symbolic 0.3.0 → 0.3.1

data/README.rdoc

@@ -6,25 +6,83 @@ gem install symbolic
 
 == 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.
+Symbolic doesn't have any external dependencies. It uses only pure ruby (less than 400 LOC (lines of code)).
 
-== Examples:
-  x = var :name => 'x'
-  y = var :name => 'y'
+This gem can help you
+- if you want to get a simplified form of a big equation
+- if you want to speed up similar calculations
+- if you need an abstraction layer for math
 
-  f = (-2*(-x) + y*(-1.0) + 6*x/(3*x))*x - 2*y + 2*y - (2**x)**y
-  puts f # => (2*x-y+2)*x-2**(x*y)
+== Tutorial
 
-  p f.operations # => {"+"=>1, "-"=>2, "*"=>3, "/"=>0, "**"=>1, "-@"=>0}
-  p f.variables.map &:name # => ["x", "y"]
-  x.value = 2
-  p f.undefined_variables.map &:name # => ["y"]
-  y.value = 4
+First, you need to create a symbolic variable.
 
-  puts f.value # => -252.0
+  x = var
 
+  # you can set a name of variable (useful if you print equations)
+  angle = var :name => 'θ'
 
-  g = Symbolic::Math.cos(y)
-  puts g # => cos(y)
-  y.value = 0
-  puts g.value # => 1.0
+  # or starting value
+  pi = var :value => 3.14
+
+  # or bind its value to a proc
+  y = var { x ** 2 }
+
+  # you can set a value for already created variable
+  x.value = 3
+
+Now, you can do any math operations with it.
+
+  f = 2*x + 1
+  puts f # => 2*x+1
+
+To get value of symbolic expression you just call value:
+
+  f.value # => 7
+
+If symbolic expression contains variables without value then it returns nil.
+
+  z = var
+  (z+1).value # => nil
+
+All symbolic expression are automatically simplified when created:
+
+  0 * x           # => 0
+  2 + x + 1       # => x + 3
+  -(x-y) + 2*x    # => x + y
+  (x**2)**3 / x   # => x**5
+  # etc. (more examples can be found in symbolic_spec.rb)
+
+If you need to use a function from Math module with symbolic variable, use Symbolic::Math module.
+
+  cos = Symbolic::Math.cos(x)
+  x.value = 0
+  cos.value # => 1.0
+
+You can get a list of variables from symbolic expression:
+
+  (x+y+1).variables # => [x, y]
+
+So you can get a list of variables without value:
+
+  (x+y+1).variables.select {|var| var.value.nil? }
+
+You can get an information about number of different operations used in a symbolic expression:
+
+  f = (2*x-y+2)*x-2**(x*y)
+  f.operations # => {"+"=>1, "-"=>2, "*"=>3, "/"=>0, "**"=>1, "-@"=>0}
+
+
+== TODO:
+- a lot of refactoring (code is pretty messy at this stage)
+- plotting capabilities
+- derivatives
+- integrals
+- thorough documentation
+
+== Author
+
+brainopia (ravwar at gmail.com).
+
+I am ready to help with any questions related to Symbolic.
+I welcome any contribution.

data/Rakefile

@@ -5,7 +5,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "symbolic"
-    gem.version = '0.3.0'
+    gem.version = '0.3.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,5 +1,3 @@
-Symbolic = Module.new
-
 require 'symbolic/coerced'
 require 'symbolic/variable'
 require 'symbolic/summand'
@@ -14,14 +12,14 @@ require 'symbolic/extensions/matrix' if Object.const_defined? 'Matrix'
 require 'symbolic/extensions/rational' if RUBY_VERSION == '1.8.7'
 
 module Symbolic
-  def -@
-    Factor.multiply self, -1
-  end
-
   def +@
     self
   end
 
+  def -@
+    Factor.multiply self, -1
+  end
+
   def +(var)
     Summand.add self, var
   end
@@ -43,11 +41,7 @@ module Symbolic
   end
 
   def coerce(numeric)
-    return Coerced.new(self), numeric
-  end
-
-  def undefined_variables
-    variables.select {|it| it.value.nil? }
+    [Coerced.new(self), numeric]
   end
 
   private

data/lib/symbolic/factor.rb

