symbolic 0.2.0 → 0.2.1

data/README.rdoc

@@ -14,7 +14,7 @@ Currently I've implemented only naive optimizations to simplify math expressions
   x = var :name => 'x'
   y = var :name => 'y'
 
-  f = symbolic { (4 - 2*(-x) + y*(-1.0))*x - 0*y + 0 - 2 }
+  f = (4 - 2*(-x) + y*(-1.0))*x - 0*y + 0 - 2
   puts f # => (4+2*x-y)*x-2
 
   p f.detailed_operations # => {"+"=>1, "-"=>2, "*"=>2}
@@ -26,7 +26,7 @@ Currently I've implemented only naive optimizations to simplify math expressions
   puts f.value # => 6
 
 
-  g = symbolic { Math.cos(y) }
+  g = Symbolic::Math.cos(y)
   puts g # => cos(y)
   y.value = 0
   puts g.value # => 1.0

data/Rakefile

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

@@ -1,57 +1,58 @@
+Symbolic = Module.new
+
+require 'symbolic/operation'
+require 'symbolic/operation/unary'
+require 'symbolic/operation/unary/minus'
+require 'symbolic/operation/binary'
+require 'symbolic/operation/binary/addition'
+require 'symbolic/operation/binary/subtraction'
+require 'symbolic/operation/binary/multiplication'
+require 'symbolic/operation/binary/division'
+require 'symbolic/operation/binary/exponentiation'
+
+require 'symbolic/coerced'
+require 'symbolic/variable'
+require 'symbolic/function'
+require 'symbolic/math'
+
+require 'extensions/kernel'
+require 'extensions/numeric'
+require 'extensions/matrix'
+
 module Symbolic
-  def self.operations
-    { :* => :multiplication,
-      :+ => :addition,
-      :- => :subtraction,
-      :/ => :division }
+  def -@
+    Operation::Unary::Minus.for self
   end
 
-  operations.each do |sign, name|
-    method = <<-CODE
-      def #{sign}(value)
-        Optimization.#{name} self, value
-      end
-    CODE
-    class_eval method, __FILE__, __LINE__
+  def +@
+    self
   end
 
-  def self.math_operations
-    [:cos, :sin]
+  def +(var)
+    Operation::Binary::Addition.for self, var
   end
 
-  def -@
-    UnaryMinus.create self
+  def -(var)
+    Operation::Binary::Subtraction.for self, var
   end
 
-  def +@
-    self
+  def *(var)
+    Operation::Binary::Multiplication.for self, var
   end
 
-  def coerce(numeric)
-    return Coerced.new(self), numeric
+  def /(var)
+    Operation::Binary::Division.for self, var
+  end
+
+  def **(var)
+    Operation::Binary::Exponentiation.for self, var
   end
 
-  def undefined?
-    !value
+  def coerce(numeric)
+    return Coerced.new(self), numeric
   end
 
   def operations
     detailed_operations.values.inject(0) {|sum,it| sum + it }
   end
-end
-
-require 'symbolic/coerced'
-require 'symbolic/optimization'
-require 'symbolic/optimization/base'
-require 'symbolic/optimization/addition'
-require 'symbolic/optimization/subtraction'
-require 'symbolic/optimization/multiplication'
-require 'symbolic/optimization/division'
-require 'symbolic/variable'
-require 'symbolic/expression'
-require 'symbolic/method'
-require 'symbolic/unary_minus'
-
-require 'extensions/kernel'
-require 'extensions/numeric'
-require 'extensions/matrix'
+end

data/lib/symbolic/coerced.rb

@@ -4,13 +4,24 @@ module Symbolic
       @symbolic = symbolic
     end
 
-    Symbolic.operations.each do |sign, name|
-      method = <<-CODE
-        def #{sign}(numeric)
-          Optimization.#{name} numeric, @symbolic
-        end
-      CODE
-      class_eval method, __FILE__, __LINE__
-    end # Symbolic.operations.each
-  end # Coerced
-end # Symbolic
+    def +(numeric)
+      Operation::Binary::Addition.for numeric, @symbolic
+    end
+
+    def -(numeric)
+      Operation::Binary::Subtraction.for numeric, @symbolic
+    end
+
+    def *(numeric)
+      Operation::Binary::Multiplication.for numeric, @symbolic
+    end
+
+    def /(numeric)
+      Operation::Binary::Division.for numeric, @symbolic
+    end
+
+    def **(numeric)
+      Operation::Binary::Exponentiation.for numeric, @symbolic
+    end
+  end
+end

