ragni-cas 0.2.5 → 0.2.6

data/lib/Mr.CAS/matlab.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+#  __  __      _   _      _      ___ _           _
+# |  \/  |__ _| |_| |__ _| |__  | _ \ |_  _ __ _(_)_ _
+# | |\/| / _` |  _| / _` | '_ \ |  _/ | || / _` | | ' \
+# |_|  |_\__,_|\__|_\__,_|_.__/ |_| |_|\_,_\__, |_|_||_|
+#                                          |___/
+
+module CAS
+  {
+    # Terminal nodes
+    CAS::Constant              => Proc.new { |_v| "#{x}", nil },
+    CAS::Variable              => Proc.new { |_v| "#{name}", nil },
+    CAS::PI_CONSTANT           => Proc.new { |_v| "pi", nil },
+    CAS::INFINITY_CONSTANT     => Proc.new { |_v| "Inf", nil },
+    CAS::NEG_INFINITY_CONSTANT => Proc.new { |_v| "(-Inf)", nil },
+    CAS::E_CONSTANT            => Proc.new { |_v|
+    },
+    # Base functions
+    CAS::Sum    => Proc.new { "(#{x.to_c} + #{y.to_c})" },
+    CAS::Diff   => Proc.new { "(#{x.to_c} - #{y.to_c})" },
+    CAS::Prod   => Proc.new { "(#{x.to_c} * #{y.to_c})" },
+    CAS::Pow    => Proc.new { "pow(#{x.to_c}, #{y.to_c})" },
+    CAS::Div    => Proc.new { "(#{x.to_c}) / (#{y.to_c} + )" },
+    CAS::Sqrt   => Proc.new { "sqrt(#{x.to_c})" },
+    CAS::Invert => Proc.new { "(-#{x.to_c})" },
+    CAS::Abs    => Proc.new { "fabs(#{x.to_c})" },
+
+    # Trigonometric functions
+    CAS::Sin    => Proc.new { "sin(#{x.to_c})" },
+    CAS::Asin   => Proc.new { "asin(#{x.to_c})" },
+    CAS::Cos    => Proc.new { "cos(#{x.to_c})" },
+    CAS::Acos   => Proc.new { "acos(#{x.to_c})" },
+    CAS::Tan    => Proc.new { "tan(#{x.to_c})" },
+    CAS::Atan   => Proc.new { "atan(#{x.to_c})" },
+
+    # Trascendent functions
+    CAS::Exp    => Proc.new { "exp(#{x.to_c})" },
+    CAS::Ln     => Proc.new { "log(#{x.to_c})" },
+
+    # Box Conditions
+    # CAS::BoxConditionOpen => Proc.new {
+    #   ["double __t_#{x.object_id} = #{x.to_c};",
+    #    "(__t_#{x.object_id} > #{lower.latex} && __t_#{x.object_id} < #{upper.latex})"]
+    # },
+    # CAS::BoxConditionUpperClosed => Proc.new {
+    #   ["double __t_#{x.object_id} = #{x.to_c};",
+    #    "(__t_#{x.object_id} > #{lower.latex} && __t_#{x.object_id} <= #{upper.latex})"]
+    # },
+    # CAS::BoxConditionLowerClosed => Proc.new {
+    #   ["double __t_#{x.object_id} = #{x.to_c};",
+    #    "(__t_#{x.object_id} >= #{lower.latex} && __t_#{x.object_id} < #{upper.latex})"]
+    # },
+    # CAS::BoxConditionClosed => Proc.new {
+    #   ["double __t_#{x.object_id} = #{x.to_c};",
+    #    "(__t_#{x.object_id} >= #{lower.latex} && __t_#{x.object_id} <= #{upper.latex})"]
+    # },
+
+    # Conditions
+    CAS::Equal        => Proc.new { "(#{x.to_c} == #{y.to_c})" },
+    CAS::Smaller      => Proc.new { "(#{x.to_c} < #{y.to_c})" },
+    CAS::Greater      => Proc.new { "(#{x.to_c} > #{y.to_c})" },
+    CAS::SmallerEqual => Proc.new { "(#{x.to_c} <= #{y.to_c})" },
+    CAS::GreaterEqual => Proc.new { "(#{x.to_c} >= #{y.to_c})" },
+
+    # Piecewise
+    CAS::Piecewise => Proc.new { raise CASError, "Not implemented yet" },
+    CAS::Max       => Proc.new { raise CASError, "Not implemented yet" },
+    CAS::Min       => Proc.new { raise CASError, "Not implemented yet" }
+  }.each do |cls, blk|
+    cls.send(:define_method, "__to_matlab", &blk)
+  end
+
+  class Op
+    def to_c_lib(name)
+      CAS::Help.assert(name, String)
+      [CAS::C_PLUGIN.write_header(self, name), CAS::C_PLUGIN.write_source(self, name)]
+    end
+  end
+
+end

data/lib/functions/fnc-base.rb

@@ -1,85 +1,6 @@
 #!/usr/vin/env ruby
 
 module CAS
-  #  ___
-  # / __|_  _ _ __
-  # \__ \ || | '  \
-  # |___/\_,_|_|_|_|
-
-  ##
-  # **Sum basic operation**. As for now it is implemented as a simple
-  # binary operation. It will be implemented as n-ary op.
-  class Sum < CAS::BinaryOp
-    # Performs the sum between two `CAS::Op`
-    #
-    # ```
-    #   d
-    # ---- (f(x) + g(x)) = f'(x) + g'(x)
-    #  dx
-    # ```
-    #
-    #  * **argument**: `CAS::Op` argument of derivative
-    #  * **returns**: `CAS::Op` derivative
-    def diff(v)
-      left, right = super v
-
-      return left if right == CAS::Zero
-      return right if left == CAS::Zero
-      left + right
-    end
-
-    # Call resolves the operation tree in a `Numeric` (if `Fixnum`)
-    # or `Float` (depends upon promotions).
-    # As input, it requires an hash with `CAS::Variable` or `CAS::Variable#name`
-    # as keys, and a `Numeric` as a value. In this case it will call
-    # the `Fixnum#overloaded_plus`, that is the old plus function.
-    #
-    #  * **argument**: `Hash` with feed dictionary
-    #  * **returns**: `Numeric`
-    def call(f)
-      CAS::Help.assert(f, Hash)
-      return @x.call(f).overloaded_plus(@y.call(f))
-    end
-
-    # Convert expression to string
-    #
-    #  * **returns**: `String` to print on screen
-    def to_s
-      "(#{@x} + #{@y})"
-    end
-
-    # Same as `CAS::Op`
-    #
-    # Simplifcation engine supports:
-    #
-    #  * x + 0 = x
-    #  * 0 + y = y
-    #  * x + x = 2 x
-    #  * x + (-x) = 0
-    #  * x + (-y) = x - y
-    #  * 1 + 2 = 3 (constants reduction)
-    #
-    #  * **returns**: `CAS::Op` simplified version
-    def simplify
-      super
-      return @y if @x == CAS::Zero
-      return @x if @y == CAS::Zero
-      return @x * 2.0 if @x == @y
-      return CAS::Zero if @x == -@y or -@x == @y
-      return (@x - @y.x) if @y.is_a? CAS::Invert
-      return CAS.const(self.call({})) if (@x.is_a? CAS::Constant and @y.is_a? CAS::Constant)
-      return self
-    end
-
-    # Convert expression to code (internal, for `CAS::Op#to_proc` method)
-    #
-    #  * **returns**: `String` that represent Ruby code to be parsed in `CAS::Op#to_proc`
-    def to_code
-      "(#{@x.to_code} + #{@y.to_code})"
-    end
-  end # Sum
-  CAS::Sum.init_simplify_dict
-
   #  ___  _  __  __
   # |   \(_)/ _|/ _|
   # | |) | |  _|  _/
@@ -149,83 +70,6 @@ module CAS
   end # Difference
   CAS::Diff.init_simplify_dict
 
-  #  ___             _
-  # | _ \_ _ ___  __| |
-  # |  _/ '_/ _ \/ _` |
-  # |_| |_| \___/\__,_|
-
-  ##
-  # Product class. Performs the product between two elements.
-  # This class will be soon modified as an n-ary operator.
-  class Prod < CAS::BinaryOp
-    # Performs the product between two `CAS::Op`
-    #
-    # ```
-    #   d
-    # ---- (f(x) * g(x)) = f'(x) * g(x) + f(x) * g'(x)
-    #  dx
-    # ```
-    #
-    #  * **argument**: `CAS::Op` argument of derivative
-    #  * **returns**: `CAS::Op` derivative
-    def diff(v)
-      left, right = super v
-      return left * @y if right == CAS::Zero
-      return right * @x if left == CAS::Zero
-      (left * @y) + (right * @x)
-    end
-
-    # Call resolves the operation tree in a `Numeric` (if `Fixnum`)
-    # or `Float` (depends upon promotions).
-    # As input, it requires an hash with `CAS::Variable` or `CAS::Variable#name`
-    # as keys, and a `Numeric` as a value. In this case it will call
-    # the `Fixnum#overloaded_plus`, that is the old plus function.
-    #
-    #  * **argument**: `Hash` with feed dictionary
-    #  * **returns**: `Numeric`
-    def call(f)
-      CAS::Help.assert(f, Hash)
-
-      return @x.call(f).overloaded_mul(@y.call(f))
-    end
-
-    # Convert expression to string
-    #
-    #  * **returns**: `String` to print on screen
-    def to_s
-      "(#{@x} * #{@y})"
-    end
-
-    # Same as `CAS::Op`
-    #
-    # Simplifcation engine supports:
-    #
-    #  * x * 0 = x * y = 0
-    #  * 1 * y = y
-    #  * x * 1 = x
-    #  * x * x = x²
-    #  * a * b = c (constants reduction)
-    #
-    #  * **returns**: `CAS::Op` simplified version
-    def simplify
-      super
-      return CAS::Zero if (@x == CAS::Zero or @y == CAS::Zero)
-      return @y if @x == CAS::One
-      return @x if @y == CAS::One
-      return @x ** 2.0 if @x == @y
-      return CAS.const(self.call({})) if @x.is_a? CAS::Constant and @y.is_a? CAS::Constant
-      return self
-    end
-
-    # Convert expression to code (internal, for `CAS::Op#to_proc` method)
-    #
-    #  * **returns**: `String` that represent Ruby code to be parsed in `CAS::Op#to_proc`
-    def to_code
-      "(#{@x.to_code} * #{@y.to_code})"
-    end
-  end # Prod
-  CAS::Prod.init_simplify_dict
-
   #  ___
   # | _ \_____ __ __
   # |  _/ _ \ V  V /
@@ -300,7 +144,7 @@ module CAS
       return self if (@x == CAS::Infinity and @y == CAS::Infinity)
       return self if (@x == CAS::Infinity and @y == CAS::Zero)
       return self if (@x == CAS::Zero and @y == CAS::Infinity)
-      
+
       return CAS::Zero if @x == CAS::Zero
       return CAS::One if @x == CAS::One
       return @x if @y == CAS::One

data/lib/functions/fnc-prod.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+
+module CAS
+
+  #  ___             _
+  # | _ \_ _ ___  __| |
+  # |  _/ '_/ _ \/ _` |
+  # |_| |_| \___/\__,_|
+
+  ##
+  # Product class. Performs the product between two elements.
+  # This class will be soon modified as an n-ary operator.
+  class Prod < CAS::NaryOp
+    # The new element of a sum accumulates inside the
+    # vector that holds the elements
+    def *(op)
+      CAS::Help.assert(op, CAS::Op)
+      @x << op
+      self
+    end
+
+    # Performs the product between two `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- (f(x) * g(x) * h(x)) = f'(x) * g(x) * h(x) +
+    #  dx
+    #                           + f(x) * g'(x) * h(x) +
+    #
+    #                           + f(x) * g(x) * h'(x)
+    # ```
+    #
+    #  * **argument**: `CAS::Op` argument of derivative
+    #  * **returns**: `CAS::Op` derivative
+    def diff(v)
+      xdiff = @x.map { |y| y.diff(v) }
+
+      xdiff.each_with_index { |y, i|
+        xdiff[i] = y * CAS::Prod.new(@x[0...i] + @x[(i + 1)..-1])
+      }
+
+      return CAS::Sum.new(xdiff)
+    end
+
+    # Call resolves the operation tree in a `Numeric` (if `Fixnum`)
+    # or `Float` (depends upon promotions).
+    # As input, it requires an hash with `CAS::Variable` or `CAS::Variable#name`
+    # as keys, and a `Numeric` as a value. In this case it will call
+    # the `Fixnum#overloaded_plus`, that is the old plus function.
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+
+      return @x.inject { |p, y| p = p.overloaded_mul(y.call(f)) }
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "(#{@x.map(&:to_s).join(" * ")})"
+    end
+
+    # Same as `CAS::Op`
+    #
+    # Simplifcation engine supports:
+    #
+    #  * x * 0 = x * y = 0
+    #  * 1 * y = y
+    #  * x * 1 = x
+    #  * x * x = x²
+    #  * a * b = c (constants reduction)
+    #
+    #  * **returns**: `CAS::Op` simplified version
+    def simplify
+      super
+      return CAS::Zero if @x.include? CAS::Zero
+      @x = @x - [CAS::One]
+      return CAS::One if @x.size == 0
+      return @x[0] if @x.size == 1
+
+      @x = self.__reduce_constants(@x) do |cs, xs|
+        [cs.inject { |t, c| t *= c.call({}) }] + xs
+      end
+
+      @x = self.__reduce_multeplicity(@x) do |op, count|
+        count > 1 ? (op ** count) : op
+      end
+      return self
+    end
+
+    # Convert expression to code (internal, for `CAS::Op#to_proc` method)
+    #
+    #  * **returns**: `String` that represent Ruby code to be parsed in `CAS::Op#to_proc`
+    def to_code
+      "(#{@x.map(&:to_code).join(" * ")})"
+    end
+  end # Prod
+  CAS::Prod.init_simplify_dict
+end

data/lib/functions/fnc-sum.rb

@@ -0,0 +1,151 @@
+module CAS
+  #  ___
+  # / __|_  _ _ __
+  # \__ \ || | '  \
+  # |___/\_,_|_|_|_|
+
+  ##
+  # **Sum basic operation**. As for now it is implemented as a simple
+  # binary operation. It will be implemented as n-ary op.
+  class Sum < CAS::NaryOp
+    # Performs the sum between arbitrary number of `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- (f(x) + g(x) + h(x)) = f'(x) + g'(x) + h'(x)
+    #  dx
+    # ```
+    #
+    #  * **argument**: `CAS::Op` argument of derivative
+    #  * **returns**: `CAS::Op` derivative
+    def diff(v)
+      @x.map { |x| x.diff(v) }.inject { |sum_x, dx| sum_x += dx }
+    end
+
+    # The added element of a sum accumulates inside the
+    # vector that holds the elements
+    def +(op)
+      CAS::Help.assert(op, CAS::Op)
+      @x << op
+      self
+    end
+
+    # Call resolves the operation tree in a `Numeric` (if `Fixnum`)
+    # or `Float` (depends upon promotions).
+    # As input, it requires an hash with `CAS::Variable` or `CAS::Variable#name`
+    # as keys, and a `Numeric` as a value. In this case it will call
+    # the `Fixnum#overloaded_plus`, that is the old plus function.
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+      return @x.inject { |val, x_i| val += x_i.call(f) }
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "(#{@x.map(&:to_s).join(" + ")})"
+    end
+
+    # Same as `CAS::Op`
+    #
+    # Simplifcation engine supports:
+    #
+    #  * x + 0 = x
+    #  * 0 + y = y
+    #  * x + x = 2 x
+    #  * x + (-x) = 0
+    #  * x + (-y) = x - y
+    #  * 1 + 2 = 3 (constants reduction)
+    #
+    #  * **returns**: `CAS::Op` simplified version
+    def simplify
+      super
+      return @x[0] if @x.size == 1
+
+      # return CAS::Zero if @x == -@y or -@x == @y
+      # return (@x - @y.x) if @y.is_a? CAS::Invert
+      # return CAS.const(self.call({})) if (@x.is_a? CAS::Constant and @y.is_a? CAS::Constant)
+      # Removing Zeros
+      @x = @x - [CAS::Zero]
+      return CAS::Zero if @x.size == 0
+      # Reduce constants
+      @x = self.__reduce_constants(@x) do |cs, xs|
+        xs + [cs.inject { |t, c| t += c.call({}) }]
+      end
+      # Multeplicity and associativity executed
+      return self.reduce_associativity
+    end
+
+    # Reduces from an associative point of view, by a segregation
+    # of "negative" and positive elements. Negatives comes from
+    # Diff operations and Invert operations. All the others are considered
+    # positive. This function implements an internal heuristic. Should
+    # not be used outside
+    #
+    #  * **returns**: A `CAS::Diff` or a `CAS::Sum`
+    def reduce_associativity
+      pos, neg = [], []
+
+      @x.each do |x_el|
+        case x_el
+        when CAS::Invert
+          neg << x_el.x
+        when CAS::Diff
+          pos << x_el.x
+          neg << x_el.y
+        else
+          pos << x_el
+        end
+      end
+
+      pos, neg = self.reduce_associativity_array pos, neg
+      pos = self.__reduce_multeplicity(pos)
+      neg = self.__reduce_multeplicity neg
+
+      # TODO : Add rules for simplifications
+      left, right = nil, nil
+      left  = CAS::Sum.new(pos) if pos.size > 1
+      left  = pos[0]            if pos.size == 1
+      right = CAS::Sum.new(neg) if neg.size > 1
+      right = neg[0]            if neg.size == 1
+
+      return  CAS::Zero unless left || right
+      return  left unless right
+      return  -right unless left
+      return left - right
+    end
+
+    # Reduce the positive and the negative associative part of
+    # the sum to perform the symbolic difference. Does not take into account
+    # multeplicity
+    #
+    #  * **requires**: positive `Array`
+    #  * **requires**: negative `Array`
+    #  * **returns**: positive, reduced `Array` and negative `Array`
+    def reduce_associativity_array(p_old, n_old)
+      p_del, n_del = [], []
+      p_old.each do |p|
+        n_old.each do |n|
+          if p == n
+            p_del << p
+            n_del << n
+          end
+        end
+      end
+
+      return (p_old - p_del), (n_old - n_del)
+    end
+
+    # Convert expression to code (internal, for `CAS::Op#to_proc` method)
+    #
+    #  * **returns**: `String` that represent Ruby code to be parsed in `CAS::Op#to_proc`
+    def to_code
+      "(#{@x.map(&:to_code).join(" + ")})"
+    end
+  end # Sum
+  CAS::Sum.init_simplify_dict
+end