@@ -1,129 +1,162 @@
-class Symbolic::Factor
-  include Symbolic
+module Symbolic
+  class Factor
+    include Symbolic
+
+    class << self
+      def exponent(base, exponent)
+        simplify_exponents! factors = unite_exponents(base, exponent)
+        simplify(*factors) || new(factors)
+      end
 
-  class << self
-    def exponent(base, exponent)
-      simplify_exponents! factors = unite_exponents(base, exponent)
-      simplify(*factors) || new(factors)
-    end
+      def multiply(var1, var2)
+        return distribute(var1, var2) if distributable? var1, var2
+        return distribute(var2, var1) if distributable? var2, var1
 
-    def multiply(var1, var2)
-      simplify_exponents! factors = unite(factors(var1), factors(var2))
-      simplify(*factors) || new(factors)
-    end
+        simplify_exponents! factors = unite(factors(var1), factors(var2))
+        simplify(*factors) || new(factors)
+      end
 
-    def divide(var1, var2)
-      simplify_exponents! factors = unite(factors(var1), reverse(var2))
-      simplify(*factors) || new(factors)
-    end
+      def divide(var1, var2)
+        simplify_exponents! factors = unite(factors(var1), reverse(var2))
+        simplify(*factors) || new(factors)
+      end
 
-    def simplify_exponents!(factors)
-      factors[1].delete_if {|base, exp| (base == 1) || (exp == 0) }
-      factors[0] = 0 if factors[1].any? {|base, exp| base == 0 }
-    end
+      def distributable?(var1, var2)
+        simple?(var1) && var2.is_a?(Summand)
+      end
 
-    def simplify(numeric, symbolic)
-      if numeric == 0 || symbolic.empty?
-        (numeric.round == numeric) ? numeric.to_i : numeric.to_f
-      elsif numeric == 1 && symbolic.size == 1 && symbolic.values.first == 1
-        symbolic.keys.first
+      def distribute(var1, var2)
+        numeric, symbolic = var2.send(:summands)
+        symbolic.map {|k,v| k*v }.inject(numeric*var1) do |sum, it|
+          sum + it*var1
+        end
       end
-    end
 
-    def reverse(var)
-      factors(var).dup.tap do |it|
-        it[0] = it[0]**-1
-        it[1] = Hash[*it[1].map {|b,e| [b,-e] }.flatten]
+      def simplify_exponents!(factors)
+        factors[1].delete_if {|base, exp| (base == 1) || (exp == 0) }
+        factors[0] = 0 if factors[1].any? {|base, exp| base == 0 }
       end
-    end
 
-    def factors(var)
-      var.is_a?(Symbolic) ? var.send(:factors) : [var, {}]
-    end
+      def simplify(numeric, symbolic)
+        if numeric == 0 || symbolic.empty?
+          (numeric.round == numeric) ? numeric.to_i : numeric.to_f
+        elsif numeric == 1 && symbolic.size == 1 && symbolic.values.first == 1
+          symbolic.keys.first
+        end
+      end
 
-    def unite(factors1, factors2)
-      numeric1, symbolic1 = factors1
-      numeric2, symbolic2 = factors2
+      def reverse(var)
+        factors(var).dup.tap do |it|
+          it[0] = it[0]**-1
+          it[1] = Hash[*it[1].map {|b,e| [b,-e] }.flatten]
+        end
+      end
 
-      numeric = numeric1 * numeric2
-      symbolic = symbolic1.merge(symbolic2) {|base, exp1, exp2| exp1 + exp2 }
-      return numeric, symbolic
-    end
+      def factors(var)
+        var.is_a?(Symbolic) ? var.send(:factors) : [var, {}]
+      end
 
-    def unite_exponents(base, exponent)
-      if base.is_a? Symbolic::Factor
-        numeric, symbolic = factors(base)
-        return numeric**exponent, Hash[*symbolic.map {|base,exp| [base,exp*exponent] }.flatten]
-      else
-        [1, { base => exponent }]
+      def unite(factors1, factors2)
+        numeric1, symbolic1 = factors1
+        numeric2, symbolic2 = factors2
+
+        numeric = numeric1 * numeric2
+        symbolic = symbolic1.merge(symbolic2) {|base, exp1, exp2| exp1 + exp2 }
+        [numeric, symbolic]
+      end
+
+      def unite_exponents(base, exponent)
+        if base.is_a? Factor
+          numeric, symbolic = factors(base)
+          return numeric**exponent, Hash[*symbolic.map {|base,exp| [base,exp*exponent] }.flatten]
+        else
+          [1, { base => exponent }]
+        end
+      end
+
+      def simple?(var)
+        case var
+        when Numeric
+          true
+        when Variable
+          true
+        when Function
+          false
+        when Summand
+          false
+        when Factor
+          var.send(:factors)[1].all? {|k,v| simple? k }
+        else
+          false
+        end
       end
     end
