symbolic 0.3.7 → 0.3.8

data/lib/symbolic/math.rb

@@ -2,14 +2,38 @@ module Symbolic::Math
 =begin
   This module is a reflection for Math module which allows to use symbolic expressions as parameters for its methods.
 =end
-  Math.methods(false).each do |method|
+  require "#{File.dirname(__FILE__)}/function.rb"
+  require 'rational'
+
+  #for use in defining derivatives
+  Arg = Symbolic::Variable.new(:name=>'Arg')
+
+  #first, make the functions with derivatives
+  Abs   = Symbolic::Function.new('abs', proc{|arg| arg/Abs[arg]}){|arg| arg.abs}
+  Sqrt  = Symbolic::Function.new('sqrt', Rational(1,2) / Arg ** Rational(1,2))
+  Exp   = Symbolic::Function.new('exp'); Exp.set_derivative(Exp)
+  Log   = Symbolic::Function.new('log', 1 / Arg)
+  Log10 = Symbolic::Function.new('log10', 1 / Arg / ::Math.log(10)) #since log10(x) = log(x) / log(10)
+  Cos   = Symbolic::Function.new('cos')
+  Sin   = Symbolic::Function.new('sin',Cos); Cos.set_derivative(-Sin[Arg])
+  Tan   = Symbolic::Function.new('tan', 1 / Cos[Arg] ** 2)
+  Cosh  = Symbolic::Function.new('cosh')
+  Sinh  = Symbolic::Function.new('sinh',Cosh); Cosh.set_derivative(Sinh)
+  Tanh  = Symbolic::Function.new('tanh',1 / Cosh[Arg] ** 2)
+  Acos  = Symbolic::Function.new('acos',- 1 / (1 - Arg) ** Rational(1,2))
+  Asin  = Symbolic::Function.new('asin',1 / (1 - Arg) ** Rational(1,2))
+  Atan  = Symbolic::Function.new('atan',1 / (Arg**2 + 1))
+  Acosh = Symbolic::Function.new('acosh',1 / (1 - Arg) ** Rational(1,2))
+  Asinh = Symbolic::Function.new('asinh',1 / (1 + Arg) ** Rational(1,2))
+  Atanh = Symbolic::Function.new('atanh',1/ (1 - Arg**2))
+
+  #make functions of the form fctn(arg) and add operation to each function
+  #for ruby 1.9, we have to convert them to strings (they were strings in 1.8)
+  Symbolic::Math.constants.collect{|c| c.to_s}.reject{|c| ['Arg','Abs'].include?(c)}.each do |fctn|
     instance_eval <<-CODE, __FILE__, __LINE__ + 1
-      def #{method}(argument)
-        unless argument.is_a? Numeric
-          Symbolic::Function.new argument, :#{method}
-        else
-          ::Math.#{method} argument
-        end
+      #{fctn}.set_operation(proc{|arg| ::Math.#{fctn.downcase}(arg)})
+      def #{fctn.downcase}(argument)
+        #{fctn}[argument]
       end
     CODE
   end

data/lib/symbolic/misc.rb

@@ -0,0 +1,5 @@
+module Symbolic
+  def factorial(n)
+    (1..n).inject(1){|f,n| f*n}
+  end
+end

data/lib/symbolic/plugins/var_name.rb

@@ -0,0 +1,42 @@
+# This is a simple module to give the name of the Ruby variable to the Symbolic::Variable
+#   x = var #=> x = var :name => 'x')
+# It can also name multiple variables (but with no options then):
+#   x, y = vars
+# This works with caller, and then need to be called directly
+
+module Kernel
+  alias :_var :var
+  def var(options={}, &proc)
+    unless options.has_key? :name
+      file, ln = caller[0].split(':')
+
+      options.merge!(
+      :name => File.open(file) { |f|
+        f.each_line.take(ln.to_i)[-1]
+      }.match(/
+        \s*([[:word:]]+)
+        \s*=
+        \s*var/x
+      ) {
+        $1
+      })
+    end
+    _var(options, &proc)
+  end
+
+  def vars
+    file, ln = caller[0].split(':')
+
+    File.open(file) { |f|
+      f.each_line.take(ln.to_i)[-1]
+    }.match(/
+      ((?:\s*[[:word:]]+?,?)+)
+      \s*=
+      \s*vars/x
+    ) {
+      $1
+    }.scan(/([[:word:]]+)/).map { |capture|
+      _var(:name => capture[0])
+    }
+  end
+end

