symbolic 0.1.0 → 0.1.1

data/Rakefile

@@ -5,7 +5,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "symbolic"
-    gem.version = '0.1.0'
+    gem.version = '0.1.1'
     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.rb

@@ -14,6 +14,11 @@ end
 require 'symbolic/core'
 require 'symbolic/operatable'
 require 'symbolic/optimizations'
+require 'symbolic/optimizations/base'
+require 'symbolic/optimizations/addition'
+require 'symbolic/optimizations/subtraction'
+require 'symbolic/optimizations/multiplication'
+require 'symbolic/optimizations/division'
 require 'symbolic/variable'
 require 'symbolic/expression'
 require 'symbolic/method'

data/lib/symbolic/core.rb

@@ -35,7 +35,7 @@ module Symbolic
             method = <<-CODE
               def #{operation_sign}(value)
                 if value.is_a?(Operatable)
-                  Optimizations.#{operation_name} value, self, :reverse
+                  Optimizations.#{operation_name} self, value
                 else
                   non_symbolic_#{operation_name}(value)
                 end

data/lib/symbolic/expression.rb

@@ -34,7 +34,8 @@ module Symbolic
     end
 
     def ==(object)
-      object.var1 == @var1 && object.var2 == @var2 && object.operation == @operation
+      object.is_a?(Expression) && (object.operation == @operation) &&
+      ((object.var1 == @var1 && object.var2 == @var2) || ((%w(+ *).include? @operation) && (object.var1 == @var2 && object.var2 == @var1)))
     end
 
     private

data/lib/symbolic/optimizations.rb

@@ -1,73 +1,19 @@
 module Symbolic
   module Optimizations
-    def self.addition(symbolic_var, var, reverse=false)
-      if var == 0
-        symbolic_var
-      elsif var.is_a?(Numeric) && var < 0
-        symbolic_var - (-var)
-      elsif var.is_a? UnaryMinus
-        symbolic_var - var.variable
-      elsif symbolic_var.is_a? UnaryMinus
-        var - symbolic_var.variable
-      else
-        if reverse
-          Expression.new var, symbolic_var, '+'
-        else
-          Expression.new symbolic_var, var, '+'
-        end
-      end
+    def self.addition(var1, var2)
+      Addition.optimize(var1, var2) || Expression.new(var1, var2, '+')
     end
 
-    def self.subtraction(symbolic_var, var, reverse=false)
-      if var == 0
-        symbolic_var * (reverse ? -1 : 1)
-      elsif var.is_a? UnaryMinus
-        symbolic_var + var.variable
-      elsif !reverse && var.is_a?(Numeric) && var < 0
-        symbolic_var + (-var)
-      elsif reverse && symbolic_var.is_a?(UnaryMinus)
-        var + symbolic_var.variable
-      else
-        if reverse
-          Expression.new var, symbolic_var, '-'
-        else
-          Expression.new symbolic_var, var, '-'
-        end
-      end
+    def self.subtraction(var1, var2)
+      Subtraction.optimize(var1, var2) || Expression.new(var1, var2, '-')
     end
 
-    def self.multiplication(symbolic_var, var, reverse=false)
-      if var == 0
-        var
-      elsif var == 1
-        symbolic_var
-      elsif var == -1
-        -symbolic_var
-      elsif var.is_a?(Numeric) && var < 0
-        -(-var*symbolic_var)
-      elsif var.is_a? UnaryMinus
-        UnaryMinus.create symbolic_var*var.variable
-      elsif symbolic_var.is_a? UnaryMinus
-        UnaryMinus.create symbolic_var.variable*var
-      else
-        if reverse
-          Expression.new var, symbolic_var, '*'
-        else
-          Expression.new symbolic_var, var, '*'
-        end
-      end
+    def self.multiplication(var1, var2)
+      Multiplication.optimize(var1, var2) || Expression.new(var1, var2, '*')
     end
 
-    def self.division(symbolic_var, var, reverse=false)
-      if var == 1
-        symbolic_var
-      else
-        if reverse
-          Expression.new var, symbolic_var, '/'
-        else
-          Expression.new symbolic_var, var, '/'
-        end
-      end
+    def self.division(var1, var2)
+      Division.optimize(var1, var2) || Expression.new(var1, var2, '/')
     end
   end
 end

