Mr.CAS 0.2.6

data/lib/numbers/functions.rb

@@ -0,0 +1,194 @@
+#!/usr/bin/env ruby
+
+module CAS
+  #  ___             _   _
+  # | __|  _ _ _  __| |_(_)___ _ _
+  # | _| || | ' \/ _|  _| / _ \ ' \
+  # |_| \_,_|_||_\__|\__|_\___/_||_|
+
+  # Unknown function class. Will allow to make symbolic differentiation and
+  # so on.
+  class Function < CAS::NaryOp
+    # Contains all defined functions. Container is a `Hash` with name of the
+    # function as key and the function as the value
+    @@container = {}
+
+    # Return the `Hash` of the functions
+    #
+    #  * **returns**: `Hash`
+    def self.list; @@container; end
+
+    # Return `true` if a function was already defined
+    #
+    #  * **argument**: name of the function to be checked
+    def self.exist?(name)
+      CAS::Help.assert_name name
+      (@@container[name] ? true : false)
+    end
+
+    # Return the number of functions defined
+    #
+    #  * **returns**: `Fixnum`
+    def self.size; @@container.keys.size; end
+
+    # Returns a function given its name
+    #
+    #  * **argument**: `Object` name of the function
+    #  * **returns**: `CAS::Function` instance if exists, raises a `CAS::CASError`
+    #    if not
+    def self.[](s)
+      return @@container[s] if self.exist? s
+      raise CASError, "Function #{s} not found"
+    end
+
+    # Returns `true` if a function exists in container
+    #
+    #  * **argument**: `String` or `Symbol` that represent the functions
+    #  * **returns**: `TrueClass` if variable exists, `FalseClass` if not
+    def self.exist?(name); @@container.keys.include?(name); end
+
+    # The attribute `name` identifies the current function. A function with the
+    # same name of an existing function connot be defined
+    attr_reader :name
+
+    # Initializes a new function. It requires a name and a series of arguments
+    # that will be the functions on which it depends.
+    #
+    #  * **argument**: `String` or `Symbol` name of the variable
+    #  * **argument**: `Array` of `CAS::Variable` that are argument of the function
+    #  * **returns**: `CAS::Function`
+    def initialize(name, *xs)
+      xs.flatten!
+      CAS::Help.assert_name name
+      xs.each do |x|
+        CAS::Help.assert x, CAS::Op
+      end
+      # raise CASError, "Function #{name} already exists" if CAS::Function.exist? name
+
+      @x = xs.uniq
+      @name = name
+      @@container[@name] = self
+    end
+
+    # Overrides new method. This will return an existing function if in the function container
+    #
+    #  * **requires**: `String` or `Symbol` that is the name of the function
+    #  * **requires**: `Array` of `CAS::Variable`
+    #  * **returns**: a new `CAS::Function` or the old one
+    def Function.new(name, *xs)
+      xs.flatten!
+      if @@container[name]
+        # 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`
+    def args
+      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
+    #
+    #  * **returns**: `CAS::Function` self instance
+    def simplify; self; end
+
+    # Tries to convert an anonymous function into Ruby code will always raise a `CASError` because it
+    # is not possible to generate code for such a fuction
+    #
+    #  * **raises**: `CAS::CASError`: Ruby code for CAs::Function cannot be generated
+    def to_code
+      raise CASError, "Ruby code for #{self.class} cannot be generated"
+    end
+
+    # Substitutions in which a function is involved directly generates a CAS::Error unless the substitution will
+    # involve another variable. Example:
+    #
+    # ``` ruby
+    # (CAS.declare :f [x, y, z]).subs { x => x ** 2 } # this raises CASError
+    # (CAS.declare :f [x, y, z]).subs { x => y } # this returns f(y, z)
+    # ```
+    #
+    #  * **requires**: a substitution `Hash`
+    #  * **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)
+      @x.each { |e| e.subs(s) }
+      self
+    end
+
+    # Performs the derivative with respect to one of the variable. The new function
+    # has a name with respect to a schema that for now is fixed (TODO: make it variable and user defined).
+    #
+    #  * **requires**: a `CAS::Variable` for derivative
+    #  * **returns**: the `CAS::Variable` derivated function
+    def diff(v)
+      # 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`
+    #
+    #  * **raises**: `CAS::CASError`
+    def call(_v)
+      raise CASError, "Cannot call a #{self.class}"
+    end
+
+    # Returns the inspect string of the function, that is similar to `CAS::Function#to_s`
+    #
+    #  * **returns**: inspection `String`
+    def inspect; self.to_s; end
+
+    # Returns a description `String` for the `CAS::Function`
+    #
+    #  * **returns**: `String`
+    def to_s
+      "#{@name}(#{@x.map(&:to_s).join(", ")})"
+    end
+
+    # Checks if two functions can be considered equal (same name, same args)
+    #
+    #  * **requires**: another op to be checked against
+    #  * **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.uniq == op.x.uniq)
+      true
+    end
+  end # Function
+
+  class << self
+    # This shortcut allows to declare a new function
+    #
+    #  * **requires**: `String` or `Symbol` that is the name of the function
+    #  * **requires**: `Array` of `CAS::Variable`
+    #  * **returns**: a new `CAS::Function` or the old one
+    def declare(name, *xs)
+      xs.flatten!
+      CAS::Function.new(name, xs)
+    end
+  end
+end

