mathrix-rails 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3e6d1c1ef7ab4ff5dd7b7e8a444a90b97d734a8e
+  data.tar.gz: 7437f39820aa79d2203b210fb222175cb3772765
+SHA512:
+  metadata.gz: b50a7f3bdb0d324ddc33d764802a334e7cf1c3867199a4683d536bcfeb5d310936d676158d6749503d9bb1f6825a5da6abf46ffaeceb11f16a52d47294e65544
+  data.tar.gz: 43f8df145d5141ee56f06ede4ea29231f899f80561ab8960e0968f26c3e30b1024be631c0ccf3320a8c877af5c417224d34b591430f2d8942c1892dce4b86d29

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,24 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'JMathsRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+

data/lib/assets/javascripts/mathrix/index.js

@@ -0,0 +1,3 @@
+//= require_directory ./lib
+//= require_tree ./lib
+//= require_tree .

data/lib/assets/javascripts/mathrix/lib/extensions/array.js

@@ -0,0 +1,33 @@
+(function($) {
+    "use strict";
+
+    try {
+        Object.defineProperties($.prototype, {
+
+            areMultiples: {
+                value: function() {
+                    var
+                        clone = this.clone();
+
+                    clone.shift();
+                    return Number.prototype.areMultiples.apply(this[0], clone);
+                }
+            },
+
+            min: {
+                value: function() {
+                    return Math.min.apply(null, this);
+                }
+            },
+
+            max: {
+                value: function() {
+                    return Math.max.apply(null, this);
+                }
+            }
+
+        });
+
+    } catch(e) {}
+
+})(Array);

data/lib/assets/javascripts/mathrix/lib/extensions/math.js

@@ -0,0 +1,140 @@
+(function($) {
+    "use strict";
+
+
+    try {
+        Object.defineProperties($, {
+
+            // greatest common divisor
+            GCD: {
+                value: function() {
+                    var
+                        iterator,
+                        primeFactor = 2,
+                        product = 1,
+                        i = 0,
+                        amount = 0,
+                        remains = [],
+
+                        everyoneAreMultipleOf = function(remains, factor) {
+                            var
+                                i = 0;
+
+                            while(i < remains.length) {
+                                if (!remains[i++].multipleOf(factor)) {
+                                    return false;
+                                }
+                            }
+
+                            return true;
+                        },
+
+                        callback = function(r) {
+                            primeFactor = iterator.primeFactor();
+                            if(everyoneAreMultipleOf(r, primeFactor)) {
+                                product *= primeFactor;
+                            }
+                        },
+
+                        euclidesAlgorithm = function(a, b) {
+                            var
+                                rest = b;
+
+                            while(rest !== 0) {
+                               rest = a % b;
+                               a = b;
+                               b = rest;
+                            }
+
+                            return a;
+                        };
+
+                    remains = Array.from(arguments);
+                    remains = remains.uniq();
+                    if(remains.length == 1) {
+                        return remains[0];
+                    }
+
+                    // properties
+
+                    // se todos os números forem múltiplos entre si, o MDC será menor deles
+                    if(remains.areMultiples()) {
+                        return remains.min();
+                    }
+
+                    // o algorítmo de Euclides é mais eficiente para calcular o MDC entre apenas dois números
+                    if(remains.length == 2) {
+                        return euclidesAlgorithm(remains[0], remains[1]);
+                    }
+
+                    // dois números primos não são múltiplos entre si
+                    i = 0;
+                    while(true) {
+                        if((remains[i]).isPrime()) {amount++;}
+                        if(amount >= 2) {return 1;}
+                        if(i == remains.length -1) {break;}
+                        i++;
+                    }
+
+                    iterator = Math.PrimeFactorsDecomposition.Proxy
+                        .new(remains);
+                    iterator.decompose(callback);
+
+                    return product;
+                }
+            },
+
+            // least common multiple
+            LCM: {
+                value: function() {
+                    var
+                        iterator,
+                        primeFactor = 2,
+                        remains = [],
+                        product = 1,
+
+                        callback = function() {
+                            primeFactor = iterator.primeFactor();
+                            product *= primeFactor;
+                        },
+
+                        for2Factors = function(numbers) {
+                            var
+                                product = 1,
+
+                                callback = function(v) {
+                                    product *= v;
+                                };
+
+                            numbers.forEach(callback);
+
+                            return product/Math.GCD.apply(null, numbers);
+                        };
+
+                    remains = Array.from(arguments);
+                    remains = remains.uniq();
+                    if(remains.length == 1) {
+                        return remains[0];
+                    }
+
+                    if(remains.areMultiples()) {
+                        return remains.max();
+                    }
+
+                    if(remains.length == 2) {
+                        return for2Factors(remains);
+                    }
+
+                    iterator = Math.PrimeFactorsDecomposition.Proxy
+                        .new(remains);
+                    iterator.decompose(callback);
+
+                    return product;
+                }
+            }
+
+        });
+
+    } catch(e) {}
+
+})(Math);

