ragni-cas 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f98cf94916ce493037fae540da85b571d677a72
-  data.tar.gz: 80e70754e06f40feb3f3ea8ef63bcf77824a77fc
+  metadata.gz: d1727dd0447e3614d413bf740c0e2012a032d8f3
+  data.tar.gz: b3470c930416120a63e903934b39c738797ec0e2
 SHA512:
-  metadata.gz: 08cc60ffe01d6b41c85e45d9e76dc89dc4ffeb01fafbf005df1ed9c68247944f9b635806c346ca6d3f196cc8964dbb04e06177ce1bd64da0dfef4d356929068b
-  data.tar.gz: 4c10e0659a2651b0c6d5919845ee1670a515f4218fb1445d978c4dfe161aa38bea057bb4d7335975afd50eb08e3f71fc2b27ae22104cb502f66d25e5cfecc115
+  metadata.gz: 1ff61d15cb0576883729cf5faaca1a04ceee6f05d5206fb0ac379300be89c7e584c38ee0c95c8b70665879cc426d3a3e28bd5b2b23a9ac85c5f43bee9d059802
+  data.tar.gz: 6a97d066096a1a0d3d991474bf076b3b215f8fa14262bbd41931c86fff1b168c84914171d376d01070dc0cf06bde9c7784f1720c2cf39942c6bf09b6f143ca99

checksums.yaml.gz.sig

@@ -1,2 +1,2 @@
-��ZQz�^?�.�����`�j�ރ�=�����x�@��(�R�Hv|���C)/`&2T�r.�	w��7W��o�Ȁ��L��pA쾷�*��K+��GZ	GU�IIG�KF��ݢgA}&�4%(bbGN+�)3�m�?P�L�(�C�u56'!�‚�V��(;T���hI7bA���nX�j�ʈz?��I����UV��pt���W�X���[0r+	�d��^����@u;�ku��
-�x=��
+'.��C��q������ϢH@���9��@*�<�0��N_�����лB�S��W��ӉԖ����'~�]��~Ȱ��f�͋5�uv�����`����H�g/֨�����q�[m��S��￣��a�mx'Z��W�~���7\]�ֽW=ϗ79=z�b����	i�M��<���.�	m/��X��54�/��0	7:�,jXO~�cJ>�"}H��,I�7l�vr��bO?Xv�^EV��
+��Q����3�X'k�{����<<

data/lib/fnc-base.rb

@@ -6,21 +6,34 @@ module CAS
   # \__ \ || | '  \
   # |___/\_,_|_|_|_|
   class Sum < CAS::BinaryOp
+    # Performs the sum between two `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- (f(x) + g(x)) = f'(x) + g'(x)
+    #  dx
+    # ```
     def diff(v)
       left, right = super v
-      return left if (right == nil or right == CAS::Zero)
-      return right if (left == nil or left == CAS::Zero)
+
+      return left if right == CAS::Zero
+      return right if left == CAS::Zero
       left + right
     end
 
+    # Same as `CAS::Op`
     def call(f)
+      CAS::Help.assert(f, Hash)
+
       return @x.call(f) + @y.call(f)
     end
 
+    # Same as `CAS::Op`
     def to_s
       "(#{@x} + #{@y})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -34,17 +47,21 @@ module CAS
       end
       if @x == -@y or -@x == @y
         return CAS::Zero
-      end 
+      end
       if @x.is_a? CAS::Constant and @y.is_a? CAS::Constant
         return CAS.const(self.call({}))
       end
       return self
     end
 
+    # Same as `CAS::Op`
     def ==(op)
+      CAS::Help.assert(op, CAS::Op)
+
       self.class == op.class and ((@x == op.x and @y == op.y) or (@y == op.x and @x == op.y))
     end
 
+    # Same as `CAS::Op`
     def to_code
       "(#{@x.to_code} + #{@y.to_code})"
     end
@@ -55,21 +72,33 @@ module CAS
   # | |) | |  _|  _/
   # |___/|_|_| |_|
   class Diff < CAS::BinaryOp
+    # Performs the difference between two `CAS::Op`s
+    #
+    # ```
+    #   d
+    # ---- (f(x) - g(x)) = f'(x) - g'(x)
+    #  dx
+    # ```
     def diff(v)
       left, right = super v