data/lib/numbers/variables.rb

@@ -0,0 +1,202 @@
+#!/usr/bin/env ruby
+
+module CAS
+  # __   __        _      _    _
+  # \ \ / /_ _ _ _(_)__ _| |__| |___
+  #  \ V / _` | '_| / _` | '_ \ / -_)
+  #   \_/\__,_|_| |_\__,_|_.__/_\___|
+
+  ##
+  # Container for a variable. It can be resolved in a numerical value.
+  # It can also be used for derivatives.
+  class Variable < CAS::Op
+    # Contains all define variable, in an hash. Variables are
+    # accessible through variable name.
+    @@container = {}
+
+    # Returns the `Hash` that contains all the variable
+    #
+    #  * **returns**: `Hash`
+    def self.list
+      @@container
+    end
+
+    # Return the number of variable defined
+    #
+    #  * **returns**: `Fixnum`
+    def self.size
+      @@container.keys.size
+    end
+
+    # Returns a variable given its name
+    #
+    #  * **argument**: `Object` name of the variable
+    #  * **returns**: `CAS::Variable` instance if exists, creates a new variable if does not
+    def self.[](s)
+      @@container[s] || CAS::vars(s)
+    end
+
+    # Returns `true` if a variable already exists
+    #
+    #  * **argument**: `Object` that represent the variable
+    #  * **returns**: `TrueClass` if variable exists, `FalseClass` if not
+    def self.exist?(name)
+      @@container.keys.include? name
+    end
+
+    # The attribute `name` identifies the current variable. A variable with the
+    # same name of an existing variable connot be defined
+    attr_reader :name
+
+    # Variable is a container for an atomic simbol that becomes a number
+    # when `CAS::Op#call` method is used.
+    #
+    #  * **argument**: `Object` that is a identifier for the variable
+    #  * **returns**: `CAS::Variable` instance
+    def initialize(name)
+      CAS::Help.assert_name name
+      raise CASError, "Variable #{name} already exists" if CAS::Variable.exist? name
+      @name = name
+      @@container[@name] = self
+    end
+
+    # Overrides new method. This will return an existing variable if in variable container
+    #
+    # * **requires**: `Object` that is an identifier for the variable
+    # * **returns**: new variable instance o
+    def Variable.new(name)
+      @@container[name] || super
+    end
+
+    # Returns the derivative of a variable
+    #
+    # ```
+    #  dx      dx
+    #  -- = 1; -- = 0
+    #  dx      dy
+    # ```
+    #
+    #  * **argument**: `CAS::Op` for the derivative denominator
+    #  * **returns**: `CAS::Constant`, 0 if not depended, 1 if dependent
+    def diff(v)
+      (self == v ? CAS::One : CAS::Zero)
+    end
+
+    # Returns `TrueClass` if argument of the function is equal
+    # to `self`
+    #
+    #  * **argument**: `CAS::Op`
+    #  * **returns**: `TrueClass` or `FalseClass`
+    def depend?(v)
+      self == v
+    end
+
+    # Equality operator, the standard operator is overloaded
+    # :warning: this operates on the graph, not on the math
+    # See `CAS::equal`, etc.
+    #
+    #  * **argument**: `CAS::Op` to be tested against
+    #  * **returns**: `TrueClass` if equal, `FalseClass` if differs
+    def ==(op)
+      # CAS::Help.assert(op, CAS::Op)
+      if op.is_a? CAS::Variable
+        return self.inspect == op.inspect
+      else
+        false
+      end
+    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
+    #
+    # ``` ruby
+    # x, y = CAS::vars :x, :y
+    # f = (x ** 2) + (y ** 2)
+    # f.call({x => 1, y => 2})
+    # # => 2
+    # ```
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+
+      return f[self] if f[self]
+      return f[@name] if f[@name]
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "#{@name}"
+    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
+      "#{@name}"
+    end
+
+    # Returns an array containing `self`
+    #
+    #  * **returns**: `Array` containing `self`
+    def args
+      [self]
+    end
+
+    # Terminal substitutions for variables. If input datatable
+    # contains the variable will perform the substitution with
+    # the value.
+    #
+    #  * **argument**: `Hash` of substitutions
+    #  * **returns**: `CAS::Op` of substitutions
+    def subs(dt)
+      CAS::Help.assert(dt, Hash)
+      if dt.keys.include? self
+        if dt[self].is_a? CAS::Op
+          return dt[self]
+        elsif dt[self].is_a? Numeric
+          return CAS::const(dt[self])
+        else
+          raise CASError, "Impossible subs. Received a #{dt[self].class} = #{dt[self]}"
+        end
+      end
+    end
+
+    # Inspector for the current object
+    #
+    #  * **returns**: `String`
+    def inspect
+      "Var(#{@name})"
+    end
+
+    # Simplification callback. The only possible simplification
+    # is returning `self`
+    #
+    #  * **returns**: `CAS::Variable` as `self`
+    def simplify
+      self
+    end
+  end # Number
+
+  # Allows to define a series of new variables.
+  #
+  # ``` ruby
+  # x, y = CAS::vars :x, :y
+  # ```
+  #
+  #  * **argument**: `Array` of Numeric
+  #  * **returns**: `Array` of `CAS::Variable`
+  def self.vars(*name)
+    (return CAS::Variable.new(name[0])) if name.size == 1
+    ret = []
+    name.each do |n|
+      ret << CAS::Variable.new(n)
+    end
+    return ret
+  end
+end

