ragni-cas 0.2.5 → 0.2.6

data/lib/numbers/functions.rb

@@ -61,9 +61,9 @@ module CAS
       xs.flatten!
       CAS::Help.assert_name name
       xs.each do |x|
-        CAS::Help.assert x, CAS::Variable
+        CAS::Help.assert x, CAS::Op
       end
-      raise CASError, "Function #{name} already exists" if CAS::Function.exist? name
+      # raise CASError, "Function #{name} already exists" if CAS::Function.exist? name
 
       @x = xs.uniq
       @name = name
@@ -78,19 +78,31 @@ module CAS
     def Function.new(name, *xs)
       xs.flatten!
       if @@container[name]
-        return @@container[name] if (@@container[name].args - xs.uniq == [] or xs.size == 0)
+        # return @@container[name] if (@@container[name].x.uniq - xs.uniq == [] or xs.size == 0)
+        return @@container[name] if (@@container[name].x.uniq.map(&:to_s).sort == xs.uniq.map(&:to_s).sort or xs.size == 0)
         raise CASError, "Function #{name} already defined with different arguments!"
       end
       super
     end
 
     # Returns an array containing `CAS::Variable`s argument of the function
+    # Plese note that sub Op will return their args.
     #
-    #  * **returns**: `Array` containing `CAs:;Variable`
+    #  * **returns**: `Array` containing `CAs::Variable`
     def args
-      @x
+      ret = []
+      @x.each do |e|
+        ret << e.args
+      end
+      ret.flatten.uniq
     end
 
+    # Get an element in a particular position of the argument
+    #
+    #  * **requires**: an iterator
+    #  * **returns**: element of the argument `CAS::Op` or `NilClass`
+    def [](i); @x[i]; end
+
     # Simplifications cannot be performed on anonymous function, thus it will always return
     # the `self` `CAS::Function` object
     #
@@ -117,14 +129,7 @@ module CAS
     #  * **returns**: a `CAS::Function` with modified argument list
     #  * **raises**: `CASError` if something different with resppect to a `CAS::Variable` is a active substitution
     def subs(s)
-      s.each do |k, v|
-        next unless self.depend? k
-        if v.is_a? CAS::Variable
-          (@x.collect! { |e| (e == k) ? v : e }).uniq!
-          next
-        end
-        raise CASError, "Cannot perform a substitution in #{self.class}"
-      end
+      @x.each { |e| e.subs(s) }
       self
     end
 
@@ -134,11 +139,15 @@ module CAS
     #  * **requires**: a `CAS::Variable` for derivative
     #  * **returns**: the `CAS::Variable` derivated function
     def diff(v)
-      if self.depend? v
-        return CAS.declare :"d#{@name}[#{v}]", @x
-      else
-        return CAS::Zero
+      # return CAS.declare :"d#{@name}[#{v}]", @x
+      ret = []
+      @x.each_with_index do |x, k|
+        dx = (x.depend?(v) ? x.diff(v) : CAS::Zero)
+        dfx = CAS.declare :"D#{@name}[#{k}]", @x
+        ret << dx * dfx
       end
+      return CAS::Zero if ret == []
+      return ret.inject { |d, e| d += e }
     end
 
     # Trying to call a `CAS::Function` will always return a `CAS::Error`
@@ -166,7 +175,7 @@ module CAS
     #  * **returns**: `TrueClass` if functions are equal, `FalseClass` if not equal
     def ==(op)
       return false if not self.class == op.class
-      return false if not (@name == op.name and @x == op.args)
+      return false if not (@name == op.name and @x.uniq == op.x.uniq)
       true
     end
   end # Function

data/lib/operators/bary-op.rb

@@ -79,14 +79,14 @@ module CAS
     #  * **returns**: `CAS::BinaryOp`, in practice `self`
     def subs_lhs(dt)
       CAS::Help.assert(dt, Hash)
-
-      if dt.keys.include? @x
-        if dt[@x].is_a? CAS::Op
-          @x = dt[@x]
-        elsif dt[@x].is_a? Numeric
-          @x = CAS::const dt[@x]
+      sub = dt.keys.select { |e| e == @x }[0]
+      if sub
+        if dt[sub].is_a? CAS::Op
+          @x = dt[sub]
+        elsif dt[sub].is_a? Numeric
+          @x = CAS::const dt[sub]
         else