data/lib/symbolic/optimizations/addition.rb

@@ -0,0 +1,15 @@
+module Symbolic::Optimizations::Addition
+  extend Symbolic::Optimizations::Base
+
+  def self.optimize_first_arg(var1, var2)
+    if var1 == 0
+      var2
+    elsif negative?(var1)
+      var2 - var1.abs
+    end
+  end
+
+  def self.optimize_second_arg(var1, var2)
+    optimize_first_arg var2, var1
+  end
+end

data/lib/symbolic/optimizations/base.rb

@@ -0,0 +1,9 @@
+module Symbolic::Optimizations::Base
+  def optimize(var1, var2)
+    optimize_first_arg(var1, var2) || optimize_second_arg(var1, var2)
+  end
+
+  def negative?(var)
+    var.is_a?(Symbolic::UnaryMinus) || (var.is_a?(Numeric) && var < 0)
+  end
+end

data/lib/symbolic/optimizations/division.rb

@@ -0,0 +1,19 @@
+module Symbolic::Optimizations::Division
+  extend Symbolic::Optimizations::Base
+
+  def self.optimize_first_arg(var1, var2)
+    if var1 == 0
+      0
+    elsif negative?(var1)
+      -(var1.abs / var2)
+    end
+  end
+
+  def self.optimize_second_arg(var1, var2)
+    if var2 == 1
+      var1
+    elsif negative?(var2)
+      -(var1 / var2.abs)
+    end
+  end
+end

data/lib/symbolic/optimizations/multiplication.rb

@@ -0,0 +1,17 @@
+module Symbolic::Optimizations::Multiplication
+  extend Symbolic::Optimizations::Base
+
+  def self.optimize_first_arg(var1, var2)
+    if var1 == 0
+      0
+    elsif var1 == 1
+      var2
+    elsif negative?(var1)
+      -(var1.abs * var2)
+    end
+  end
+
+  def self.optimize_second_arg(var1, var2)
+    optimize_first_arg var2, var1
+  end
+end

data/lib/symbolic/optimizations/subtraction.rb

@@ -0,0 +1,16 @@
+module Symbolic::Optimizations::Subtraction
+  extend Symbolic::Optimizations::Base
+
+  def self.optimize_first_arg(var1, var2)
+    if var1 == 0
+      -var2
+    elsif negative?(var1)
+      -(var1.abs + var2)
+    end
+  end
+
+  def self.optimize_second_arg(var1, var2)
+    reverse_optimization = optimize_first_arg(var2, var1)
+    -reverse_optimization if reverse_optimization
+  end
+end

data/lib/symbolic/unary_minus.rb

@@ -3,6 +3,7 @@ module Symbolic
     attr_reader :variable
 
     def self.create(expression)
+      # move to optimizations module
       if expression.is_a? UnaryMinus
         expression.variable
       else
@@ -22,6 +23,10 @@ module Symbolic
       end
     end
 
+    def abs
+      @variable
+    end
+
     def value
       -@variable.value if undefined_variables.empty?
     end

data/spec/symbolic_spec.rb

@@ -11,36 +11,36 @@ describe "Symbolic" do
   end
 
   describe "evaluation (x=1, y=2):" do
-    def self.should_evaluate_to(conditions)
-      conditions.each do |symbolic_expression, result|
-        it symbolic_expression do
-          expression(symbolic_expression).value.should == result
-        end
-      end
-    end
+     def self.should_evaluate_to(conditions)
+       conditions.each do |symbolic_expression, result|
+         it symbolic_expression do
+           expression(symbolic_expression).value.should == result
+         end
+       end
+     end
 
