ragni-cas 0.2.2 → 0.2.3

data/lib/numbers/variables.rb

@@ -0,0 +1,211 @@
+#!/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.
+    @@vars = {}
+
+    # Returns the `Hash` that contains all the variable
+    #
+    #  * **returns**: `Hash`
+    def self.list
+      @@vars
+    end
+
+    # Return the number of variable defined
+    #
+    #  * **returns**: `Fixnum`
+    def self.size
+      @@vars.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)
+      @@vars[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)
+      @@vars.keys.include? name
+    end
+
+    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)
+      raise CASError, "Variable #{name} already exists" if CAS::Variable.exist? name
+      @name = name
+      @@vars[@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)
+      @@vars[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
+
+    # Return the local Graphviz node of the tree
+    #
+    #  * **returns**: `String` of local Graphiz node
+    def dot_graph
+      "#{@name};"
+    end
+
+    # Returns the latex representation of the current Op.
+    #
+    #  * **returns**: `String`
+    def to_latex
+      self.to_s
+    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,185 @@
+#!/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)
+
+      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]
+        else
+          raise CASError, "Impossible subs. Received a #{dt[@x].class} = #{dt[@x]}"
+        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)
+      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]
+        else
+          raise CASError, "Impossible subs. Received a #{dt[@y].class} = #{dt[@y]}"
+        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

data/lib/operators/nary-op.rb

@@ -0,0 +1,175 @@
+#!/usr/bin/env ruby
+
+module CAS
+  # This is an attempt to build some sort of node in the graph that
+  # has arbitrary number of childs node. It should help implement more easily
+  # some sort of better simplifications engine
+  #
+  # This is an incredibly experimental feature.
+  class NaryOp < CAS::Op
+    # List of arguments of the operation
+    attr_reader :x
+
+    # Initialize a new empty N-elements operation container. This is
+    # a virtual class, and other must inherit from this basical container
+    #
+    #  * **argument**: `Numeric` to be converted in `CAS::Constant` or `CAS::Op` child operations
+    #  * **returns**: `CAS::NaryOp` instance
+    def initialize(*xs)
+      @x = []
+      xs.each do |x|
+        if x.is_a? Numeric
+          x = Op.numeric_to_const x
+        end
+        CAS::Help.assert(x, CAS::Op)
+        @x << x
+      end
+    end
+
+    # Returns the dependencies of the operation. Require a `CAS::Variable`
+    # and it is one of the recursive method (implicit tree resolution)
+    #
+    #  * **argument**: `CAS::Variable` instance
+    #  * **returns**: `TrueClass` or `FalseClass`
+    def depend?(v)
+      CAS::Help.assert(v, CAS::Op)
+      dep = false
+      @x.each { |x| dep = (x.depend?(v) or dep) }
+      return dep
+    end
+
+    # Return a list of derivative using the chain rule. The input is a
+    # operation:
+    #
+    # ```
+    #  f(x) = g(x) + h(x) + l(x) + m(x)
+    #
+    #  d f(x)
+    #  ------ = g'(x) + h'(x) + l'(x) + m'(x)
+    #    dx
+    #
+    #  d f(x)
+    #  ------ = 1
+    #  d g(x)
+    # ```
+    #  * **argument**: `CAS::Op` object of the derivative
+    #  * **returns**: `CAS::NaryOp` of derivative
+    def diff(v)
+      CAS::Help.assert(v, CAS::Op)
+      if self.depend?(v)
+        return @x.map { |x| x.diff(v) }
+      end
+      return CAS::Zero
+    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**: `Array` of `Numeric`
+    def call(fd)
+      CAS::Help.assert(fd, Hash)
+      return @x.map { |x| x.call(fd) }
+    end
+
+    # Perform substitution of a part of the graph using a data table:
+    #
+    # ``` ruby
+    # x, y = CAS::vars :x, :y
+    # f = (x ** 2) + (y ** 2)
+    # puts f
+    # # => (x^2) + (y^2)
+    # puts f.subs({x => CAS::ln(y)})
+    # # => (ln(y)^2) + (y^2)
+    # ```
+    #
+    #  * **argument**: `Hash` with substitution table
+    #  * **returns**: `CAS::NaryOp` (`self`) with substitution performed
+    def subs(dt)
+      CAS::Help.assert(dt, Hash)
+      @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]
+          else
+            raise CAS::CASError, "Impossible subs. Received a #{dt[x].class} = #{dt[x]}"
+          end
+        end
+      end
+      return self
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      return "(#{@x.map(&:to_s).join(", ")})"
+    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
+      return "(#{@x.map(&:to_code).join(", ")})"
+    end
+
+    # Simplification callback. It simplify the subgraph of each node
+    # until all possible simplification are performed (thus the execution
+    # time is not deterministic).
+    #
+    #  * **returns**: `CAS::Op` simplified
+    def simplify
+      hash = self.to_s
+      @x = @x.map { |x| x.simplify }
+      while self.to_s != hash
+        hash = self.to_s
+        @x = @x.map { |x| x.simplify }
+      end
+    end
+
+    # Inspector for the current object
+    #
+    #  * **returns**: `String`
+    def inspect
+      "#{self.class}(#{@x.map(&:inspect).join(", ")})"
+    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::NaryOp
+        return false if @x.size != op.x.size
+        0.upto(@x.size - 1) do |i|
+          return false if @x[i] != op.x[i]
+        end
+        return true
+      end
+      false
+    end
+
+    # Returns a list of all `CAS::Variable`s of the current tree
+    #
+    #  * **returns**: `Array` of `CAS::Variable`s
+    def args
+      r = []
+      @x.each { |x| r += x.args }
+      return r.uniq
+    end
+  end # NaryOp
+  CAS::NaryOp.init_simplify_dict
+end