symbolic 0.1.2 → 0.1.3

data/Rakefile

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

@@ -21,48 +21,51 @@ module Symbolic
 
       private
 
-      def numerical_context(&proc)
+      def numerical_eval(*args)
         [Fixnum, Bignum, Float].each do |klass|
-          klass.class_eval &proc
+          klass.class_eval *args
         end
       end
 
       def redefine_numerical_methods
-        numerical_context do
-          Symbolic.operations.each do |operation_sign, operation_name|
-            alias_method "non_symbolic_#{operation_name}", operation_sign
+        Symbolic.operations.each do |sign, name|
+          numerical_eval numerical_method(sign,name), __FILE__, __LINE__
+        end
+      end
 
-            method = <<-CODE
-              def #{operation_sign}(value)
-                if value.is_a?(Operatable)
-                  Optimizations.#{operation_name} self, value
-                else
-                  non_symbolic_#{operation_name}(value)
-                end
-              end
-            CODE
+      def numerical_method(sign, name)
+        <<-CODE
+          alias non_symbolic_#{name} #{sign}
 
-            class_eval method, __FILE__, __LINE__
+          def #{sign}(value)
+            if value.is_a?(Operatable)
+              Optimizations.#{name} self, value
+            else
+              non_symbolic_#{name}(value)
+            end
           end
-        end # numerical_context
-      end # redefine_numerical_methods
+        CODE
+      end
 
       def redefine_math_methods
         Symbolic.math_operations.each do |operation|
-          code = <<-CODE
-            alias non_symbolic_#{operation} #{operation}
+          Math.instance_eval math_method(operation), __FILE__, __LINE__
+        end
+      end
+
+      def math_method(operation)
+        <<-CODE
+          alias non_symbolic_#{operation} #{operation}
 
-            def #{operation}(value)
-              if value.is_a? Operatable
-                Symbolic::Method.new value, :#{operation}
-              else
-                non_symbolic_#{operation} value
-              end
+          def #{operation}(value)
+            if value.is_a?(Operatable)
+              Symbolic::Method.new value, :#{operation}
+            else
+              non_symbolic_#{operation} value
             end
-          CODE
-          Math.instance_eval code, __FILE__, __LINE__
-        end
-      end # redefine_math_methods
+          end
+        CODE
+      end
 
       def restore_numerical_methods
         numerical_context do

data/lib/symbolic/optimizations/subtraction.rb

@@ -2,15 +2,14 @@ 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
+    -var2 if var1 == 0
   end
 
   def self.optimize_second_arg(var1, var2)
-    reverse_optimization = optimize_first_arg(var2, var1)
-    -reverse_optimization if reverse_optimization
+    if var2 == 0
+      var1
+    elsif negative?(var2)
+      var1 + var2.abs
+    end
   end
 end

data/lib/symbolic/optimizations.rb

@@ -1,19 +1,12 @@
 module Symbolic
   module Optimizations
-    def self.addition(var1, var2)
-      Addition.optimize(var1, var2) || Expression.new(var1, var2, '+')
-    end
-
-    def self.subtraction(var1, var2)
-      Subtraction.optimize(var1, var2) || Expression.new(var1, var2, '-')
-    end
-
-    def self.multiplication(var1, var2)
-      Multiplication.optimize(var1, var2) || Expression.new(var1, var2, '*')
-    end
-
-    def self.division(var1, var2)
-      Division.optimize(var1, var2) || Expression.new(var1, var2, '/')
+    Symbolic.operations.each do |operation_sign, operation_name|
+      method = <<-CODE
+        def #{operation_name}(var1, var2)
+          #{operation_name.to_s.capitalize}.optimize(var1, var2) || Expression.new(var1, var2, '#{operation_sign}')
+        end
+      CODE
+      instance_eval method, __FILE__, __LINE__
     end
   end
 end

data/spec/symbolic_spec.rb

@@ -61,12 +61,11 @@ describe "Symbolic" do
     '-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',
+    '-2 - (-x)'   => 'x - 2',
     'x - (-y)'    => 'x + y',
 
     '0 * x'       => '0',

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: symbolic
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - brainopia