-  end
 
-  def initialize(factors)
-    @factors = factors
-  end
+    def initialize(factors)
+      @factors = factors
+    end
 
-  def value
-    @factors[1].inject(@factors[0]) {|value, (base, exp)| value * base.value ** exp.value }
-  end
+    def value
+      @factors[1].inject(@factors[0]) {|value, (base, exp)| value * base.value ** exp.value }
+    end
 
-  def variables
-    @factors[1].map {|k,v| [variables_of(k), variables_of(v)] }.flatten.uniq
-  end
+    def variables
+      @factors[1].map {|k,v| [variables_of(k), variables_of(v)] }.flatten.uniq
+    end
 
-  def to_s
-    simplify_output
-  end
+    def to_s
+      simplify_output
+    end
 
-  def ==(object)
-    object.send(:factors) == @factors rescue false
-  end
+    def ==(object)
+      object.send(:factors) == @factors rescue false
+    end
 
-  private
+    private
 
-  attr_reader :factors
+    attr_reader :factors
 
-  def summands
-    if @factors[0] == 1
-      super
-    else
-      [0, {(self/@factors[0]) => @factors[0]}]
+    def summands
+      if @factors[0] == 1
+        super
+      else
+        [0, {(self/@factors[0]) => @factors[0]}]
+      end
     end
-  end
 
-  def coefficient_to_string(numeric)
-    "#{'-' if numeric < 0}#{"#{rational_to_string numeric.abs}*" if numeric.abs != 1}"
-  end
+    def coefficient_to_string(numeric)
+      "#{'-' if numeric < 0}#{"#{rational_to_string numeric.abs}*" if numeric.abs != 1}"
+    end
 
-  def exponent_to_string(base, exponent)
-    "#{brackets base}#{"**#{brackets exponent}" if exponent != 1}"
-  end
+    def exponent_to_string(base, exponent)
+      "#{brackets base}#{"**#{brackets exponent}" if exponent != 1}"
+    end
 
-  def brackets(var)
-    [Numeric, Symbolic::Variable].any? {|klass| var.is_a? klass } ? var : "(#{var})"
-  end
+    def brackets(var)
+      [Numeric, Symbolic::Variable].any? {|klass| var.is_a? klass } ? var : "(#{var})"
+    end
 
-  def simplify_output
-    groups = @factors[1].group_by {|b,e| e.is_a?(Numeric) && e < 0 }
-    reversed_factors = groups[true] ? [1, Hash[*groups[true].flatten] ] : nil
-    factors = groups[false] ? [@factors[0], Hash[*groups[false].flatten] ] : nil
-    output = '' << (factors ? output(factors) : rational_to_string(@factors[0]))
-    output << "/#{reversed_output reversed_factors}" if reversed_factors
-    output
-  end
+    def simplify_output
+      groups = @factors[1].group_by {|b,e| e.is_a?(Numeric) && e < 0 }
+      reversed_factors = groups[true] ? [1, Hash[*groups[true].flatten] ] : nil
+      factors = groups[false] ? [@factors[0], Hash[*groups[false].flatten] ] : nil
+      output = '' << (factors ? output(factors) : rational_to_string(@factors[0]))
+      output << "/#{reversed_output reversed_factors}" if reversed_factors
+      output
+    end
 
-  def output(factors)
-    coefficient_to_string(factors[0]) <<
-    factors[1].map {|base,exp| exponent_to_string base,exp }.join('*')
-  end
+    def output(factors)
+      coefficient_to_string(factors[0]) <<
+      factors[1].map {|base,exp| exponent_to_string base,exp }.join('*')
+    end
 
