symbolic 0.0.6 → 0.1.0

data/README.rdoc

@@ -1,14 +1,16 @@
 Symbolic math for ruby.
 
-Installation:
+== Installation:
+
 gem install symbolic
 
-Introduction:
+== Introduction:
+
 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::Optimizations module for examples.
 
-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.0.6'
+    gem.version = '0.1.0'
     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/expression.rb

@@ -1,18 +1,14 @@
 module Symbolic
   class Expression < Operatable
+    attr_reader :var1, :var2, :operation
+
     def initialize(var1, var2, operation)
       var1, var2 = var2, var1 if operation == '*' && var2.is_a?(Numeric)
       @var1, @var2, @operation = var1, var2, operation
     end
 
     def to_s
-      var1 = "#{@var1}"
-      var2 = "#{@var2}"
-      if ['*', '/'].include? @operation
-        var1 = "(#{@var1})" if @var1.is_a?(Expression) && (@var1.plus? || @var1.minus?) || @var1.is_a?(UnaryMinus)
-        var2 = "(#{@var2})" if @var2.is_a?(Expression) && (@var2.plus? || @var2.minus?) || @var2.is_a?(UnaryMinus)
-      end
-      "#{var1}#{@operation}#{var2}"
+      "#{brackets @var1}#{@operation}#{brackets @var2}"
     end
 
     def plus?
@@ -37,8 +33,20 @@ module Symbolic
       (undefined_variables_of(@var1) + undefined_variables_of(@var2)).uniq
     end
 
+    def ==(object)
+      object.var1 == @var1 && object.var2 == @var2 && object.operation == @operation
+    end
+
     private
 
+    def brackets(var)
+      brackets_conditional(var) ? "(#{var})" : var.to_s
+    end
+
+    def brackets_conditional(var)
+      %w(* /).include?(@operation) && (var.is_a?(UnaryMinus) || var.is_a?(Expression) && (var.plus? || var.minus?))
+    end
+
     def undefined_variables_of(variable)
       variable.is_a?(Operatable) ? variable.undefined_variables : []
     end

data/lib/symbolic/optimizations.rb

@@ -3,9 +3,11 @@ module Symbolic
     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 reverse && symbolic_var.is_a?(UnaryMinus)
+      elsif symbolic_var.is_a? UnaryMinus
         var - symbolic_var.variable
       else
         if reverse
@@ -18,9 +20,11 @@ module Symbolic
 
     def self.subtraction(symbolic_var, var, reverse=false)
       if var == 0
-        symbolic_var
+        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

data/lib/symbolic/unary_minus.rb

@@ -29,5 +29,9 @@ module Symbolic
     def undefined_variables
       @variable.undefined_variables
     end
+
+    def ==(object)
+      object.is_a?(UnaryMinus) && object.variable == @variable
+    end
   end
 end

data/lib/symbolic/variable.rb

@@ -5,7 +5,7 @@ module Symbolic
     @@index = 0
 
     def initialize(options)
-      unless @name = options[:name]
+      unless @name = options[:name].to_s
         @@index += 1
         @name = "var#{@@index}"
       end

data/spec/symbolic_spec.rb

@@ -1,43 +1,89 @@
 require File.expand_path(File.dirname(__FILE__) +'/spec_helper')
 
 describe "Symbolic" do
-  def self.x
-    var :value => 1, :name => 'x'
+  before(:all) do
+    @x = var :name => :x, :value => 1
+    @y = var :name => :y, :value => 2
   end
 
-  def self.y
-    var :value => 2, :name => 'y'
+  def expression(string)
+    eval string.gsub(/[a-z]+/, '@\0')
   end
 
   describe "evaluation (x=1, y=2):" do
-    def self.check_evaluation(conditions)
+    def self.should_evaluate_to(conditions)
       conditions.each do |symbolic_expression, result|
         it symbolic_expression do
-          symbolic_expression.value.should == result
+          expression(symbolic_expression).value.should == result
         end
       end
     end
 
-    check_evaluation \
-    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
+    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)
+      conditions.each do |non_optimized, optimized|
+        it non_optimized do
+          expression(non_optimized).should == expression(optimized)
+        end
+      end
+    end
+
+    should_equal \
+    '-(-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 - (-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'
+  end
+
+  describe "formulas" do
   end
 end

metadata

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