-    should_evaluate_to \
-    'x'         => 1,
-    'y'         => 2,
-    '+x'        => 1,
-    '-x'        => -1,
-    'x + 4'     => 5,
-    '3 + x'     => 4,
-    'x + y'     => 3,
-    'x - 1'     => 0,
-    '1 - x'     => 0,
-    'x - y'     => -1,
-    '-x + 3'    => 2,
-    '-y - x'    => -3,
-    'x*3'       => 3,
-    '4*y'       => 8,
-    '(+x)*(-y)' => -2,
-    'x/2'       => 0,
-    'y/2'       => 1,
-    'x/2.0'     => 0.5,
-    '-2/x'      => -2,
-    '4/(-y)'    => -2
-  end
+     should_evaluate_to \
+     'x'         => 1,
+     'y'         => 2,
+     '+x'        => 1,
+     '-x'        => -1,
+     'x + 4'     => 5,
+     '3 + x'     => 4,
+     'x + y'     => 3,
+     'x - 1'     => 0,
+     '1 - x'     => 0,
+     'x - y'     => -1,
+     '-x + 3'    => 2,
+     '-y - x'    => -3,
+     'x*3'       => 3,
+     '4*y'       => 8,
+     '(+x)*(-y)' => -2,
+     'x/2'       => 0,
+     'y/2'       => 1,
+     'x/2.0'     => 0.5,
+     '-2/x'      => -2,
+     '4/(-y)'    => -2
+   end
 
   describe "optimization:" do
     def self.should_equal(conditions)
@@ -52,36 +52,37 @@ describe "Symbolic" do
     end
 
     should_equal \
-    '-(-x)' => 'x',
+    '-(-x)'       => 'x',
 
-    '0 + x' => 'x',
-    'x + 0' => 'x',
-    'x + (-2)' => 'x - 2',
-    '-2 + x' => 'x - 2',
-    '-x + 2' => '2 - x',
-    'x + (-y)' => 'x - y',
-    '-y + x' => 'x - y',
+    '0 + x'       => 'x',
+    'x + 0'       => 'x',
+    'x + (-2)'    => 'x - 2',
+    '-2 + x'      => 'x - 2',
+    '-x + 2'      => '2 - x',
+    'x + (-y)'    => 'x - y',
+    '-y + x'      => 'x - y',
+    '-y + (-x)'   => '-(y + x)',
 
-    '0 - x' => '-x',
-    'x - 0' => 'x',
-    'x - (-2)' => 'x + 2',
-    '-2 - (-x)' => 'x - 2',
-    'x - (-y)' => 'x + y',
+    '0 - x'       => '-x',
+    'x - 0'       => 'x',
+    'x - (-2)'    => 'x + 2',
+    # '-2 - (-x)'   => 'x - 2',
+    'x - (-y)'    => 'x + y',
 
-    '0 * x' => '0',
-    'x * 0' => '0',
-    '1 * x' => 'x',
-    'x * 1' => 'x',
-    '-1 * x' => '-x',
-    'x * (-1)' => '-x',
-    'x * (-3)' => '-(x*3)',
-    '-3 * x' => '-(x*3)',
-    '-3 * (-x)' => 'x*3',
-    'x*(-y)' => '-(x*y)',
-    '-x*y' => '-(x*y)',
-    '(-x)*(-y)' => 'x*y',
+    '0 * x'       => '0',
+    'x * 0'       => '0',
+    '1 * x'       => 'x',
+    'x * 1'       => 'x',
+    '-1 * x'      => '-x',
+    'x * (-1)'    => '-x',
+    'x * (-3)'    => '-(x*3)',
+    '-3 * x'      => '-(x*3)',
+    '-3 * (-x)'   => 'x*3',
+    'x*(-y)'      => '-(x*y)',
+    '-x*y'        => '-(x*y)',
+    '(-x)*(-y)'   => 'x*y',
 
-    'x / 1' => 'x'
+    'x / 1'       => 'x'
   end
 
   describe "formulas" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: symbolic
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - brainopia
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-25 00:00:00 +03:00
+date: 2009-11-28 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,6 +41,11 @@ files:
 - lib/symbolic/method.rb
 - lib/symbolic/operatable.rb
 - lib/symbolic/optimizations.rb
+- lib/symbolic/optimizations/addition.rb
+- lib/symbolic/optimizations/base.rb
+- lib/symbolic/optimizations/division.rb
+- lib/symbolic/optimizations/multiplication.rb
+- lib/symbolic/optimizations/subtraction.rb
 - lib/symbolic/unary_minus.rb
 - lib/symbolic/variable.rb
 - spec/spec.opts