data/lib/symbolic/{method.rb → function.rb}

@@ -1,7 +1,6 @@
 module Symbolic
-  class Method
+  class Function
     include Symbolic
-
     def initialize(variable, operation)
       @variable, @operation = variable, operation
     end

data/lib/symbolic/math.rb

@@ -0,0 +1,9 @@
+module Symbolic::Math
+  def self.cos(argument)
+    Symbolic::Function.new argument, :cos
+  end
+
+  def self.sin(argument)
+    Symbolic::Function.new argument, :sin
+  end
+end

data/lib/symbolic/operation.rb

@@ -0,0 +1,48 @@
+class Symbolic::Operation
+  include Symbolic
+
+  def self.for(*args)
+    simplify(*args) || new(*args)
+  end
+
+  def self.negative?(var)
+    var.is_a?(Unary::Minus) || (var.is_a?(Numeric) && var < 0)
+  end
+
+  private
+
+  def operation(expression)
+    case expression
+    when Unary::Minus           then :unary_minus
+    when Binary::Addition       then :addition
+    when Binary::Subtraction    then :subtraction
+    when Binary::Multiplication then :multiplication
+    when Binary::Division       then :division
+    when Symbolic::Variable     then :variable
+    end
+  end
+
+  def unary_minus?(expression)
+    operation(expression) == :unary_minus
+  end
+
+  def addition?(expression)
+    operation(expression) == :addition
+  end
+
+  def subtraction?(expression)
+    operation(expression) == :subtraction
+  end
+
+  def multiplication?(expression)
+    operation(expression) == :multiplication
+  end
+
+  def division?(expression)
+    operation(expression) == :division
+  end
+
+  def variable?(expression)
+    operation(expession) == :variable
+  end
+end

data/lib/symbolic/operation/binary.rb

@@ -0,0 +1,64 @@
+class Symbolic::Operation::Binary < Symbolic::Operation
+  def self.simplify(var1, var2)
+    simplify_first_arg(var1, var2) || simplify_second_arg(var1, var2)
+  end
+
+  def self.symmetric
+    def self.simplify(var1, var2)
+      simplify_first_arg(var1, var2) || simplify_first_arg(var2, var1)
+    end
+
+    def ==(object)
+      (object.class == self.class) &&
+      ((object.var1 == @var1 && object.var2 == @var2) || (object.var1 == @var2 && object.var2 == @var1))
+    end
+  end
+
+  def self.brackets_for(*operations)
+    def brackets(var)
+      operations.include?(operation var) ? "(#{var})" : var.to_s
+    end
+  end
+
+  def initialize(var1, var2)
+    @var1, @var2 = var1, var2
+  end
+
+  def variables
+    @var1.variables | @var2.variables
+  end
+
+  def undefined_variables
+    variables.select {|it| it.value.nil? }
+  end
+
+  def value
+    @var1.value.send sign, @var2.value if undefined_variables.empty?
+  end
+
+  def detailed_operations
+    operations_of(@var1).tap {|it| it.merge!(operations_of @var2)[sign] += 1 }
+  end
+
+  def to_s
+    "#{brackets @var1}#{sign}#{brackets @var2}"
+  end
+
+  def ==(object)
+    (object.class == self.class) && (object.var1 == @var1 && object.var2 == @var2)
+  end
+
+  protected
+
+  attr_reader :var1, :var2
+
+  private
+
+  def operations_of(var)
+    var.is_a?(Symbolic) ? var.detailed_operations : Hash.new(0)
+  end
+
+  def brackets(var)
+    var.to_s
+  end
+end

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

@@ -0,0 +1,15 @@
+class Symbolic::Operation::Binary::Addition < Symbolic::Operation::Binary
+  symmetric
+
+  def self.simplify_first_arg(var1, var2)
+    if var1 == 0
+      var2
+    elsif negative?(var1)
+      var2 - var1.abs
+    end
+  end
+
+  def sign
+    '+'
+  end
+end

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

@@ -0,0 +1,23 @@
+class Symbolic::Operation::Binary::Division < Symbolic::Operation::Binary
+  brackets_for :unary_minus, :addition, :subtraction
+  
+  def self.simplify_first_arg(var1, var2)
+    if var1 == 0
+      0
+    elsif negative?(var1)
+      -(var1.abs / var2)
+    end
+  end
+
+  def self.simplify_second_arg(var1, var2)
+    if var2 == 1
+      var1
+    elsif negative?(var2)
+      -(var1 / var2.abs)
+    end
+  end
+
+  def sign
+    '/'
+  end
+end

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

