symbolic 0.2.2 → 0.2.3

data/README.rdoc

@@ -8,8 +8,6 @@ gem install symbolic
 
 Symbolic math can be really helpful if you want to simplify some giant equation or if you don't want to get a performance hit re-evaluating big math expressions every time when few variables change.
 
-Currently I've implemented only naive optimizations to simplify math expressions, but it's pretty simple to add your own - see Symbolic::Optimization module for examples.
-
 == Examples:
   x = var :name => 'x'
   y = var :name => 'y'

data/Rakefile

@@ -5,7 +5,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "symbolic"
-    gem.version = '0.2.2'
+    gem.version = '0.2.3'
     gem.summary = 'Symbolic math for ruby'
     gem.description = %Q{Symbolic math can be really helpful if you want to simplify some giant equation or if you don't want to get a performance hit re-evaluating big math expressions every time when few variables change.}
     gem.email = "ravwar@gmail.com"

data/lib/symbolic/function.rb

@@ -1,28 +1,27 @@
-module Symbolic
-  class Function
-    include Symbolic
-    def initialize(variable, operation)
-      @variable, @operation = variable, operation
-    end
+class Symbolic::Function
+  include Symbolic
 
-    def to_s
-      "#{@operation}(#{@variable})"
-    end
+  def initialize(variable, operation)
+    @variable, @operation = variable, operation
+  end
+
+  def to_s
+    "#{@operation}(#{@variable})"
+  end
 
-    def value
-      Math.send @operation, @variable.value if undefined_variables.empty?
-    end
+  def value
+    Math.send @operation, @variable.value if undefined_variables.empty?
+  end
 
-    def variables
-      @variable.variables
-    end
+  def variables
+    @variable.variables
+  end
 
-    def undefined_variables
-      @variable.undefined_variables
-    end
+  def undefined_variables
+    @variable.undefined_variables
+  end
 
-    def detailed_operations
-      @variable.detailed_operations.tap {|it| it[@operation] += 1}
-    end
+  def detailed_operations
+    @variable.detailed_operations.tap {|it| it[@operation] += 1}
   end
 end

data/lib/symbolic/operation.rb

@@ -18,6 +18,7 @@ class Symbolic::Operation
     when Binary::Subtraction    then :subtraction
     when Binary::Multiplication then :multiplication
     when Binary::Division       then :division
+    when Binary::Exponentiation then :exponentiation
     when Symbolic::Variable     then :variable
     end
   end

data/lib/symbolic/operation/binary/division.rb

@@ -20,6 +20,6 @@ class Symbolic::Operation::Binary::Division < Symbolic::Operation::Binary
   end
 
   def brackets_for
-    [:unary_minus, :addition, :subtraction]
+    [:addition, :subtraction]
   end
 end

data/lib/symbolic/operation/binary/exponentiation.rb

@@ -1,10 +1,14 @@
 class Symbolic::Operation::Binary::Exponentiation < Symbolic::Operation::Binary
   def self.simplify_first_arg(var1, var2)
-    # add conditional for negative?(var1) and even or odd values of var2
     if var1 == 0
       0
     elsif var1 == 1
       1
+    elsif negative?(var1) && var2.respond_to?(:even?)
+      without_sign = var1.abs ** var2
+      var2.even? ? without_sign : -without_sign
+    elsif operation(var1) == :exponentiation
+      var1.send(:base) ** (var1.send(:exponent) * var2)
     end
   end
 
@@ -23,4 +27,9 @@ class Symbolic::Operation::Binary::Exponentiation < Symbolic::Operation::Binary
   def sign
     '**'
   end
+
+  private
+
+  alias base var1
+  alias exponent var2
 end

data/lib/symbolic/operation/binary/multiplication.rb

@@ -1,44 +1,84 @@
-class Symbolic::Operation::Binary::Multiplication < Symbolic::Operation::Binary
-  symmetric
-
-  def self.simplify_first_arg(var1, var2)
-    if var1 == 0
-      0
-    elsif var1 == 1
-      var2
-    elsif negative?(var1)
-      -(var1.abs * var2)
+class Symbolic::Operation
+  class Binary::Multiplication < Binary
+
+    class << self
+      def for(var1, var2)
+        # TODO: def -@(var); -1 * var; end
+        sign1, var1 = sign_and_modulus var1
+        sign2, var2 = sign_and_modulus var2
+        sign = (sign1 == sign2) ? :+@ : :-@
+
+        factors = unite factors(var1), factors(var2)
+        (simplify(factors) || new(factors)).send sign
+      end
+
+      def simplify(factors)
+        factors.first if factors.length == 1
+      end
+
+      def unite(factors1, factors2)
+        numeric = extract_numeric!(factors1) * extract_numeric!(factors2)
+        return [0] if numeric == 0
+        factors = unite_by_exponent factors1, factors2
+        factors.unshift(numeric) if numeric != 1 || factors.empty?
+        factors
+      end
+
+      def unite_by_exponent(factors1, factors2)
+        exponents(factors1).
+          merge(exponents factors2) {|base,exponent1,exponent2| exponent1 + exponent2 }.
+          delete_if {|base, exponent| exponent == 0 }.
+          map {|base, exponent| base**exponent }
+      end
+
+      def exponents(factors)
+        exponents = factors.map {|it| base_and_exponent it }
+        Hash[exponents]
+      end
+
+      def base_and_exponent(var)
+        var.is_a?(Binary::Exponentiation) ? [var.send(:base), var.send(:exponent)] : [var, 1]
+      end
+
+      def extract_numeric!(factors)
+        factors.first.is_a?(Numeric) ? factors.shift : 1
+      end
+
+      def sign_and_modulus(var)
+        negative?(var) ? [:-@, var.abs] : [:+@, var]
+      end
+
+      def factors(var)
+        var.respond_to?(:factors) ? var.send(:factors) : [var]
+      end
     end
-  end
 
-  def sign
-    '*'
-  end
+    def sign
+      '*'
+    end
 
-  def brackets_for
-    [:unary_minus, :addition, :subtraction]
-  end
-  # def initialize(var1, var2)
-  #   super
-  #   coef, numerators, denominators = unite_factors factors_of(var1), factors_of(var2)
-  # end
-
-  def unite_factors(factors1, factors2)
-    c1, n1, d1 = factors1
-    c2, n2, d2 = factors2
-    return c1*c2, n1+n2, d1+d2
-  end
+    def brackets_for
+      [:addition, :subtraction]
+    end
+
+    def initialize(factors)
+      @factors = factors
+    end
 
-  def factors_of(var)
-    case var
-    when Numeric
-      [var, [], []]
-    when Unary::Minus
-      unite_factors [-1, [], []], factors_of(var.abs)
-    when Binary::Multiplication
-      [var.coef, var.nominators, var.denominators]
-    else
-      [[], [var], []]
+    def variables
+      @factors.map(&:variables).flatten.uniq
     end
+
+    def value
+      @factors.inject(1) {|product, it| product*it.value } if undefined_variables.empty?
+    end
+
+    def to_s
+      @factors.map {|it| brackets it }.join '*'
+    end
+
+    protected
+
+    attr_reader :factors
   end
 end

data/spec/symbolic_spec.rb

@@ -90,7 +90,14 @@ describe "Symbolic" do
     '0**x'        => '0',
     '1**x'        => '1',
     'x**0'        => '1',
-    'x**1'        => 'x'
+    'x**1'        => 'x',
+    '(-x)**1'     => '-x',
+    '(-x)**2'     => 'x**2',
+    '(x**2)**y'   => 'x**(2*y)',
+
+    'x*4*x'       => '4*x**2',
+    'x*(-1)*x**(-1)' => '-1',
+    'x**2*(-1)*x**(-1)' => '-x'
   end
 
   describe 'general methods:' do
@@ -121,12 +128,12 @@ describe "Symbolic" do
     '-(x-y)' => 'y-x',
     'x*y' => 'x*y',
     '(-x)*y' => '-x*y',
-    '(x+2)*(y+3)*4' => '(x+2)*(y+3)*4',
+    '(x+2)*(y+3)*4' => '4*(x+2)*(y+3)',
     '4/x' => '4/x',
     '(-(2+x))/(-(-y))' => '(-2-x)/y',
     'x**y' => 'x**y',
     'x**(y-4)' => 'x**(y-4)',
-    '(x+1)**(y*2)' => '(x+1)**(y*2)',
+    '(x+1)**(y*2)' => '(x+1)**(2*y)',
     '-(x**y -2)+5' => '2-x**y+5'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: symbolic
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors: 
 - brainopia
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-09 00:00:00 +03:00
+date: 2009-12-11 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency