symbolic 0.3.3 → 0.3.4

data/README.rdoc

@@ -1,18 +1,18 @@
 Symbolic math for ruby.
 
-== Installation:
+== Installation
 
 gem install symbolic
 
-== Introduction:
-
-Symbolic doesn't have any external dependencies. It uses only pure ruby (less than 400 LOC (lines of code)).
+== Introduction
 
 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
 
+Symbolic doesn't have any external dependencies. It uses only pure ruby (less than 400 lines of code).
+
 == Tutorial
 
 First, you need to create a symbolic variable.
@@ -73,7 +73,7 @@ You can get an information about number of different operations used in a symbol
   f.operations # => {"+"=>1, "-"=>2, "*"=>3, "/"=>0, "**"=>1, "-@"=>0}
 
 
-== TODO:
+== TODO
 - a lot of refactoring (code is pretty messy at this stage)
 - plotting capabilities
 - derivatives

data/Rakefile

@@ -5,7 +5,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "symbolic"
-    gem.version = '0.3.3'
+    gem.version = '0.3.4'
     gem.summary = 'Symbolic math for ruby'
     gem.description = <<TEXT
 Symbolic math for ruby.
@@ -14,13 +14,13 @@ Symbolic math for ruby.
 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
+- if you need an abstraction layer for math.
 
 
 Symbolic doesn't have any external dependencies. It uses only pure ruby (less than 400 LOC (lines of code)).
 TEXT
     gem.email = "ravwar@gmail.com"
-    gem.homepage = "http://github.com/brainopia/symbolic"
+    gem.homepage = "http://brainopia.github.com/symbolic"
     gem.authors = ["brainopia"]
     gem.add_development_dependency "rspec", ">= 1.2.9"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings

data/lib/symbolic.rb

@@ -1,7 +1,8 @@
 require 'symbolic/coerced'
 require 'symbolic/variable'
-require 'symbolic/summand'
-require 'symbolic/factor'
+require 'symbolic/expression'
+require 'symbolic/summands'
+require 'symbolic/factors'
 require 'symbolic/function'
 require 'symbolic/math'
 require 'symbolic/statistics'
@@ -17,42 +18,38 @@ module Symbolic
   end
 
   def -@
-    Factor.multiply self, -1
+    Factors.add self, -1
   end
 
   def +(var)
-    Summand.add self, var
+    Summands.add self, var
   end
 
   def -(var)
-    Summand.subtract self, var
+    Summands.subtract self, var
   end
 
   def *(var)
-    Factor.multiply self, var
+    Factors.add self, var
   end
 
   def /(var)
-    Factor.divide self, var
+    Factors.subtract self, var
   end
 
   def **(var)
-    Factor.exponent self, var
+    Factors.power self, var
   end
 
   def coerce(numeric)
     [Coerced.new(self), numeric]
   end
 
-  private
-
-  def factors
-    [1, { self => 1 }]
+  def inspect
+    "Symbolic: #{to_s}"
   end
 
-  def summands
-    [0, { self => 1 }]
-  end
+  private
 
   def variables_of(var)
     var.variables rescue []

data/lib/symbolic/coerced.rb

@@ -1,27 +1,33 @@
 module Symbolic
+=begin
+ This class restores a correct order of arguments after using a coerce method.
+ For example, expression "1 - symbolic" calls to Symbolic#coerce
+ which gives us a power to reverse a receiver and parameter of method
+ so we set a receiver as Coerced.new(symbolic) to reverse arguments back after coercing.
+=end
   class Coerced
     def initialize(symbolic)
       @symbolic = symbolic
     end
 
     def +(numeric)
-      Summand.add numeric, @symbolic
+      Summands.add numeric, @symbolic
     end
 
     def -(numeric)
-      Summand.subtract numeric, @symbolic
+      Summands.subtract numeric, @symbolic
     end
 
     def *(numeric)
-      Factor.multiply numeric, @symbolic
+      Factors.add numeric, @symbolic
     end
 
     def /(numeric)
-      Factor.divide numeric, @symbolic
+      Factors.subtract numeric, @symbolic
     end
 
     def **(numeric)
-      Factor.exponent numeric, @symbolic
+      Factors.power numeric, @symbolic
     end
   end
 end

data/lib/symbolic/expression.rb