-          raise CASError, "Impossible subs. Received a #{dt[@x].class} = #{dt[@x]}"
+          raise CASError, "Impossible subs. Received a #{dt[sub].class} = #{dt[sub]}"
         end
       else
         @x.subs(dt)
@@ -100,13 +100,14 @@ module CAS
     #  * **returns**: `CAS::BinaryOp`, in practice `self`
     def subs_rhs(dt)
       CAS::Help.assert(dt, Hash)
-      if dt.keys.include? @y
-        if dt[@y].is_a? CAS::Op
-          @y = dt[@y]
-        elsif dt[@y].is_a? Numeric
-          @y = CAS::const dt[@y]
+      sub = dt.keys.select { |e| e == @y }[0]
+      if sub
+        if dt[sub].is_a? CAS::Op
+          @y = dt[sub]
+        elsif dt[sub].is_a? Numeric
+          @y = CAS::const dt[sub]
         else
-          raise CASError, "Impossible subs. Received a #{dt[@y].class} = #{dt[@y]}"
+          raise CASError, "Impossible subs. Received a #{dt[sub].class} = #{dt[sub]}"
         end
       else
         @y.subs(dt)

data/lib/operators/nary-op.rb

@@ -17,7 +17,7 @@ module CAS
     #  * **returns**: `CAS::NaryOp` instance
     def initialize(*xs)
       @x = []
-      xs.each do |x|
+      xs.flatten.each do |x|
         if x.is_a? Numeric
           x = Op.numeric_to_const x
         end
@@ -93,14 +93,16 @@ module CAS
     #  * **returns**: `CAS::NaryOp` (`self`) with substitution performed
     def subs(dt)
       CAS::Help.assert(dt, Hash)
+      @x = @x.map { |z| z.subs(dt) || z }
       @x.each_with_index do |x, k|
-        if dt.keys.include? x
-          if dt[x].is_a? CAS::Op
-            @x[k] = dt[x]
-          elsif dt[x].is_a? Numeric
-            @x[k] = CAS::const dt[x]
+        sub = dt.keys.select { |e| e == x }[0]
+        if sub
+          if dt[sub].is_a? CAS::Op
+            @x[k] = dt[sub]
+          elsif dt[sub].is_a? Numeric
+            @x[k] = CAS::const dt[sub]
           else
-            raise CAS::CASError, "Impossible subs. Received a #{dt[x].class} = #{dt[x]}"
+            raise CAS::CASError, "Impossible subs. Received a #{dt[sub].class} = #{dt[sub]}"
           end
         end
       end
@@ -168,6 +170,63 @@ module CAS
       @x.each { |x| r += x.args }
       return r.uniq
     end
+
+    # Reduce multeplicity will scan for elements that are equal in the definition
+    # of the sum and will reduce their multeplicity. A block can be used to do something
+    # different. For example in nary-product we use it like this:
+    #
+    # ``` ruby
+    # @x = self.__reduce_multeplicity(@x) do |count, op|
+    #   count > 1 ? (op ** count) : op
+    # end
+    # ```
+    #
+    # In general it works like that:
+    #
+    # ```
+    #  a + a + b + c => 2 * a + b + c
+    #  a * a * b * a => (a ** b) * b
+    # ```
+    # But operates only on Array level! This is an internal function
+    # and should never be used
+    #
+    #  * **requires**: An `Array`
+    #  * **returns**: An `Array` with multeplicity reduced
+    #  * **block**: yields the count and the op. Get the value to insert in a new
+    #    `Array` that is the returned `Array`
+    def __reduce_multeplicity(xs)
+      count = Hash.new(0)
+      xs.each do |x|
+        e = x
+        count.keys.each { |d| e = d if x == d  }
+        count[e] += 1
+      end
+      count.map do |k, v|
+        if block_given?
+          yield(k, v)
+        else
+          v > 1 ? CAS.const(v) * k : k
+        end
+      end
+    end
+
+    # Collects all the constants and tries to reduce them to a single constant.
+    # Requires a block to understand what it should do with the constants
+    #
+    # * **requires**: input `Array` of `CAS::Op`
+    # * **returns**: new `Array` of `CAS::Op`
+    # * **block**: yields an `Array` of `CAS::Constant` and an `Array` of others `CAS::Op`,
+    #   requires an `Array` back
+    def __reduce_constants(xs)
+      const = []
+      xs.each { |x| const << x if x.is_a? CAS::Constant }
+      if const.size > 0
+        yield const, (xs - const)
+      else
+        xs
+      end
+    end
+
   end # NaryOp
   CAS::NaryOp.init_simplify_dict
 end