-  def reversed_output(factors)
-    result = output [factors[0], Hash[*factors[1].map {|b,e| [b,-e] }.flatten]]
-    (factors[1].length > 1) ? "(#{result})" : result
-  end
+    def reversed_output(factors)
+      result = output [factors[0], Hash[*factors[1].map {|b,e| [b,-e] }.flatten]]
+      (factors[1].length > 1) ? "(#{result})" : result
+    end
 
-  def rational_to_string(numeric)
-    ((numeric.round == numeric) ? numeric.to_i : numeric.to_f).to_s
+    def rational_to_string(numeric)
+      ((numeric.round == numeric) ? numeric.to_i : numeric.to_f).to_s
+    end
   end
 end

data/lib/symbolic/function.rb

@@ -17,10 +17,6 @@ class Symbolic::Function
     @variable.variables
   end
 
-  def undefined_variables
-    @variable.undefined_variables
-  end
-
   def detailed_operations
     @variable.detailed_operations.tap {|it| it[@operation] += 1}
   end

data/lib/symbolic/summand.rb

@@ -29,7 +29,7 @@ class Symbolic::Summand
 
       numeric = numeric1 + numeric2
       symbolic = symbolic1.merge(symbolic2) {|base, coef1, coef2| coef1 + coef2 }
-      return numeric, symbolic
+      [numeric, symbolic]
     end
 
     def simplify_coefficients!(summands)
@@ -64,7 +64,7 @@ class Symbolic::Summand
   def to_s
     output = @summands[1].map {|base, coef| coef_to_string(coef) + base.to_s }
     output << remainder_to_string(@summands[0]) if @summands[0] != 0
-    output[0] = output.first[1..-1]
+    output[0] = output.first[1..-1] if output.first[0] == '+'
     output.join
   end
 

data/lib/symbolic/variable.rb

@@ -22,10 +22,6 @@ module Symbolic
       [self]
     end
 
-    def undefined_variables
-      value ? [] : variables
-    end
-
     def detailed_operations
       Hash.new 0
     end

data/spec/symbolic_spec.rb

@@ -96,18 +96,18 @@ describe "Symbolic" do
 
     'x*4*x'       => '4*x**2',
     'x*(-1)*x**(-1)' => '-1',
-    'x**2*(-1)*x**(-1)' => '-x'
+    'x**2*(-1)*x**(-1)' => '-x',
+    'x + y - x' => 'y',
+    '2*x + x**1 - y**2/y - y' => '3*x - 2*y',
+    '-(x+4)' => '-x-4'
   end
 
   describe 'general methods:' do
     should_equal \
     'x.variables' => '[x]',
     '(-(x+y)).variables' => '[x,y]',
-    '(x+y).undefined_variables' => '[]',
-    '(x*y).undefined_variables' => '[]'#,
-    # '(-x**y-4*y+5-y/x).detailed_operations' =>
-    # '{"+" => 1, "-" => 2, "*" => 1, "/" => 1, "-@" => 1, "**" => 1}',
-    # '(-x**y-4*y+5-y/x).operations' => '7'
+    '(-x**y-4*y+5-y/x).operations' =>
+    '{"+" => 1, "-" => 2, "*" => 1, "/" => 1, "-@" => 1, "**" => 1}'
   end
 
   describe "to_s:" do
@@ -124,17 +124,18 @@ describe "Symbolic" do
     '-x' => '-x',
     'x+1' => 'x+1',
     'x-4' => 'x-4',
-    # '-(x+y)' => '-x-y',
-    # '-(x-y)' => 'y-x',
+    '-x-4' => '-x-4',
+    '-(x+y)' => '-x-y',
+    '-(x-y)' => '-x+y',
     'x*y' => 'x*y',
     '(-x)*y' => '-x*y',
     '(x+2)*(y+3)*4' => '4*(x+2)*(y+3)',
     '4/x' => '4/x',
     '2*x**(-1)*y**(-1)' => '2/(x*y)',
-    # '(-(2+x))/(-(-y))' => '(-2-x)/y',
+    '(-(2+x))/(-(-y))' => '(-x-2)/y',
     'x**y' => 'x**y',
     'x**(y-4)' => 'x**(y-4)',
-    '(x+1)**(y*2)' => '(x+1)**(2*y)'#,
-    # '-(x**y -2)+5' => '2-x**y+5'
+    '(x+1)**(y*2)' => '(x+1)**(2*y)',
+    '-(x**y -2)+5' => '-x**y+7'
   end
 end

metadata

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