@@ -0,0 +1,73 @@
+module Symbolic
+  class Expression
+    include Symbolic
+
+    class << self
+      def add(var1, var2)
+        simplify_expression! expression = unite(convert(var1), convert(var2))
+        simplify(*expression) || new(*expression)
+      end
+
+      def subtract(var1, var2)
+        add var1, convert(var2).reverse
+      end
+
+      def unite(expr1, expr2)
+        numeric = unite_numeric expr1.numeric, expr2.numeric
+        symbolic = unite_symbolic expr1.symbolic, expr2.symbolic
+        [numeric, symbolic]
+      end
+
+      def unite_symbolic(symbolic1, symbolic2)
+        symbolic1.merge(symbolic2) {|base, coef1, coef2| coef1 + coef2 }
+      end
+
+      def unite_numeric(numeric1, numeric2)
+        numeric1.send operation, numeric2
+      end
+
+      def convert(var)
+        case var
+        when Summands then summands var
+        when Factors  then factors var
+        when Numeric  then numeric var
+        else one var; end
+      end
+
+      def numeric(numeric)
+        new numeric, {}
+      end
+
+      def one(symbolic)
+        new identity_element, symbolic => 1
+      end
+
+      def simple?(var)
+        case var
+        when Numeric, Variable
+          true
+        when Function, Summands
+          false
+        when Factors
+          var.symbolic.all? {|k,v| simple? k }
+        else
+          false
+        end
+      end
+    end
+
+    attr_reader :numeric, :symbolic
+
+    def initialize(numeric, symbolic)
+      @numeric, @symbolic = numeric, symbolic
+    end
+
+    def variables
+      @symbolic.map {|k,v| [variables_of(k), variables_of(v)] }.flatten.uniq
+    end
+
+    def ==(object)
+      (object.numeric == @numeric) and (object.symbolic == @symbolic) rescue false
+    end
+  end
+end

data/lib/symbolic/factors.rb

@@ -0,0 +1,119 @@
+module Symbolic
+  class Factors < Expression
+    class << self
+      def operation
+        '*'
+      end
+
+      def identity_element
+        1
+      end
+
+      def summands(summands)
+        one summands
+      end
+
+      def factors(factors)
+        factors
+      end
+
+      def power(base, exponent)
+        simplify_expression! factors = unite_exponents(base, exponent)
+        simplify(*factors) || new(*factors)
+      end
+
+      def add(var1, var2)
+        if distributable? var1, var2
+          distribute(var1, var2)
+        elsif distributable? var2, var1
+          distribute(var2, var1)
+        else
+          super
+        end
+      end
+
+      def subtract(var1, var2)
+        simplify_expression! factors = unite(convert(var1), convert(var2).reverse)
+        simplify(*factors) || new(*factors)
+      end
+
+      def distributable?(var1, var2)
+        simple?(var1) && var2.is_a?(Summands)
+      end
+
+      def distribute(var1, var2)
+        var2.symbolic.map {|k,v| k*v }.inject(var2.numeric*var1) do |sum, it|
+          sum + it*var1
+        end
+      end
+
+      def simplify_expression!(factors)
+        factors[1].delete_if {|base, exp| (base == identity_element) || (exp == 0) }
+        factors[0] = 0 if factors[1].any? {|base, exp| base == 0 }
+      end
+
+      def simplify(numeric, symbolic)
+        if numeric == 0 || symbolic.empty?
+          (numeric.round == numeric) ? numeric.to_i : numeric.to_f
+        elsif numeric == identity_element && symbolic.size == 1 && symbolic.values.first == 1
+          symbolic.keys.first
+        end
+      end
+
+      def unite_exponents(base, exponent)
+        if base.is_a? Factors
+          return base.numeric**exponent, Hash[*base.symbolic.map {|base,exp| [base,exp*exponent] }.flatten]
+        else
+          [identity_element, { base => exponent }]
+        end
+      end
+    end
+
+    def reverse
+      self.class.new numeric**-1, Hash[*symbolic.map {|k,v| [k,-v]}.flatten]
+    end
+
+    def value
+      @symbolic.inject(numeric) {|value, (base, exp)| value * base.value ** exp.value }
+    end
+
+    def to_s
+      simplify_output
+    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 brackets(var)
+      [Numeric, Symbolic::Variable].any? {|klass| var.is_a? klass } ? var : "(#{var})"
+    end
+
+    def simplify_output
+      groups = @symbolic.group_by {|b,e| e.is_a?(Numeric) && e < 0 }
+      reversed_factors = groups[true] ? [1, Hash[*groups[true].flatten] ] : nil
+      factors = groups[false] ? [@numeric, Hash[*groups[false].flatten] ] : nil
+      output = '' << (factors ? output(factors) : rational_to_string(@numeric))
+      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 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
+    end
+  end
+end