@@ -0,0 +1,24 @@
+class Symbolic::Operation::Binary::Exponentiation < Symbolic::Operation::Binary
+  brackets_for :unary_minus, :addition, :subtraction, :multiplication, :division
+
+  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
+    end
+  end
+
+  def self.simplify_second_arg(var1, var2)
+    if var2 == 0
+      1
+    elsif var2 == 1
+      var1
+    end
+  end
+
+  def sign
+    '**'
+  end
+end

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

@@ -0,0 +1,42 @@
+class Symbolic::Operation::Binary::Multiplication < Symbolic::Operation::Binary
+  symmetric
+  brackets_for :unary_minus, :addition, :subtraction
+
+  def self.simplify_first_arg(var1, var2)
+    if var1 == 0
+      0
+    elsif var1 == 1
+      var2
+    elsif negative?(var1)
+      -(var1.abs * var2)
+    end
+  end
+
+  def sign
+    '*'
+  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 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], []]
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+class Symbolic::Operation::Binary::Subtraction < Symbolic::Operation::Binary
+  def self.simplify_first_arg(var1, var2)
+    -var2 if var1 == 0
+  end
+
+  def self.simplify_second_arg(var1, var2)
+    if var2 == 0
+      var1
+    elsif negative?(var2)
+      var1 + var2.abs
+    end
+  end
+
+  def sign
+    '-'
+  end
+end

data/lib/symbolic/operation/unary.rb

@@ -0,0 +1,13 @@
+class Symbolic::Operation::Unary < Symbolic::Operation
+  def initialize(expression)
+    @expression = expression
+  end
+
+  def variables
+    @expression.variables
+  end
+
+  def undefined_variables
+    @expression.undefined_variables
+  end
+end

data/lib/symbolic/operation/unary/minus.rb

@@ -0,0 +1,32 @@
+class Symbolic::Operation
+  class Unary::Minus < Unary
+    def self.simplify(expression)
+      expression.abs if expression.is_a? Unary::Minus
+    end
+
+    def abs
+      # TODO: implement Symbolic#abs
+      @expression
+    end
+
+    def to_s
+      if [:variable, :multiplication, :division].include? operation(@expression)
+        "-#{@expression}"
+      else
+        "(-#{@expression})"
+      end
+    end
+
+    def value
+      -@expression.value if undefined_variables.empty?
+    end
+
+    def ==(object)
+      object.is_a?(Unary::Minus) && object.abs == @expression
+    end
+
+    def detailed_operations
+      @expression.detailed_operations.tap {|it| it['-@'] += 1}
+    end
+  end
+end

data/lib/symbolic/variable.rb

@@ -1,7 +1,6 @@
 module Symbolic
   class Variable
     include Symbolic
-
     attr_accessor :name, :proc
     attr_writer :value
 

data/spec/symbolic_spec.rb

@@ -7,7 +7,15 @@ describe "Symbolic" do
   end
 
   def expression(string)
-    eval string.gsub(/[a-z]+/, '@\0')
+    eval string.gsub(/[xy]/, '@\0')
+  end
+
+  def self.should_equal(conditions)
+    conditions.each do |non_optimized, optimized|
+      it non_optimized do
+        expression(non_optimized).should == expression(optimized)
+      end
+    end
   end
 
   describe "evaluation (x=1, y=2):" do
@@ -39,18 +47,13 @@ describe "Symbolic" do
      'y/2'       => 1,
      'x/2.0'     => 0.5,
      '-2/x'      => -2,
-     '4/(-y)'    => -2
+     '4/(-y)'    => -2,
+     'x**2'      => 1,
+     '4**y'      => 16,
+     'y**x'      => 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',
 
@@ -81,7 +84,22 @@ describe "Symbolic" do
     '-x*y'        => '-(x*y)',
     '(-x)*(-y)'   => 'x*y',
 
-    'x / 1'       => 'x'
+    '0 / x'       => '0',
+    'x / 1'       => 'x',
+
+    '0**x'        => '0',
+    '1**x'        => '1',
+    'x**0'        => '1',
+    'x**1'        => 'x'
+  end
+
+  describe 'general methods:' do
+    should_equal \
+    'x.variables' => '[x]',
+    '(-(x-y)).variables' => '[x,y]',
+    '(x+y).undefined_variables' => '[]',
+    '(-x-4*y+5-y/x).detailed_operations' =>
+    '{"+" => 1, "-" => 2, "*" => 1, "/" => 1, "-@" => 1}'
   end
 
   describe "formulas" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: symbolic
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - brainopia
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-07 00:00:00 +03:00
+date: 2009-12-08 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -39,15 +39,17 @@ files:
 - lib/extensions/numeric.rb
 - lib/symbolic.rb
 - lib/symbolic/coerced.rb