data/lib/symbolic/printer.rb

@@ -0,0 +1,79 @@
+=begin
+This class intend to handle the String representation of a Symbolic expression
+Two formats will be soon supported: standard and LaTeX
+=end
+module Symbolic
+  class Printer
+    class << self
+      def print(o)
+        send(o.class.simple_name.downcase, o)
+      end
+
+      def brackets(var)
+        [Numeric, Variable, Function].any? { |c| var.is_a? c } ? var.to_s : "(#{var})"
+      end
+
+      def rational(r)
+        "#{r.round == r ? r.to_i : r.to_f}"
+      end
+
+      def coef(c)
+        "#{'-' if c < 0}#{"#{rational c.abs}*" if c.abs != 1}"
+      end
+      def coef_with_sign(c)
+        "#{ c < 0 ? '-' : '+'}#{"#{rational c.abs}*" if c.abs != 1}"
+      end
+
+      # Factors
+      def factors(f)
+        rfactors, factors = f.symbolic.partition { |b,e| e.is_a?(Numeric) && e < 0 }
+        rfactors = rfactors.empty? ? nil : [ 1, Hash[*rfactors.flatten] ]
+        factors = factors.empty? ? nil : [ f.numeric, Hash[*factors.flatten] ]
+
+        s = (factors ? output(factors) : rational(f.numeric))
+        s << "/#{reversed_output rfactors}" if rfactors
+        s
+      end
+      def output(f) # This has to change ! can be inline in ::factors, but needed also in reversed_output
+        coef(f[0]) << f[1].map {|b,e| exponent b,e }.join('*')
+      end
+      def reversed_output(f) # This has to change ! Please make this non dependent of output ;)
+        result = output [f[0], Hash[*f[1].map {|b,e| [b,-e] }.flatten]]
+        (f[1].length > 1) ? "(#{result})" : result
+      end
+      def exponent(base, exponent)
+        "#{brackets base}#{"**#{brackets exponent}" if exponent != 1}"
+      end
+
+      # Summands
+      def summands(s)
+        out = s.symbolic.map { |base, coef| coef_with_sign(coef) + brackets(base) }
+        out << remainder(s.numeric)
+        out[0].sub!(/^\+/, '')
+        out.join
+      end
+
+      def remainder(n)
+        "#{'+' if n > 0}#{n unless n.zero?}"
+      end
+
+      # Variable
+      def variable(v)
+        "#{v.name || :unnamed_variable}"
+      end
+
+      # Function
+      def functionwrapper(f)
+        "#{f.name}(#{f.argument})"
+      end
+
+      def constant(c)
+        "#{c.name || :unnamed_variable}"
+      end
+      # Sums
+      def sum(s)
+        "Sum(#{s.term}, #{s.index} = #{s.lb}..#{s.ub})"
+      end
+    end
+  end
+end

data/lib/symbolic/statistics.rb

@@ -1,13 +1,18 @@
 module Symbolic
+  OPERATIONS = [:+, :-, :*, :/, :**, :-@]
   def operations
     formula = to_s
-    stats = {}
-    stats['+'] = formula.scan(/\+/).size
-    stats['-'] = formula.scan(/[^(]-/).size
-    stats['*'] = formula.scan(/[^*]\*[^*]/).size
-    stats['/'] = formula.scan(/\//).size
-    stats['**']= formula.scan(/\*\*/).size
-    stats['-@']= formula.scan(/\(-/).size + formula.scan(/^-/).size
-    stats
+    OPERATIONS.inject({}) { |stats, op|
+      stats.merge({
+        op => formula.scan(
+        case op
+        when :-  then /[^(]-/
+        when :*  then /[^*]\*[^*]/
+        when :-@ then /\(-|^-/
+        else /#{Regexp.escape(op.to_s)}/
+        end
+        ).size
+      })
+    }
   end
 end

data/lib/symbolic/sum.rb

@@ -0,0 +1,43 @@
+module Symbolic::Misc
+=begin
+blah
+=end
+  class Sum
+    attr_reader :term, :index, :lb, :ub
+    include Symbolic
+    def initialize(term,index,lb,ub)
+      @term, @index, @lb, @ub = term, index, lb, ub
+    end
+    def Sum.[](term,index,lb,ub)
+      Symbolic::Sum.new(term,index,lb,ub)
+    end
+    def expand
+      (lb..ub).collect{|ind| @term.subs(@index,ind)}.inject{|m,t| m + t}
+    end
+    def variables
+      @term.variables.reject{|var| var == @index}
+    end
+    def diff(wrt)
+      #TODO: error if wrt is the index
+      if @term.diff(wrt) != 0
+        Sum.new(@term.diff(wrt),@index,@lb,@ub)
+      else
+        0
+      end
+    end
+    def variables
+      @term.variables.reject{|var| var == @index} #@index doesn't really count
+    end
+    def value
+      self.expand.value
+    end
+    def subs(to_replace, replacement=nil)
+      #TODO: error if to_replace is @index
+      if replacement == nil and to_replace.is_a?(Hash)
+	super(to_replace)
+      else
+	Sum.new(@term.subs(to_replace, replacement),@index,@lb,@ub)
+      end
+    end
+  end
+end

data/lib/symbolic/summands.rb

@@ -1,24 +1,20 @@
 # TODO: 2*symbolic is a 2 power of symbolic Summand
+require "#{File.dirname(__FILE__)}/expression.rb"
 module Symbolic
+  require "#{File.dirname(__FILE__)}/expression.rb"
   class Summands < Expression
+    OPERATION = :+
+    IDENTITY = 0
     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
+        if factors.symbolic.length == 1 && factors.symbolic.first[1] == Factors::IDENTITY
+          new IDENTITY, factors.symbolic.first[0] => factors.numeric
         else
-          new identity_element, Factors.new(1, factors.symbolic) => factors.numeric
+          new IDENTITY, Factors.new(1, factors.symbolic) => factors.numeric
         end
       end
 
@@ -27,41 +23,50 @@ module Symbolic
       end
 
       def simplify(numeric, symbolic)
-        if symbolic.empty?
+        if symbolic.empty? #only the numeric portion
           numeric
-        elsif numeric == identity_element && symbolic.size == 1
-          symbolic.values.first * symbolic.keys.first
+        elsif numeric == IDENTITY && symbolic.size == 1 #no numeric to add and only one symbolic, so can just return the one base*coefficient
+          symbolic.first[1] * symbolic.first[0]
+        elsif symbolic.size > 1 #let's look to see if any base gets repeated, so that they can be combined
+          temp = []
+          symbolic.each_key do |base1|
+            temp = symbolic.find_all{|base2,v2| base1 == base2} #temp is an array of form [[b,c1],[b,c2]...]
+            break if temp.size > 1 #found a duplicate base
+          end
+          if temp.size > 1
+            repeated_base = temp[0][0]
+            new_coef = temp.inject(0){|sum, (b,coeff)| sum + coeff} #sum up the old coefficients
+            #it could be that there is more than one repeated base, but the next line effectively is recursion, and it'll take care of that
+            Summands.new(numeric, symbolic.reject{|k,v| k == repeated_base}) + new_coef * repeated_base
+          else
+            nil
+          end
         end
       end
     end
 
     def value
-      if variables.all? &:value
+      if variables.all?(&:value)
         symbolic.inject(numeric) {|value, (base, coef)| value + base.value * coef.value }
       end
     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]
+      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}"
+    def value
+      @symbolic.inject(@numeric){|m,(base,coefficient)| m + coefficient * base.value}
     end
-
-    def remainder_to_string(numeric)
-      "#{'+' if numeric > 0}#{numeric}"
+    def subs(to_replace, replacement=nil)
+      if replacement == nil and to_replace.is_a?(Hash)
+	super(to_replace)
+      else
+	@symbolic.inject(@numeric){|m,(base,coefficient)| m + coefficient * base.subs(to_replace, replacement)}
+      end
     end
 
-    def rational_to_string(numeric)
-      ((numeric.round == numeric) ? numeric.to_i : numeric.to_f).to_s
+    def diff(wrt)
+      @symbolic.inject(0){|m,(base,coefficient)| m + coefficient * base.diff(wrt)}
     end
   end
 end

data/lib/symbolic/variable.rb

@@ -1,32 +1,44 @@
 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.
+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
     attr_writer :value
 
+    # Create a new Symbolic::Variable, with optional name, value and proc
     def initialize(options={}, &proc)
-      @name, @value = options.values_at(:name, :value)
+      (@name, @value), @proc = options.values_at(:name, :value), proc
       @name = @name.to_s if @name
-      @proc = proc
     end
 
     def value
       @value || @proc && @proc.call.value
     end
 
-    def to_s
-      @name || 'unnamed_variable'
-    end
-
     def variables
       [self]
     end
+
+    def subs(to_replace, replacement=nil, expect_numeric = false)
+      if replacement == nil and to_replace.is_a?(Hash)
+	super(to_replace)
+      else
+	return replacement if self == to_replace
+	#Consider the possibility that @value is not numeric?
+	return self.value if expect_numeric
+	self
+      end
+    end
+
+    def diff(wrt)
+      return 1 if self == wrt
+      0
+    end
   end
 end

data/spec/integration_spec.rb

@@ -0,0 +1,193 @@
+#!/usr/bin/env ruby -w
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Symbolic do
+  describe "evaluation (x=1, y=2):" do
+    x = var :name => :x, :value => 1
+    y = var :name => :y, :value => 2
+    {
+      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.5,
+      y/2       => 1,
+      -2/x      => -2,
+      4/(-y)    => -2,
+      x**2      => 1,
+      4**y      => 16,
+      y**x      => 2,
+      x-(y+x)/5 => Rational(2,5),
+    }.each_pair { |expr, value|
+      it expr do
+        expr.value.should == value
+      end
+    }
+  end
+
+  describe "optimization:" do
+    x = var :name => :x
+    y = var :name => :y
+    {
+      -(-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,
+
+      0 / x       => 0,
+      x / 1       => x,
+
+      0**x        => 0,
+      1**x        => 1,
+      x**0        => 1,
+      x**1        => x,
+      (-x)**1     => -x,
+      (-x)**2     => x**2,
+      (x**2)**y   => x**(2*y),
+
+      x*4*x       => 4*x**2,
+      x*(-1)*x**(-1) => -1,
+      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,
+
+      (x/y)/(x/y) => 1,
+      (y/x)/(x/y) => y**2/x**2,
+
+      x - (y+x)/5 => 0.8*x-0.2*y,
+    }.each_pair { |non_optimized, optimized|
+      it non_optimized do
+        non_optimized.should == optimized
+      end
+    }
+  end
+
+  describe 'Variable methods:' do
+    let(:v) { var :name => :v }
+    let(:x) { var :name => :x, :value => 2 }
+    let(:y) { var :name => :y }
+
+    #initialize
+    it 'var(:name => :v)' do
+      v.name.should == 'v'
+      v.value.should be nil
+    end
+    it 'var.to_s == "unnamed_variable"' do
+      v.name = nil
+      v.to_s.should == 'unnamed_variable'
+      v.value.should be nil
+    end
+    it 'var init' do
+      x.value.should == 2
+    end
+    it 'proc value' do
+      y = var { x**2 }
+      x.value = 3
+      (x*y).value.should == 27
+    end
+
+    it 'expression variables' do
+      x.variables.should == [x]
+      (-(x+y)).variables.should == [x,y]
+    end
+
+    it 'operations' do
+      (-x**y-4*y+5-y/x).operations.should == {:+ => 1, :- => 2, :* => 1, :/ => 1, :-@ => 1, :** => 1}
+    end
+
+    it 'math method' do
+      cos = Symbolic::Math.cos(x)
+      x.value = 0
+      cos.value.should == 1.0
+      cos.to_s.should == 'cos(x)'
+    end
+  end
+
+  describe "to_s:" do
+    x = var :name => :x
+    y = var :name => :y
+    {
+      x                 => 'x',
+      -x                => '-x',
+      x+1               => 'x+1',
+      x-4               => 'x-4',
+      -x-4              => '-x-4',
+      -(x+y)            => '-x-y',
+      -(x-y)            => '-x+y',
+      x*y               => 'x*y',
+      (-x)*y            => '-x*y',
+      (y+3)*(x+2)*4     => '4*(y+3)*(x+2)',
+      4/x               => '4/x',
+      2*x**(-1)*y**(-1) => '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       => '-x**y+7',
+      x-(y+x)/5         => 'x-0.2*(y+x)',
+    }.each_pair { |expr, str|
+      it str do
+        expr.to_s.should == str
+      end
+    }
+  end
+end
+
+describe "Symbolic plugins" do
+  if RUBY_VERSION > '1.9' # Not yet compatible with 1.8
+    describe "var_name" do
+      require "symbolic/plugins/var_name"
+      it 'single variable' do
+        x = var
+        x.name.should == 'x'
+      end
+
+      it 'single variable with value' do
+        x = var :value => 7
+        x.name.should == 'x'
+        x.value.should == 7
+      end
+
+      it 'multiple variables' do
+        x, yy, zzz = vars
+        [x, yy, zzz].map(&:name).should == ['x', 'yy', 'zzz']
+      end
+    end
+  end
+end