symbolic 0.3.7 → 0.3.8

data/README.rdoc

@@ -2,6 +2,8 @@ Symbolic math for ruby.
 
 == Installation
 
+Symbolic needs Ruby 1.9.
+
 gem install symbolic
 
 == Introduction
@@ -11,7 +13,7 @@ This gem can help you
 - 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).
+Symbolic doesn't have any external dependencies.
 
 == Tutorial
 
@@ -40,6 +42,14 @@ To get value of symbolic expression you just call value:
 
   f.value # => 7
 
+You can accomplish the same thing with subs:
+
+  f.subs(x,3) # => 7
+
+Or make a more complicated substitution:
+
+  f.subs(x,x**2) # => 2*x**2+1
+
 If symbolic expression contains variables without value then it returns nil.
 
   z = var
@@ -67,16 +77,22 @@ 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:
+You can get information about the 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}
 
+You can also take derivitives and do taylor expansions:
+
+  Symbolic::Math.cos(x**2).diff(x)
+  # => -2*(sin(x**2))*x
+  Symbolic::Math.cos(x).taylor(x,0,3)
+  # => -0.5*x**2+1.0
+
 
 == TODO
 - a lot of refactoring (code is pretty messy at this stage)
 - plotting capabilities
-- derivatives
 - integrals
 - thorough documentation
 
@@ -85,4 +101,4 @@ You can get an information about number of different operations used in a symbol
 brainopia (ravwar at gmail.com).
 
 I am ready to help with any questions related to Symbolic.
-I welcome any contribution.
+I welcome any contribution.

data/Rakefile

@@ -5,13 +5,13 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "symbolic"
-    gem.version = '0.3.7'
+    gem.version = '0.3.8'
     gem.summary = 'Symbolic math for ruby'
     gem.description = 'Symbolic math for ruby. This gem can help if you want to get a simplified form of a big equation or to speed up similar calculations or you need an abstraction layer for math. Symbolic does not have any external dependencies. It uses only pure ruby (less than 400 lines of code).'
     gem.email = "ravwar@gmail.com"
     gem.homepage = "http://brainopia.github.com/symbolic"
     gem.authors = ["brainopia"]
-    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "rspec", ">= 2.4"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
@@ -19,18 +19,7 @@ rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
-
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
-task :spec => :check_dependencies
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task :default => :spec

data/lib/symbolic.rb

@@ -1,17 +1,3 @@
-require 'symbolic/coerced'
-require 'symbolic/variable'
-require 'symbolic/expression'
-require 'symbolic/summands'
-require 'symbolic/factors'
-require 'symbolic/function'
-require 'symbolic/math'
-require 'symbolic/statistics'
-
-require 'symbolic/extensions/kernel'
-require 'symbolic/extensions/numeric'
-require 'symbolic/extensions/matrix' if Object.const_defined? 'Matrix'
-require 'symbolic/extensions/rational' if RUBY_VERSION == '1.8.7'
-
 module Symbolic
   def +@
     self
@@ -45,13 +31,38 @@ module Symbolic
     [Coerced.new(self), numeric]
   end
 
+  def to_s
+    Printer.print(self)
+  end
+
   def inspect
     "Symbolic(#{to_s})"
   end
 
-  private
-
-  def variables_of(var)
-    var.variables rescue []
+  def taylor(var, about, numterms=5)
+    term = self
+    #inject needs initial value to prevent it from eating the first term
+    (0..numterms-1).inject(0) do |sum,n|
+      to_add = term.subs(var,about) * (var - about) ** n / factorial(n)
+      term = term.diff(var) #save a little time by not having to do all the derivites every time
+      sum + to_add
+    end
+  end
+  
+  #make multiple substitutions using a hash. Ex: (x+y+z).subs({x=>2*y,z=>y**2}) results in y**2+3*y
+  def subs(hsh)
+    temp = self
+    hsh.each{|k,v| temp = temp.subs(k,v)}
+    temp
   end