data/lib/symbolic/summands.rb

@@ -0,0 +1,65 @@
+# TODO: 2*symbolic is a 2 power of symbolic Summand
+module Symbolic
+  class Summands < Expression
+    class << self
+      def operation
+        '+'
+      end
+
+      def identity_element
+        0
+      end
+
+      def summands(summands)
+        summands
+      end
+
+      def factors(factors)
+        if factors.symbolic.length == 1 && factors.symbolic.values.first == 1
+          new identity_element, factors.symbolic.keys.first => factors.numeric
+        else
+          new identity_element, Factors.new(1, factors.symbolic) => factors.numeric
+        end
+      end
+
+      def simplify_expression!(summands)
+        summands[1].delete_if {|base, coef| coef == 0 }
+      end
+
+      def simplify(numeric, symbolic)
+        if symbolic.empty?
+          numeric
+        elsif numeric == identity_element && symbolic.size == 1
+          symbolic.values.first * symbolic.keys.first
+        end
+      end
+    end
+
+    def value
+      symbolic.inject(numeric) {|value, (base, coef)| value + base.value * coef.value }
+    end
+
+    def to_s
+      output = symbolic.map {|base, coef| coef_to_string(coef) + base.to_s }
+      output << remainder_to_string(numeric) if numeric != 0
+      output[0].sub!(/^\+/, '')
+      output.join
+    end
+
+    def reverse
+      self.class.new -numeric, Hash[*symbolic.map {|k,v| [k,-v]}.flatten]
+    end
+
+    def coef_to_string(coef)
+      "#{(coef > 0) ? '+' : '-' }#{ "#{rational_to_string(coef.abs)}*" if coef.abs != 1}"
+    end
+
+    def remainder_to_string(numeric)
+      "#{'+' if numeric > 0}#{numeric}"
+    end
+
+    def rational_to_string(numeric)
+      ((numeric.round == numeric) ? numeric.to_i : numeric.to_f).to_s
+    end
+  end
+end

data/lib/symbolic/variable.rb

@@ -1,4 +1,11 @@
 module Symbolic
+=begin
+  This class is used to create symbolic variables.
+  Symbolic variables presented by name and value.
+  Name is neccessary for printing meaningful symbolic expressions.
+  Value is neccesary for calculation of symbolic expressions.
+  If value isn't set for variable, but there is an associated proc, then value is taken from evaluating the proc.
+=end
   class Variable
     include Symbolic
     attr_accessor :name, :proc
@@ -11,7 +18,7 @@ module Symbolic
     end
 
     def value
-      @value || @proc && @proc.call
+      @value || @proc && @proc.call.value
     end
 
     def to_s
@@ -21,9 +28,5 @@ module Symbolic
     def variables
       [self]
     end
-
-    def detailed_operations
-      Hash.new 0
-    end
   end
 end

data/spec/symbolic_spec.rb

@@ -18,15 +18,23 @@ describe "Symbolic" do
     end
   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
+
+  def self.should_print(conditions)
+    conditions.each do |symbolic_expression, result|
+      it symbolic_expression do
+        expression(symbolic_expression).to_s.should == result
+      end
+    end
+  end
 
+  describe "evaluation (x=1, y=2):" do
      should_evaluate_to \
      'x'         => 1,
      'y'         => 2,
@@ -111,14 +119,6 @@ describe "Symbolic" do
   end
 
   describe "to_s:" do
-    def self.should_print(conditions)
-      conditions.each do |symbolic_expression, result|
-        it symbolic_expression do
-          expression(symbolic_expression).to_s.should == result
-        end
-      end
-    end
-
     should_print \
     'x' => 'x',
     '-x' => '-x',

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: symbolic
 version: !ruby/object:Gem::Version 
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors: 
 - brainopia
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-16 00:00:00 +03:00
+date: 2009-12-22 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -29,7 +29,7 @@ description: |
   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
+  - if you need an abstraction layer for math.
   
   
   Symbolic doesn't have any external dependencies. It uses only pure ruby (less than 400 LOC (lines of code)).
@@ -47,21 +47,22 @@ files:
 - Rakefile
 - lib/symbolic.rb
 - lib/symbolic/coerced.rb
+- lib/symbolic/expression.rb
 - lib/symbolic/extensions/kernel.rb
 - lib/symbolic/extensions/matrix.rb
 - lib/symbolic/extensions/numeric.rb
 - lib/symbolic/extensions/rational.rb
-- lib/symbolic/factor.rb
+- lib/symbolic/factors.rb
 - lib/symbolic/function.rb
 - lib/symbolic/math.rb
 - lib/symbolic/statistics.rb
-- lib/symbolic/summand.rb
+- lib/symbolic/summands.rb
 - lib/symbolic/variable.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/symbolic_spec.rb
 has_rdoc: true
-homepage: http://github.com/brainopia/symbolic
+homepage: http://brainopia.github.com/symbolic
 licenses: []
 
 post_install_message: 

data/lib/symbolic/factor.rb

@@ -1,162 +0,0 @@
-module Symbolic
-  class Factor
-    include Symbolic
-
-    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
-
-        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 distributable?(var1, var2)
-        simple?(var1) && var2.is_a?(Summand)
-      end
-
-      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
-
-      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 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 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
-
-      def factors(var)
-        var.is_a?(Symbolic) ? var.send(:factors) : [var, {}]
-      end
-
-      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
-
-    def initialize(factors)
-      @factors = factors
-    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 to_s
-      simplify_output
-    end
-
-    def ==(object)
-      object.send(:factors) == @factors rescue false
-    end
-
-    private
-
-    attr_reader :factors
-
-    def summands
-      if @factors[0] == 1
-        super
-      else
-        [0, {(self/@factors[0]) => @factors[0]}]
-      end
-    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 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 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 rational_to_string(numeric)
-      ((numeric.round == numeric) ? numeric.to_i : numeric.to_f).to_s
-    end
-  end
-end

data/lib/symbolic/summand.rb

@@ -1,86 +0,0 @@
-class Symbolic::Summand
-  include Symbolic
-
-  class << self
-    def add(var1, var2)
-      simplify_coefficients! summands = unite(summands(var1), summands(var2))
-      simplify(*summands) || new(summands)
-    end
-
-    def subtract(var1, var2)
-      simplify_coefficients! summands = unite(summands(var1), reverse(var2))
-      simplify(*summands) || new(summands)
-    end
-
-    def reverse(var)
-      summands(var).tap do |it|
-        it[0] = -it[0]
-        it[1] = Hash[*it[1].map {|b,e| [b,-e] }.flatten]
-      end
-    end
-
-    def summands(var)
-      var.is_a?(Symbolic) ? var.send(:summands) : [var, {}]
-    end
-
-    def unite(summands1, summands2)
-      numeric1, symbolic1 = summands1
-      numeric2, symbolic2 = summands2
-
-      numeric = numeric1 + numeric2
-      symbolic = symbolic1.merge(symbolic2) {|base, coef1, coef2| coef1 + coef2 }
-      [numeric, symbolic]
-    end
-
-    def simplify_coefficients!(summands)
-      summands[1].delete_if {|base, coef| coef == 0 }
-    end
-
-    def simplify(numeric, symbolic)
-      if symbolic.empty?
-        numeric
-      elsif numeric == 0 && symbolic.size == 1
-        symbolic.values.first * symbolic.keys.first
-      end
-    end
-  end
-
-  def initialize(summands)
-    @summands = summands
-  end
-
-  def value
-    @summands[1].inject(@summands[0]) {|value, (base, coef)| value + base.value * coef.value }
-  end
-
-  def variables
-    @summands[1].map {|k,v| [variables_of(k), variables_of(v)] }.flatten.uniq
-  end
-
-  def ==(object)
-    object.send(:summands) == @summands rescue false
-  end
-
-  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] if output.first[0] == '+'
-    output.join
-  end
-
-  private
-
-  attr_reader :summands
-
-  def coef_to_string(coef)
-    "#{(coef > 0) ? '+' : '-' }#{ "#{rational_to_string(coef.abs)}*" if coef.abs != 1}"
-  end
-
-  def remainder_to_string(numeric)
-    "#{'+' if numeric > 0}#{numeric}"
-  end
-
-  def rational_to_string(numeric)
-    ((numeric.round == numeric) ? numeric.to_i : numeric.to_f).to_s
-  end
-end