-- lib/symbolic/expression.rb
-- lib/symbolic/method.rb
-- lib/symbolic/optimization.rb
-- lib/symbolic/optimization/addition.rb
-- lib/symbolic/optimization/base.rb
-- lib/symbolic/optimization/division.rb
-- lib/symbolic/optimization/multiplication.rb
-- lib/symbolic/optimization/subtraction.rb
-- lib/symbolic/unary_minus.rb
+- lib/symbolic/function.rb
+- lib/symbolic/math.rb
+- lib/symbolic/operation.rb
+- lib/symbolic/operation/binary.rb
+- lib/symbolic/operation/binary/addition.rb
+- lib/symbolic/operation/binary/division.rb
+- lib/symbolic/operation/binary/exponentiation.rb
+- lib/symbolic/operation/binary/multiplication.rb
+- lib/symbolic/operation/binary/subtraction.rb
+- lib/symbolic/operation/unary.rb
+- lib/symbolic/operation/unary/minus.rb
 - lib/symbolic/variable.rb
 - spec/spec.opts
 - spec/spec_helper.rb

data/lib/symbolic/expression.rb

@@ -1,66 +0,0 @@
-module Symbolic
-  class Expression
-    include Symbolic
-
-    attr_reader :var1, :var2, :operation
-
-    def initialize(var1, var2, operation)
-      @var1, @var2, @operation = var1, var2, operation
-    end
-
-    def to_s
-      "#{brackets @var1}#{@operation}#{brackets @var2}"
-    end
-
-    def plus?
-      @operation == '+'
-    end
-
-    def minus?
-      @operation == '-'
-    end
-
-    def multiply?
-      @operation == '*'
-    end
-
-    def divide?
-      @operation == '/'
-    end
-
-    def value
-      @var1.value.send @operation, @var2.value if undefined_variables.empty?
-    end
-
-    def variables
-      @var1.variables | @var2.variables
-    end
-
-    def undefined_variables
-      variables.select &:undefined?
-    end
-
-    def ==(object)
-      object.is_a?(Expression) && (object.operation == @operation) &&
-      ((object.var1 == @var1 && object.var2 == @var2) || ((plus? || multiply?) && (object.var1 == @var2 && object.var2 == @var1)))
-    end
-
-    def detailed_operations
-      operations_of(@var1).tap {|it| it.merge!(operations_of @var2)[@operation] += 1 }
-    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 operations_of(var)
-      var.is_a?(Symbolic) ? var.detailed_operations : Hash.new(0)
-    end
-  end
-end

data/lib/symbolic/optimization.rb

@@ -1,12 +0,0 @@
-module Symbolic
-  module Optimization
-    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/lib/symbolic/optimization/addition.rb

@@ -1,15 +0,0 @@
-module Symbolic::Optimization::Addition
-  extend Symbolic::Optimization::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/optimization/base.rb

@@ -1,9 +0,0 @@
-module Symbolic::Optimization::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/optimization/division.rb

@@ -1,19 +0,0 @@
-module Symbolic::Optimization::Division
-  extend Symbolic::Optimization::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/optimization/multiplication.rb

@@ -1,17 +0,0 @@
-module Symbolic::Optimization::Multiplication
-  extend Symbolic::Optimization::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/optimization/subtraction.rb

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

data/lib/symbolic/unary_minus.rb

@@ -1,46 +0,0 @@
-module Symbolic
-  class UnaryMinus
-    include Symbolic
-
-    def self.create(var)
-      var.is_a?(UnaryMinus) ? var.abs : new(var)
-    end
-
-    def initialize(variable)
-      @variable = variable
-    end
-
-    def to_s
-      if @variable.is_a? Variable
-        "-#{@variable}"
-      else
-        "(-#{@variable})"
-      end
-    end
-
-    def abs
-      # TODO: add a common method for Symbolic which will point to an instance of Abs(magnitude) class
-      @variable
-    end
-
-    def value
-      -@variable.value if undefined_variables.empty?
-    end
-
-    def variables
-      @variable.variables
-    end
-
-    def undefined_variables
-      @variable.undefined_variables
-    end
-
-    def ==(object)
-      object.is_a?(UnaryMinus) && object.abs == @variable
-    end
-
-    def detailed_operations
-      @variable.detailed_operations.tap {|it| it['-@'] += 1}
-    end
-  end
-end