-      return left if (right == nil or right == CAS::Zero)
-      return CAS::Invert.new(right) if (left == nil or left == CAS::Zero)
+      return left if right == CAS::Zero
+      return CAS::Invert.new(right) if left == CAS::Zero
       left - right
     end
 
+    # Same as `CAS::Op`
     def call(f)
+      CAS::Help.assert(f, Hash)
+
       return @x.call(f) - @y.call(f)
     end
 
+    # Same as `CAS::Op`
     def to_s
       "(#{@x} - #{@y})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -87,10 +116,13 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def ==(op)
+      CAS::Help.assert(op, CAS::Op)
       self.class == op.class and ((@x == op.x and @y == op.y) or (@y == op.x and @x == op.y))
     end
 
+    # Same as `CAS::Op`
     def to_code
       "(#{@x.to_code} - #{@y.to_code})"
     end
@@ -101,21 +133,33 @@ module CAS
   # |  _/ '_/ _ \/ _` |
   # |_| |_| \___/\__,_|
   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
+    # ```
     def diff(v)
       left, right = super v
-      return left * @y if (right == nil or right == CAS::Zero)
-      return right * @x if (left == nil or left == CAS::Zero)
+      return left * @y if right == CAS::Zero
+      return right * @x if left == CAS::Zero
       (left * @y) + (right * @x)
     end
 
+    # Same as `CAS::Op`
     def call(f)
+      CAS::Help.assert(f, Hash)
+
       return @x.call(f) * @y.call(f)
     end
 
+    # Same as `CAS::Op`
     def to_s
       "(#{@x} * #{@y})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero or @y == CAS::Zero
@@ -136,10 +180,14 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def ==(op)
+      CAS::Help.assert(op, CAS::Op)
+
       self.class == op.class and ((@x == op.x and @y == op.y) or (@y == op.x and @x == op.y))
     end
 
+    # Same as `CAS::Op`
     def to_code
       "(#{@x.to_code} * #{@y.to_code})"
     end
@@ -150,25 +198,45 @@ module CAS
   # |  _/ _ \ V  V /
   # |_| \___/\_/\_/
   class Pow < CAS::BinaryOp
+    # Performs the power between two `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- (f(x)^a) = f(x)^(a - 1) * a * f'(x)
+    #  dx
+    #
+    #   d
+    # ---- (a^f(x)) = a^f(x) * f'(x) * ln a
+    #  dx
+    #
+    #   d
+    # ---- (f(x)^g(x)) = (f(x)^g(x)) * (g'(x) * ln f(x) + g(x) * f'(x) / f(x))
+    #  dx
+    # ```
     def diff(v)
       diff_x, diff_y = super v
-      if diff_y == nil or diff_y == CAS::Zero
+      if diff_y == CAS::Zero
         return ((@x ** (@y - 1.0)) * @y * diff_x)
-      elsif diff_x == nil or diff_x == CAS::Zero
+      elsif diff_x == CAS::Zero
         return (@x ** @y) * diff_y * CAS.ln(@x)
       else
         return (@x ** @y) * ((diff_y * CAS.ln(@x)) + (@y * diff_x / @x))
       end
     end
 
+    # Same as `CAS::Op`
     def call(f)
+      CAS::Help.assert(f, Hash)
+
       @x.call(f) ** @y.call(f)
     end
 
+    # Same as `CAS::Op`
     def to_s
       "#{@x}^#{@y}"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -189,6 +257,7 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def to_code
       "(#{@x.to_code} ** #{@y.to_code})"
     end
@@ -203,25 +272,37 @@ module CAS
   # | |) | \ V /
   # |___/|_|\_/
   class Div < CAS::BinaryOp
+    # Performs the division between two `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- (f(x) / g(x)) = (f'(x) * g(x) - f(x) * g'(x))/(g(x)^2)
+    #  dx
+    # ```
     def diff(v)
       diff_x, diff_y = super v
-      if diff_y == nil or diff_y == CAS::Zero
+      if diff_y == CAS::Zero
         return (diff_x/@y)
-      elsif diff_x == nil or diff_x == CAS::Zero
+      elsif diff_x == CAS::Zero
         return CAS.invert(@x * diff_y / CAS.pow(@y, CAS.const(2.0)))
       else
         return ((diff_x * @y) - (diff_y * @x))/CAS.pow(@y, CAS.const(2.0))
       end
     end
 