data/lib/operators/bary-op.rb

@@ -0,0 +1,186 @@
+#!/usr/bin/env ruby
+
+module CAS
+  #  ___ _                     ___
+  # | _ |_)_ _  __ _ _ _ _  _ / _ \ _ __
+  # | _ \ | ' \/ _` | '_| || | (_) | '_ \
+  # |___/_|_||_\__,_|_|  \_, |\___/| .__/
+  #                      |__/      |_|
+
+  ##
+  # Binary operator
+  class BinaryOp < CAS::Op
+    # First element of the operation
+    attr_reader :x
+    # Second element of the operation
+    attr_reader :y
+
+    # The binary operator inherits from the `CAS::Op`, even
+    # if it is defined as a node with two possible branches. This
+    # is particular of the basic operations. The two basic nodes
+    # shares the **same** interface, so all the operations do not
+    # need to know which kind of node they are handling.
+    #
+    #  * **argument**: `CAS::Op` left argument of the node or `Numeric` to be converted in `CAS::Constant`
+    #  * **argument**: `CAS::Op` right argument of the node or `Numeric` to be converted in `CAS::Constant`
+    #  * **returns**: `CAS::BinaryOp` instance
+    def initialize(x, y)
+      if x.is_a? Numeric
+        x = BinaryOp.numeric_to_const x
+      end
+      if y.is_a? Numeric
+        y = BinaryOp.numeric_to_const y
+      end
+      CAS::Help.assert(x, CAS::Op)
+      CAS::Help.assert(y, CAS::Op)
+
+      @x = x
+      @y = y
+    end
+
+    # Return the dependencies of the operation. Requires a `CAS::Variable`
+    # and it is one of the recursve method (implicit tree resolution)
+    #
+    #  * **argument**: `CAS::Variable` instance
+    #  * **returns**: `TrueClass` if depends, `FalseClass` if not
+    def depend?(v)
+      CAS::Help.assert(v, CAS::Op)
+
+      @x.depend? v or @y.depend? v
+    end
+
+    # This method returns an array with the derivatives of the two branches
+    # of the node. This method is usually called by child classes, and it is not
+    # intended to be used directly.
+    #
+    #  * **argument**: `CAS::Op` operation to differentiate against
+    #  * **returns**: `Array` of differentiated branches ([0] for left, [1] for right)
+    def diff(v)
+      CAS::Help.assert(v, CAS::Op)
+      left, right = CAS::Zero, CAS::Zero
+
+      left = @x.diff(v) if @x.depend? v
+      right = @y.diff(v) if @y.depend? v
+
+      return left, right
+    end
+
+    # Substituitions for both branches of the graph, same as `CAS::Op#subs`
+    #
+    #  * **argument**: `Hash` of substitutions
+    #  * **returns**: `CAS::BinaryOp`, in practice `self`
+    def subs(dt)
+      return self.subs_lhs(dt).subs_rhs(dt)
+    end
+
+    # Substituitions for left branch of the graph, same as `CAS::Op#subs`
+    #
+    #  * **argument**: `Hash` of substitutions
+    #  * **returns**: `CAS::BinaryOp`, in practice `self`
+    def subs_lhs(dt)
+      CAS::Help.assert(dt, Hash)
+      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[sub].class} = #{dt[sub]}"
+        end
+      else
+        @x.subs(dt)
+      end
+      return self
+    end
+
+    # Substituitions for left branch of the graph, same as `CAS::Op#subs`
+    #
+    #  * **argument**: `Hash` of substitutions
+    #  * **returns**: `CAS::BinaryOp`, in practice `self`
+    def subs_rhs(dt)
+      CAS::Help.assert(dt, Hash)
+      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[sub].class} = #{dt[sub]}"
+        end
+      else
+        @y.subs(dt)
+      end
+      return self
+    end
+
+    # Same `CAS::Op#call`
+    #
+    #  * **argument**: `Hash` of values
+    #  * **returns**: `Numeric` for result
+    def call(_fd)
+      raise CAS::CASError, "Not Implemented. This is a virtual method"
+    end
+
+    # String representation of the tree
+    #
+    #  * **returns**: `String`
+    def to_s
+      raise CAS::CASError, "Not Implemented. This is a virtual method"
+    end
+
+    # Code to be used in `CAS::BinaryOp#to_proc`
+    #
+    #  * **returns**: `String`
+    def to_code
+      raise CAS::CASError, "Not implemented. This is a virtual method"
+    end
+
+    # Returns an array of all the variables that are in the graph
+    #
+    #  * **returns**: `Array` of `CAS::Variable`s
+    def args
+      (@x.args + @y.args).uniq
+    end
+
+    # Inspector
+    #
+    #  * **returns**: `String`
+    def inspect
+      "#{self.class}(#{@x.inspect}, #{@y.inspect})"
+    end
+
+    # Comparison with other `CAS::Op`. This is **not** a math operation.
+    #
+    #  * **argument**: `CAS::Op` to be compared against
+    #  * **returns**: `TrueClass` if equal, `FalseClass` if different
+    def ==(op)
+      CAS::Help.assert(op, CAS::Op)
+      if op.is_a? CAS::BinaryOp
+        return (self.class == op.class and @x == op.x and @y == op.y)
+      else
+        return false
+      end
+    end
+
+    # Executes simplifications of the two branches of the graph
+    #
+    #  * **returns**: `CAS::BinaryOp` as `self`
+    def simplify
+      hash = @x.to_s
+      @x = @x.simplify
+      while @x.to_s != hash
+        hash = @x.to_s
+        @x = @x.simplify
+      end
+      hash = @y.to_s
+      @y = @y.simplify
+      while @y.to_s != hash
+        hash = @y.to_s
+        @y = @y.simplify
+      end
+    end
+  end # BinaryOp
+  CAS::BinaryOp.init_simplify_dict
+end