data/lib/assets/javascripts/mathrix/lib/extensions/math/prime_factors_decomposition.js

@@ -0,0 +1,219 @@
+var
+    Iterable,
+    Map;
+
+(function($module) {
+    "use strict";
+
+    var
+        Iterator_ = function(collection) {
+            var
+                iteration = -1,
+                primeFactor = 2,
+                remains = collection.clone(),
+                primeFactors = [],
+                quotients = [],
+                decomposition = new Map(),
+
+                hasSomeMultipleOf = function(remains, factor) {
+                    var
+                        i = 0;
+
+                    while(i < remains.length) {
+                        if (remains[i++].multipleOf(factor)) {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                },
+
+                resolveFactor = function(remains) {
+                    if (remains.amount(1) < remains.length) {
+                        while(!hasSomeMultipleOf(remains, primeFactor)) {
+                            primeFactor = primeFactor.nextPrimeFactor();
+                        }
+                    } else {
+                        primeFactor = 1;
+                    }
+
+                    return primeFactor;
+                },
+
+                resolveDecomposition = function(reference) {
+                    if (reference.hasNext()) {
+                        reference.decompose();
+                    }
+                };
+
+            this.primeFactor = function() {
+                return primeFactor;
+            };
+
+            this.next = function() {
+                var
+                    i,
+                    clone,
+                    iterator = Iterable.Proxy.new(remains),
+
+                    callback = function(n) {
+                        i = iterator.index();
+                        if (n.multipleOf(primeFactor)) {
+                            remains[i] /= primeFactor;
+                        }
+                    };
+
+                if (this.hasNext()) {
+                    iteration += 1;
+                    if(iteration === 0) {
+                        return remains;
+                    }
+
+                    primeFactors.push(primeFactor);
+
+                    iterator.each(callback);
+
+                    resolveFactor(remains);
+
+                    clone = remains.clone();
+                    decomposition.set(clone, primeFactor);
+                    quotients.push(clone);
+
+                    return remains;
+                }
+
+                return undefined;
+
+            };
+
+            this.hasNext = function() {
+                return primeFactor > 1;
+            };
+
+            this.primeFactors = function() {
+                resolveDecomposition(this);
+
+                return primeFactors;
+            };
+
+            this.reset = function() {
+                remains = collection.clone();
+                iteration = -1;
+                primeFactor = 2;
+            };
+
+            this.finalize = function() {
+                primeFactor = 1;
+            };
+
+            this.decompose = function(callback) {
+                if (typeof callback != "function") {
+                    callback = function(){};
+                }
+
+                while (this.hasNext(remains)) {
+                    callback.call(collection, this.next());
+                }
+
+                return decomposition;
+            };
+
+            this.decomposition = function() {
+                resolveDecomposition(this);
+
+                return decomposition;
+            };
+
+            this.quotients = function() {
+                resolveDecomposition(this);
+
+                return quotients;
+            };
+
+            resolveFactor(remains);
+            decomposition.set(remains.clone(), primeFactor);
+        };
+
+    try {
+        Object.defineProperties($module, {
+            PrimeFactorsDecomposition: {
+                value: {}
+            }
+        });
+    } catch(e) {}
+
+    try {
+        Object.defineProperties($module.PrimeFactorsDecomposition, {
+            Proxy: {
+                value: {}
+            }
+        });
+    } catch(e) {}
+
+    try {
+        Object.defineProperties($module.PrimeFactorsDecomposition.Proxy, {
+            new: {
+                value: function(numbers, callback) {
+                    var
+                        collection,
+                        _iterator,
+                        self = $module.PrimeFactorsDecomposition.Proxy,
+                        argumentsAsArray = Array.from(arguments);
+
+                    if (!(this instanceof self.new)) {
+                        return new self.new(numbers, callback);
+                    }
+
+                    if (typeof argumentsAsArray[argumentsAsArray.length - 1] ==
+                        "function") {
+                        collection = argumentsAsArray
+                            .slice(0, argumentsAsArray.length - 1);
+                    } else {
+                        collection = argumentsAsArray.flatten().compact();
+                    }
+
+                    _iterator = new Iterator_(collection);
+
+                    this.primeFactor = function() {
+                        return _iterator.primeFactor();
+                    };
+
+                    this.primeFactors = function() {
+                        return _iterator.primeFactors();
+                    };
+
+                    this.next = function() {
+                        return _iterator.next();
+                    };
+
+                    this.reset = function() {
+                        _iterator.reset();
+                    };
+
+                    this.finalize = function() {
+                        _iterator.finalize();
+                    };
+
+                    this.hasNext = function() {
+                        return _iterator.hasNext();
+                    };
+
+                    this.decompose = function(callback) {
+                        return _iterator.decompose(callback);
+                    };
+
+                    this.decomposition = function() {
+                        return _iterator.decomposition();
+                    };
+
+                    this.quotients = function() {
+                        return _iterator.quotients();
+                    };
+
+                    return this;
+                }
+            }
+        });
+    } catch(e) {}
+
+})(Math);

data/lib/assets/javascripts/mathrix/lib/extensions/number.js

@@ -0,0 +1,196 @@
+(function($) {
+    "use strict";
+
+    try {
+        Object.defineProperties($.prototype, {
+            nextPrimeFactor: {
+                value: function() {
+                    var
+                        value = this;
+
+                    while(!(++value).isPrime()) {}
+
+                    return value;
+                }
+            },
+
+            // Para futuras implementações, como retorno de fatores primos de determinado valor, podemos usar um algorítmo determinístico como os dos dois links abaixo
+            // É interessante calcular somente os fatores primos que caberiam para determinado número ao invés de testar com todo número natural até chegar a ele, e salvá-los em i como um array, e no if calcular o retorno 0 somente para estes. Devendo o próprio número ser retornado caso não haja quantidade de múltiplos maior que 1, pois 1 e ele mesmo não deverão entrar no vetor para ser calculado.
+
+            // http://pt.wikipedia.org/wiki/Crivo_de_Erat%C3%B3stenes
+            // http://pt.wikipedia.org/wiki/Teste_de_primalidade_AKS
+
+            // dá para usar com gcd
+            primeFactors: {
+                value: function() {
+                    var
+                        factors = [],
+                        n = parseFloat(this);
+
+                    if(n < 0) {n = Math.abs(n);}
+
+                    while(true) {
+                        factors.push(n.firstMultiple());
+                        n = n/n.firstMultiple();
+                        if(n == 1) {break;}
+                    }
+
+                    return factors;
+                }
+            },
+
+            multipleOf: {
+                value: function(numbers) {
+                    var
+                        args = Array.from(arguments),
+                        i = 0,
+                        n = parseFloat(this),
+
+                        callback = function(item, i) {
+                            return parseFloat(Math.abs(arguments[i]));
+                        };
+
+                    args = args.map(callback);
+
+                    if(args.length === 0) {return true;}
+
+                    i = 0;
+                    while(true) {
+                        if(args[i] > n || n % args[i] !== 0) {return false;}
+                        if(i == args.length -1) {break;}
+                        i++;
+                    }
+
+                    return true;
+                }
+            },
+
+            areMultiples: {
+                value: function(numbers) {
+                    var
+                        current,
+                        i = 0,
+                        args = Array.from(arguments);
+
+                    args.push(this);
+                    args = args.uniq().desc();
+                    current = parseFloat(args.shift());
+                    while(true) {
+                        while(true) {
+                            if(!current.multipleOf(args[i++])) {return false;}
+                            if (i == args.length) {break;}
+                        }
+
+                        i = 0;
+                        current = args.delete(i);
+                        if(!args.length) {break;}
+                    }
+
+                    return true;
+                }
+            },
+
+            isPrime: {
+                value: function() {
+                    var
+                        amount = 2,
+                        i = amount,
+                        n = parseFloat(this);
+
+                    if(n < 0) {n = Math.abs(n);}
+                    if(n == 1) {return false;}
+                    if(n < 1 || n == 2) {return true;}
+
+                    while(true) {
+                        if (i == n || amount > 2) {break;}
+                        if (n.multipleOf(i)) {amount++;}
+                        i++;
+                    }
+
+                    if(amount == 2) {
+                        return true;
+                    } else {
+                        return false;
+                    }
+                }
+            },
+
+            multiples: {
+                value: function() {
+                    var
+                        n = parseFloat(this),
+                        i = 1,
+                        multiples = [];
+
+                    if(n === 0) {return ["∞"];}
+                    if(n < 0) {n = Math.abs(n);}
+                    if(n.isPrime()) {return [1, n];}
+
+                    while(true) {
+                        if(n.multipleOf(i)) {multiples.push(i);}
+                        if(i == n) {break;}
+                        i++;
+                    }
+
+                    return multiples;
+                }
+            },
+
+            firstMultiple: {
+                value: function() {
+                    var
+                        i = 2,
+                        n = parseFloat(this);
+
+                    if (n < 0) {n = Math.abs(n);}
+                    if (n <= 1) {return n;}
+
+                    while(true) {
+                        if(n.multipleOf(i)) {
+                            return i;
+                        }
+                        i++;
+
+                    }
+                }
+            },
+
+            fraction: {
+                value: function(places) {
+                    var
+                        numerator,
+                        dLength,
+                        n = parseFloat(this),
+                        denominator = '1',
+                        gcd = 1,
+                        i = 1;
+
+                    if( places && places <= 10 ) {
+                        n = parseFloat(n.toFixed(places));
+                    } else if(((n.toString().split('.') )[1]).toString()
+                              .length > 10) {
+                        n = parseFloat( n.toFixed(10) );
+                    }
+
+                    n = n.toString().split('.');
+                    dLength = n[1].length;
+                    numerator = parseInt(n[0]+n[1]);
+
+                    while(true) {
+                        denominator += '0';
+                        if(i == dLength) {break;}
+                        i++;
+                    }
+
+                    denominator = parseInt(denominator);
+                    gcd = Math.gcd(numerator, denominator);
+
+                    return (numerator/gcd).toString() + '/' + (denominator/gcd)
+                        .toString();
+                }
+            }
+        });
+
+    } catch(e) {}
+
+})(Number);

data/lib/assets/javascripts/mathrix/samples/array.js

@@ -0,0 +1,35 @@
+// // faz o mesmo que _arr = _arr.sort(function(a, b) {return a-b;});
+// // ordena através do método "insertion sort". Se a-b retornar um valor menor que 0 então a é menor que b, se 0 então a é iguala b, se maior que zero, por conseguinte, a é maior que b, e assim ordenará em ordem crescente
+// Array.prototype.insertionSort = function() {
+//     var
+//         sort = this,
+//         aux,
+//         i = 0,
+//         count = 0
+//     ;
+
+//     while(true) {
+//         if(count === sort.length -1) {break;}
+//         while(true) {
+//             i = count;
+//             if( sort[i] > sort[i+1] ) { //0, 1
+//                 aux = sort[i];
+//                 sort[i] = sort[i+1];
+//                 sort[i+1] = aux;
+//                 while(true) {
+//                     if(i === 0 || sort[i] > sort[i-1]) {break;}
+//                     aux = sort[i];
+//                     sort[i] = sort[i-1];
+//                     sort[i-1] = aux;
+//                     i--;
+//                 }
+//             }
+//             if(i === 0 || sort[i] < sort[i+1]) {
+//                 break;
+//             }
+//         }
+//         count++;
+//     }
+
+//     return sort;
+// }

data/lib/mathrix-rails.rb

@@ -0,0 +1 @@
+require "mathrix/rails"

data/lib/mathrix/rails.rb

@@ -0,0 +1 @@
+require 'mathrix/rails/engine'

data/lib/mathrix/rails/engine.rb

@@ -0,0 +1,6 @@
+module Mathrix
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/mathrix/rails/version.rb

@@ -0,0 +1,5 @@
+module Mathrix
+  module Rails
+    VERSION = "1.0.0"
+  end
+end

data/mathrix.gemspec

@@ -0,0 +1,19 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require "mathrix/rails/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mathrix-rails"
+  s.version     = Mathrix::Rails::VERSION
+  s.authors     = ["rplaurindo"]
+  s.email       = ["rafaelplaurindo@gmail.com"]
+  s.homepage    = "https://rubygems.org/gems/mathrix-rails"
+  s.summary     = %q{Summary of Mathrix}
+  s.description = %q{Complementary mathematical methods.}
+  s.license     = "MIT"
+
+  s.files       = Dir["{bin,config,lib,vendor}/**/*", "MIT-LICENSE", "Rakefile", "README.md", "mathrix.gemspec"]
+
+  s.add_dependency 'esphinx-rails', '~> 1'
+
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: mathrix-rails
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- rplaurindo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: esphinx-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: Complementary mathematical methods.
+email:
+- rafaelplaurindo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- lib/assets/javascripts/mathrix/index.js
+- lib/assets/javascripts/mathrix/lib/extensions/array.js
+- lib/assets/javascripts/mathrix/lib/extensions/math.js
+- lib/assets/javascripts/mathrix/lib/extensions/math/prime_factors_decomposition.js
+- lib/assets/javascripts/mathrix/lib/extensions/number.js
+- lib/assets/javascripts/mathrix/samples/array.js
+- lib/mathrix-rails.rb
+- lib/mathrix/rails.rb
+- lib/mathrix/rails/engine.rb
+- lib/mathrix/rails/version.rb
+- mathrix.gemspec
+homepage: https://rubygems.org/gems/mathrix-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Summary of Mathrix
+test_files: []