+    # Same as `CAS::Op`
     def call(f)
+      CAS::Help.assert(f, Hash)
+
       @x.call(f)/@y.call(f)
     end
 
+    # Same as `CAS::Op`
     def to_s
       "(#{@x}) / (#{@y})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -242,6 +323,7 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def to_code
       "(#{@x.to_code} / #{@y.to_code})"
     end
@@ -253,6 +335,13 @@ module CAS
   # |___/\__, |_|  \__|
   #         |_|
   class Sqrt < CAS::Op
+    # Performs the square root between two `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- √f(x) = 1/2 * f'(x) * √f(x)
+    #  dx
+    # ```
     def diff(v)
       if @x.depend? v
         return (@x.diff(v) / (CAS.const(2.0) * CAS.sqrt(@x)))
@@ -261,14 +350,19 @@ module CAS
       end
     end
 
+    # Same as `CAS::Op`
     def call(f)
+      CAS::Help.assert(f, Hash)
+
       Math::sqrt @x.call(f)
     end
 
+    # Same as `CAS::Op`
     def to_s
       "√(#{@x})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x.is_a? CAS::Pow
@@ -286,6 +380,7 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def to_code
       "Math::sqrt(#{@x.to_code})"
     end
@@ -300,22 +395,34 @@ module CAS
   #  | || ' \ V / -_) '_|  _|
   # |___|_||_\_/\___|_|  \__|
   class Invert < CAS::Op
+    # Performs the inversion of a `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- (-f(x)) = -f'(x)
+    #  dx
+    # ```
     def diff(v)
       if @x.depend? v
-        CAS::const(-1.0) * @x.diff
+        CAS::const(-1.0) * @x.diff(v)
       else
         CAS::Zero
       end
     end
 
+    # Same as `CAS::Op`
     def call(f)
+      CAS::Help.assert(f, Hash)
+
       -1.0 * @x.call(f)
     end
 
+    # Same as `CAS::Op`
     def to_s
       "-#{@x}"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -327,6 +434,7 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def to_code
       "(-#{@x.to_code})"
     end
@@ -341,6 +449,13 @@ module CAS
   #  / _ \| '_ (_-<
   # /_/ \_\_.__/__/
   class Abs < CAS::Op
+    # Performs the absolute value of a `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- |f(x)| = f'(x) * (f(x) / |f(x)|)
+    #  dx
+    # ```
     def diff(v)
       if @x.depend? v
         return @x.diff * (@x/CAS.abs(@x))
@@ -349,15 +464,20 @@ module CAS
       end
     end
 
+    # Same as `CAS::Op`
     def call(f)
+      CAS::Help.assert(f, Hash)
+
       s = (@x.call(f) >= 0 ? 1 : -1)
       return s * @x.call(f)
     end
 
+    # Same as `CAS::Op`
     def to_s
       "|#{@x}|"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -369,6 +489,7 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def to_code
       "(#{@x.to_code}).abs"
     end

data/lib/fnc-branch.rb

@@ -0,0 +1,198 @@
+#!/usr/bin/env ruby
+
+module CAS
+  class Piecewise < CAS::BinaryOp
+    attr_reader :condition
+
+    def initialize(x, y, condition)
+      CAS::Help.assert(condition, CAS::Condition)
+
+      super(x, y)
+      @condition = condition
+    end
+
+    def diff(v)
+      CAS::Help.assert(v, CAS::Op)
+
+      return CAS::Piecewise.new(@x.diff(v).simplify, @y.diff(v).simplify, condition)
+    end
+
+    def call(fd)
+      CAS::Help.assert(fd, Hash)
+
+      (@condition.call(fd) ? @x.call(fd) : @y.call(fd))
+    end
+
+    def ==(op)
+      CAS::Help.assert(op, CAS::Op)
+
+      if self.class != op.class
+        return false
+      else
+        return ((@x == op.x) and (@y == op.y) and (@condition == op.condition))
+      end
+    end
+
+    def to_code
+      "(#{@condition.to_code} ? (#{@x.to_code}) : (#{@y.to_code}))"
+    end
+
+    def to_s
+      "(#{@condition} ? #{@x} : #{@y})"
+    end
+
+    def dot_graph(node)
+      cls = "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id}"
+      "#{cls} -> #{@x.dot_graph node}\n  #{cls} -> #{@y.dot_graph node}\n  #{cls} -> #{@condition.dot_graph node}"
+    end
+  end
+
+
+  def self.max(x, y)
+    CAS::Piecewise.new(x, y, CAS::greater_equal(x, y))
+  end
+
+  def self.min(x, y)
+    CAS::Piecewise.new(x, y, CAS::smaller_equal(x, y))
+  end
+
+  class Condition
+    attr_reader :x, :y, :type
+
+    def initialize(type, x, y)
+      CAS::Help.assert(type, Symbol)
+
+      @x = x
+      @y = y
+      case type
+      when :eq
+        @type = "=="
+        self.define_singleton_method("call") do |fd|
+          @x.call(fd) == @y.call(fd)
+        end
+      when :gt
+        @type = ">"
+        self.define_singleton_method("call") do |fd|
+          @x.call(fd) > @y.call(fd)
+        end
+      when :lt
+        @type = "<"
+        self.define_singleton_method("call") do |fd|
+          @x.call(fd) < @y.call(fd)
+        end
+      when :geq
+        @type = "≥"
+        self.define_singleton_method("call") do |fd|
+          @x.call(fd) >= @y.call(fd)
+        end
+      when :leq
+        @type = "≤"
+        self.define_singleton_method("call") do |fd|
+          @x.call(fd) <= @y.call(fd)
+        end
+      else
+        raise CASError, "Unknown condition #{@type}"
+      end
+    end
+
+    def inspect
+      "#{@x.inspect} #{@type} #{@y.inspect}"
+    end
+
+    def to_s
+      "#{@x} #{@type} #{@y}"
+    end
+
+    def to_code
+      "#{@x}.call(fd) #{@type} #{@y}.call(fd)"
+    end
+
+    def args
+      (@x.args + @y.args).uniq
+    end
+
+    def diff(v)
+      @x.diff(v)
+      @y.diff(v)
+      self.simplify
+    end
+
+    def depend?(v)
+      @x.depend?(v) or @y.depend?(v)
+    end
+
+    def ==(op)
+      CAS::Help.assert(op, CAS::Op)
+      condA = (@x == op.x) and (@y == op.y)
+      condB = (@x == op.y) and (@y == op.x)
+      condC = condA or condB
+      return (condC and (self.class == op.class) and (@type == op.type))
+    end
+
+    def !=(op)
+      not self == op
+    end
+
+    def simplify
+      @x.simplify
+      @y.simplify
+      return self
+    end
+
+    def subs(fd)
+      CAS::Help.assert(fd, Hash)
+      @x.subs(fd)
+      @y.subs(fd)
+      return self
+    end
+
+    def dot_graph(node)
+      cls = "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id}"
+      "#{cls} -> #{@x.dot_graph node}\n  #{cls} -> #{@y.dot_graph node}"
+    end
+  end
+
+  class Equal < CAS::Condition
+    def initialize(x, y)
+      super(:eq, x, y)
+    end
+  end
+
+  class Greater < CAS::Condition
+    def initialize(x, y)
+      super(:gt, x, y)
+    end
+  end
+
+  class GreaterEqual < CAS::Condition
+    def initialize(x, y)
+      super(:geq, x, y)
+    end
+  end
+
+  class Smaller < CAS::Condition
+    def initialize(x, y)
+      super(:lt, x, y)
+    end
+  end
+
+  class SmallerEqual < CAS::Condition
+    def initialize(x, y)
+      super(:leq, x, y)
+    end
+  end
+
+  def self.equal(x, y); CAS::Equal.new(x, y); end
+  def self.greater(x, y); CAS::Greater.new(x, y); end
+  def self.greater_equal(x, y); CAS::GreaterEqual.new(x, y); end
+  def self.smaller(x, y); CAS::Smaller.new(x, y); end
+  def self.smaller_equal(x, y); CAS::SmallerEqual.new(x, y); end
+
+  class Op
+    def equal(v); CAS.equal(self, v); end
+    def greater(v); CAS.greater(self, v); end
+    def smaller(v); CAS.smaller(self, v); end
+    def greater_equal(v); CAS.greater_equal(self, v); end
+    def smaller_equal(v); CAS.smaller_equal(self, v); end
+  end
+end