-end
+  
+end
+
+#in order they should be loaded
+['symbolic/expression.rb','symbolic/coerced.rb','symbolic/constants.rb','symbolic/factors.rb',
+'symbolic/printer.rb','symbolic/sum.rb','symbolic/variable.rb','symbolic/constant.rb',
+'symbolic/function.rb','symbolic/misc.rb','symbolic/statistics.rb',
+'symbolic/summands.rb','symbolic/extensions/kernel.rb','symbolic/extensions/matrix.rb','symbolic/extensions/module.rb',
+'symbolic/extensions/numeric.rb','symbolic/extensions/rational.rb','symbolic/math.rb'].each do |file|
+  require File.dirname(__FILE__) + '/' + file
+end

data/lib/symbolic/constant.rb

@@ -0,0 +1,27 @@
+module Symbolic
+  class Constant
+    include Symbolic
+    attr_reader :name, :value
+
+    # Create a new Symbolic::Variable, with optional name, value and proc
+    def initialize(value , name = nil)
+      @name, @value = name, value
+      @name = @name.to_s if @name
+    end
+    def subs(to_replace, replacement=nil)
+      if replacement == nil and to_replace.is_a?(Hash)
+	super(to_replace)
+      else
+	return replacement if self == to_replace
+	self
+      end
+    end
+    def diff(wrt)
+      0
+    end
+    #yeah, it's not a variable, but it acts like one as far as value is concerned
+    def variables
+      [self]
+    end
+  end
+end

data/lib/symbolic/constants.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'complex'
+module Symbolic::Constants
+  require "#{File.dirname(__FILE__)}/constant.rb"
+  if RUBY_VERSION < '1.9'
+    PI = Symbolic::Constant.new(::Math::PI,'PI')
+    I = Symbolic::Constant.new(::Complex::I,'i')
+    E = Symbolic::Constant.new(::Math::E,'e')
+  else #we can use unicode
+    PI = Symbolic::Constant.new(::Math::PI,'π')
+    I = Symbolic::Constant.new(::Complex::I,'ⅈ')
+    E = Symbolic::Constant.new(::Math::E,'ⅇ')
+  end
+end

data/lib/symbolic/expression.rb

@@ -23,7 +23,7 @@ module Symbolic
       end
 
       def unite_numeric(numeric1, numeric2)
-        numeric1.send operation, numeric2
+        numeric1.send self::OPERATION, numeric2
       end
 
       def convert(var)
@@ -39,7 +39,7 @@ module Symbolic
       end
 
       def one(symbolic)
-        new identity_element, symbolic => 1
+        new self::IDENTITY, symbolic => 1
       end
 
       def simple?(var)
@@ -63,11 +63,25 @@ module Symbolic
     end
 
     def variables
-      @symbolic.map {|k,v| [variables_of(k), variables_of(v)] }.flatten.uniq
+      @symbolic.map {|k,v| [k.variables, v.variables] }.flatten.uniq
     end
 
     def ==(object)
-      (object.numeric == @numeric) and (object.symbolic == @symbolic) rescue false
+      # We need to make sure the classes are the same because both Factors and
+      # Summands have .numeric and .symbolic, but we can't say they're equal
+      object.class == self.class and
+      object.numeric == @numeric and
+      # Make sure that we have the same number of elements, otherwise the
+      # next step could give false positives
+      object.symbolic.size == @symbolic.size and
+      # hash's == function only checks that the object_ids are equal, but we
+      # could have different instances of the same object (mathematically speaking). We
+      # need to check that each thing in @symbolic appears in object.symbolic as well.
+      object.symbolic.inject(true) do |memo,(key,value)| # go through each kv pair in object.symbolic
+        memo and @symbolic.inject(false) do |memo2,(key2,value2)|# and make sure it appears in @symbolic
+          memo2 or (key2 == key and value2 == value)
+        end
+      end
     end
   end
 end

data/lib/symbolic/extensions/kernel.rb

@@ -1,5 +1,5 @@
 module Kernel
   def var(options={}, &proc)
-    Symbolic::Variable.new options, &proc
+    Symbolic::Variable.new(options, &proc)
   end
 end

data/lib/symbolic/extensions/matrix.rb

@@ -1,9 +1,11 @@
-class Matrix
-  def value
-    map {|it| it.value }
-  end
+if Object.const_defined? 'Matrix'
+  class Matrix
+    def value
+      map {|it| it.value }
+    end
 
-  def variables
-    map {|it| it.variables }.to_a.flatten.uniq
+    def variables
+      map {|it| it.variables }.to_a.flatten.uniq
+    end
   end
 end

data/lib/symbolic/extensions/module.rb

@@ -0,0 +1,5 @@
+class Module
+  def simple_name
+    name.split('::').last
+  end
+end

data/lib/symbolic/extensions/numeric.rb

@@ -2,4 +2,12 @@ class Numeric
   def value
     self
   end
+
+  def variables
+    []
+  end
+
+  def subs(to_replace, replacement)
+    self
+  end
 end

data/lib/symbolic/extensions/rational.rb

@@ -1,13 +1,19 @@
-# Fix for rational on 1.8.7
-[Fixnum,Bignum].each do |klass|
-  klass.class_eval do
-    def rpower(other)
-      if other.is_a?(Numeric) && other < 0
-        Rational.new!(self, 1)**other
-      else
-        self.power!(other)
+# Fix for Integer#** defined in stdlib rational.rb on ruby < 1.9
+# We need to redefine Integer#**(other)
+# Because, with Rational, it uses a comparaison such as other >= 0
+# That cannot work with Symbolic::Variable (or make sense)
+if RUBY_VERSION < '1.9'
+  require 'rational'
+  [Fixnum,Bignum].each do |klass|
+    klass.class_eval do
+      alias :old_power :**
+      def **(other)
+        if Numeric === other # If other is Numeric, we can use rpower(the new #** defined in stdlib rational.rb)
+          old_power(other)
+        else # But if not, we want the old behaviour(that was aliased to power!, and does not check if >= 0)
+          power!(other)
+        end
       end
-    end
-    alias ** rpower
-  end
-end
+    end # class_eval
+  end # each
+end # if

data/lib/symbolic/factors.rb

@@ -1,14 +1,8 @@
 module Symbolic
   class Factors < Expression
+    OPERATION = :*
+    IDENTITY = 1
     class << self
-      def operation
-        '*'
-      end
-
-      def identity_element
-        1
-      end
-
       def summands(summands)
         one summands
       end
@@ -48,23 +42,23 @@ module Symbolic
       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 }
+        factors[1].delete_if {|base, exp| (base == IDENTITY) || (exp == 0) }
+        factors[0] = 0 if factors[1].any? {|base, _| 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
+        elsif numeric == IDENTITY && symbolic.size == 1 && symbolic.first[1] == 1
+          symbolic.first[0]
         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]
+          [base.numeric**exponent, Hash[*base.symbolic.map {|b,e| [b, e*exponent] }.flatten]]
         else
-          [identity_element, { base => exponent }]
+          [IDENTITY, { base => exponent }]
         end
       end
     end
@@ -74,48 +68,32 @@ module Symbolic
     end
 
     def value
-      if variables.all? &:value
+      if variables.all?(&:value)
         @symbolic.inject(numeric) {|value, (base, exp)| value * base.value ** exp.value }
       end
     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, Variable, Function].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('*')
+    def subs(to_replace, replacement=nil)
+      if replacement == nil and to_replace.is_a?(Hash)
+	super(to_replace)
+      else
+	@symbolic.inject(@numeric){|m,(base,exponential)| m * base.subs(to_replace, replacement) ** exponential.subs(to_replace, replacement)}
+      end
     end
 
-    def reversed_output(factors)
-      result = output [factors[0], Hash[*factors[1].map {|b,e| [b,-e] }.flatten]]
-      (factors[1].length > 1) ? "(#{result})" : result
+    def value
+      @symbolic.inject(@numeric){|m,(base,exponential)| m * base.value ** exponential.value}
     end
 