data/lib/operators/op.rb

@@ -107,11 +107,12 @@ module CAS
     #  * **returns**: `CAS::Op` (`self`) with substitution performed
     def subs(dt)
       CAS::Help.assert(dt, Hash)
-      if dt.keys.include? @x
-        if dt[@x].is_a? CAS::Op
-          @x = dt[@x]
-        elsif dt[@x].is_a? Numeric
-          @x = CAS::const dt[@x]
+      sub = dt.keys.select { |e| e == @x }[0]
+      if sub
+        if dt[sub].is_a? CAS::Op
+          @x = dt[sub]
+        elsif dt[sub].is_a? Numeric
+          @x = CAS::const dt[sub]
         else
           raise CAS::CASError, "Impossible subs. Received a #{dt[@x].class} = #{dt[@x]}"
         end
@@ -140,7 +141,7 @@ module CAS
     #  * **argument**: `CAS::Op` tree
     #  * **returns**: `CAS::Op` new object
     def +(op)
-      CAS::Sum.new self, op
+      CAS::Sum.new [self, op]
     end
 
     # Returns a difference of two `CAS::Op`s
@@ -156,7 +157,7 @@ module CAS
     #  * **argument**: `CAS::Op` tree
     #  * **returns**: `CAS::Op` new object
     def *(op)
-      CAS::Prod.new self, op
+      CAS::Prod.new [self, op]
     end
 
     # Returns a division of two `CAS::Op`s

data/lib/version.rb

@@ -1,4 +1,3 @@
-
 #!/usr/bin/env ruby
 
 module CAS
@@ -8,6 +7,6 @@ module CAS
   #  * Major version
   #  * Minor version
   #  * Patchlevel
-  VERSION = [0, 2, 5]
+  VERSION = [0, 2, 6]
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ragni-cas
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Matteo Ragni
@@ -29,7 +29,7 @@ cert_chain:
   XorZtzkkLImvKFj35xKLFfVkv0Vd8tGQoiL8vdmQNJjAjtE+C+Y7OI4dpiZPKO4G
   R/8JOvUuk9jPbyLxjQH/sFaFqqYGX2xo1zk2CRy/A0WhJrSaXVw1r5lEi7b0W5gg
   -----END CERTIFICATE-----
-date: 2016-10-13 00:00:00.000000000 Z
+date: 2016-11-28 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: info@ragni.me
@@ -37,10 +37,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/Mr.CAS.rb
+- lib/Mr.CAS/auto-diff.rb
+- lib/Mr.CAS/c-opt.rb
+- lib/Mr.CAS/c.rb
+- lib/Mr.CAS/graphviz.rb
+- lib/Mr.CAS/latex.rb
+- lib/Mr.CAS/matlab.rb
 - lib/functions/fnc-base.rb
 - lib/functions/fnc-box-conditions.rb
 - lib/functions/fnc-conditions.rb
 - lib/functions/fnc-piecewise.rb
+- lib/functions/fnc-prod.rb
+- lib/functions/fnc-sum.rb
 - lib/functions/fnc-trig.rb
 - lib/functions/fnc-trsc.rb
 - lib/numbers/constants.rb
@@ -51,9 +60,6 @@ files:
 - lib/operators/op.rb
 - lib/overloading/fixnum.rb
 - lib/overloading/float.rb
-- lib/ragni-cas.rb
-- lib/ragni-cas/plugins/graphviz.rb
-- lib/ragni-cas/plugins/latex.rb
 - lib/version.rb
 homepage: https://github.com/MatteoRagni/cas-rb
 licenses:
@@ -75,8 +81,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: An extremely simple CAS, for rapid prototyping and meta-programming
+summary: 'THIS IS OUTDATED! PLEASE CHECK: https://rubygems.org/gems/Mr.CAS'
 test_files: []