-    def rational_to_string(numeric)
-      ((numeric.round == numeric) ? numeric.to_i : numeric.to_f).to_s
+    def diff(wrt)
+      return 0 unless self.variables.include?(wrt) #speed things up a bit
+      first_base, first_exp = @symbolic.to_a[0]
+      first = first_base ** first_exp #the first factor
+      self_without_first = self / first #the expression with the first factor removed
+      #product rule to find derivitive
+      udv = self_without_first.is_a?(Symbolic) ? first * self_without_first.diff(wrt) : 0
+      vdu = first_base.is_a?(Symbolic) ? first_exp * first_base ** (first_exp - 1 ) * first_base.diff(wrt) * self_without_first : 0
+      udv + vdu
     end
   end
 end

data/lib/symbolic/function.rb

@@ -1,26 +1,107 @@
-class Symbolic::Function
-=begin
-  This class is proxy for methods from Math module.
-=end
-  include Symbolic
-
-  def initialize(argument, operation)
-    @argument, @operation = argument, operation
-  end
+module Symbolic
+  class Function
+    attr_reader :name, :deriv, :operation
 
-  def to_s
-    "#{@operation}(#{@argument})"
-  end
+    #deriv can be either a function or a proc that takes an argument -- it can be set later
+    #operation can be passed as a block, a proc, or set later
+    def initialize(name, deriv = nil, op = nil, &block)
+      @name, @deriv = name, deriv
+      unless op == nil
+        @operation = op
+      else
+        @operation = block
+      end
+    end
 
-  def value
-    ::Math.send @operation, @argument.value if variables.all? &:value
-  end
+    #it may be easier to set the derivitve after the object is made
+    def set_derivative(deriv)
+      #only allow it to be set if @derivative is nil
+      @deriv = deriv if @deriv == nil
+    end
+
+    def set_operation(op)
+      #only allow it to be set if @derivative is nil
+      @operation = op if @operation == nil
+    end
 
-  def variables
-    @argument.variables
+    #returns a FunctionWrapper with the argument or a number
+    def [] (arg)
+      if arg.is_a?(::Numeric) #take care of the case where arg is a number
+        self.call(arg)
+      else
+        FunctionWrapper.new(arg, self)
+      end
+    end
+
+    #same but with different syntax
+    def arg(arg)
+      self[arg]
+    end
+
+    #returns the derivitve with arg plugged in -- for use with chainrule
+    def derivative(arg)
+      if @deriv.is_a?(Proc)
+        @deriv.call(arg)
+      elsif @deriv.is_a?(Function)
+        @deriv[arg]
+      else  #by process of elimination, it's a Symbolic
+        @deriv.subs(Symbolic::Math::Arg,arg)
+      end
+    end
+
+    def call(arg)
+      @operation.call(arg)
+    end
   end
 
-  def detailed_operations
-    @argument.detailed_operations.tap {|it| it[@operation] += 1}
+  #class combines a function with an argument or arguments
+  #this class is what allows functions to be used in symbolic expressions
+  class FunctionWrapper
+    include Symbolic
+    attr_reader :argument, :function
+
+    def initialize(arg, fctn)
+      @argument, @function = arg, fctn
+    end
+
+    def name
+      @function.name
+    end
+
+    def value
+      @function.call(@argument.value)
+    end
+
+    def variables
+      @argument.variables
+    end
+
+    def detailed_operations
+      @argument.detailed_operations.tap {|it| it[@operation] += 1}
+    end
+
+    def subs(to_replace, replacement=nil)
+      if replacement == nil and to_replace.is_a?(Hash)
+	super(to_replace)
+      else
+	@function[@argument.subs(to_replace, replacement)]
+      end
+    end
+
+    #simply dumps @argument in to the function -- no gaurentee that the function
+    #will know how to handle it. Useful in some circumstances
+    def eval
+      @function.call(@argument)
+    end
+
+    def ==(object)
+      (object.function == @function and object.argument == @argument) rescue false
+    end
+
+    def diff(wrt)
+      return 0 unless self.variables.member?(wrt)
+      #chain rule
+      @function.derivative(@argument)  * @argument.diff(wrt)
+    end
   end
 end