ragni-cas 0.2.2 → 0.2.3

data/lib/operators/op.rb

@@ -0,0 +1,285 @@
+#!/usr/bin/env ruby
+
+module CAS
+  class CASError < RuntimeError; end
+
+  #   ___
+  #  / _ \ _ __
+  # | (_) | '_ \
+  #  \___/| .__/
+  #       |_|
+  class Op
+    # Argument of the operation
+    attr_reader :x
+
+    # Initialize a new empty operation container. This is a virtual
+    # class and the other must inherit from this basic container.
+    # Some methods raise a `CAS::CASError` if called.
+    # The input element is a Numric, to create a constant.
+    # `CAS::Op` specifies operations with a single variable
+    #
+    #  * **argument**: `Numeric` to be converted in `CAS::Constant` or `CAS::Op` child operation
+    #  * **returns**: `CAS::Op` instance
+    def initialize(x)
+      if x.is_a? Numeric
+        x = Op.numeric_to_const x
+      end
+      CAS::Help.assert(x, CAS::Op)
+
+      @x = x
+    end
+
+    def self.numeric_to_const(x)
+      if CAS::NumericToConst[x]
+        return CAS::NumericToConst[x]
+      else
+        return CAS::const x
+      end
+    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
+    end
+
+    # Return the derivative of the operation using the chain rule
+    # The input is a `CAS::Op` because it can handle derivatives
+    # with respect to functions. E.g.:
+    #
+    # ```
+    #  f(x) = (ln(x))**2
+    #  g(x) = ln(x)
+    #
+    #  d f(x)
+    #  ------ = 2 ln(x)
+    #  d g(x)
+    # ```
+    #
+    #  * **argument**: `CAS::Op` object of the derivative
+    #  * **returns**: `CAS::Op` a derivated object, or `CAS::Zero` for constants
+    def diff(v)
+      CAS::Help.assert(v, CAS::Op)
+
+      if @x.depend? v
+        return @x.diff(v)
+      end
+      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**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+
+      @x.call(f)
+    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::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]
+        else
+          raise CAS::CASError, "Impossible subs. Received a #{dt[@x].class} = #{dt[@x]}"
+        end
+      else
+        @x.subs(dt)
+      end
+      return self
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "#{@x}"
+    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}"
+    end
+
+    # Returns a sum of two `CAS::Op`s
+    #
+    #  * **argument**: `CAS::Op` tree
+    #  * **returns**: `CAS::Op` new object
+    def +(op)
+      CAS::Sum.new self, op
+    end
+
+    # Returns a difference of two `CAS::Op`s
+    #
+    #  * **argument**: `CAS::Op` tree
+    #  * **returns**: `CAS::Op` new object
+    def -(op)
+      CAS::Diff.new self, op
+    end
+
+    # Returns a product of two `CAS::Op`s
+    #
+    #  * **argument**: `CAS::Op` tree
+    #  * **returns**: `CAS::Op` new object
+    def *(op)
+      CAS::Prod.new self, op
+    end
+
+    # Returns a division of two `CAS::Op`s
+    #
+    #  * **argument**: `CAS::Op` tree
+    #  * **returns**: `CAS::Op` new object
+    def /(op)
+      CAS::Div.new self, op
+    end
+
+    # Returns the power of two `CAS::Op`s
+    #
+    #  * **argument**: `CAS::Op` tree
+    #  * **returns**: `CAS::Op` new object
+    def **(op)
+      CAS.pow(self, op)
+    end
+
+    # Unary operator for inversion of a `CAS::Op`
+    #
+    #  * **returns**: `CAS::Op` new object
+    def -@
+      CAS.invert(self)
+    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 version
+    def simplify
+      hash = @x.to_s
+      @x = @x.simplify
+      while @x.to_s != hash
+        hash = @x.to_s
+        @x = @x.simplify
+      end
+    end
+
+    # Simplify dictionary performs a dictionary simplification
+    # that is the class variable `@@simplify_dict`
+    #
+    #  * **returns**: `CAS::Op` self
+    def simplify_dictionary
+      if self.class.simplify_dict(@x)
+        return self.class.simplify_dict(@x)
+      else
+        return self
+      end
+    end
+
+    # Initializes the simplification dictionary (one for each class)
+    #
+    # * **returns**: `Hash` with simplification dictionary
+    def self.init_simplify_dict
+      @simplify_dict = { }
+    end
+
+    # Returns an element of a
+    def self.simplify_dict(k)
+      @simplify_dict[k]
+    end
+
+    # Inspector for the current object
+    #
+    #  * **returns**: `String`
+    def inspect
+      "#{self.class}(#{@x.inspect})"
+    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::Op
+        return false if op.is_a? CAS::BinaryOp
+        return (self.class == op.class and @x == op.x)
+      end
+      false
+    end
+
+    # Disequality 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**: `FalseClass` if equal, `TrueClass` if differs
+    def !=(op)
+      not self.==(op)
+    end
+
+    # Evaluates the proc against a given context. It is like having a
+    # snapshot of the tree transformed in a callable object.
+    # Obviously **if the tree changes, the generated proc does notchanges**.
+    # The proc takes as input a feed dictionary in which each variable
+    # is identified through the `CAS::Variable#name` key.
+    #
+    # The proc is evaluated in the context devined by the input `Binding` object
+    # If `nil` is passed, the `eval` will run in this local context
+    #
+    #  * **argument**: `Binding` or `NilClass` that is the context of the Ruby VM
+    #  * **returns**: `Proc` object with a single argument as an `Hash`
+    def as_proc(bind=nil)
+      args_ext = self.args.map { |e| "#{e} = fd[\"#{e}\"];" }
+      code = "Proc.new do |fd|; #{args_ext.join " "} #{self.to_code}; end"
+      if bind # All objects have eval value, we bind when not nil
+        # CAS::Help.assert(bind, Binding)
+        bind.eval(code)
+      else
+        eval(code)
+      end
+    end
+
+    # Returns a list of all `CAS::Variable`s of the current tree
+    #
+    #  * **returns**: `Array` of `CAS::Variable`s
+    def args
+      @x.args.uniq
+    end
+  end # Op
+  CAS::Op.init_simplify_dict
+end

data/lib/overloading/fixnum.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+##
+# Overloading operators for Fixnum. Operations that are
+# oveloaded are:
+#
+# * `overloaded_plus` for `+`
+# * `overloaded_minus` for `-`
+# * `overloaded_mul` for `*`
+# * `overloaded_div` for `/`
+# * `overloaded_pow` for `**`
+class Fixnum
+  # Setting aliases
+  alias :overloaded_plus  :+
+  alias :overloaded_minus :-
+  alias :overloaded_mul   :*
+  alias :overloaded_div   :/
+  alias :overloaded_pow   :**
+  alias :dot_graph :to_s
+
+  ##
+  # If `a` is a `CAS::Op` transform self in a `CAS::Const`
+  # and return a symbolic operation.
+  # If
+  def +(a)
+    return (CAS::const(self) + a) if a.is_a? CAS::Op
+    self.overloaded_plus a
+  end
+
+  ##
+  # If `a` is a `CAS::Op` transform self in a `CAS::Const`
+  # and return a symbolic operation
+  def -(a)
+    return (CAS::const(self) - a) if a.is_a? CAS::Op
+    self.overloaded_minus a
+  end
+
+  ##
+  # If `a` is a `CAS::Op` transform self in a `CAS::Const`
+  # and return a symbolic operation
+  def *(a)
+    return (CAS::const(self) * a) if a.is_a? CAS::Op
+    self.overloaded_mul a
+  end
+
+  ##
+  # If `a` is a `CAS::Op` transform self in a `CAS::Const`
+  # and return a symbolic operation
+  def /(a)
+    return (CAS::const(self) / a) if a.is_a? CAS::Op
+    self.overloaded_div a
+  end
+
+  ##
+  # If `a` is a `CAS::Op` transform self in a `CAS::Const`
+  # and return a symbolic operation
+  def **(a)
+    return (CAS::const(self) ** a) if a.is_a? CAS::Op
+    self.overloaded_pow a
+  end
+end

data/lib/overloading/float.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+##
+# Overloading operators for Float. Operations that are
+# oveloaded are:
+#
+# * `overloaded_plus` for `+`
+# * `overloaded_minus` for `-`
+# * `overloaded_mul` for `*`
+# * `overloaded_div` for `/`
+# * `overloaded_pow` for `**`
+class Float
+  # Setting aliases
+  alias :overloaded_plus  :+
+  alias :overloaded_minus :-
+  alias :overloaded_mul   :*
+  alias :overloaded_div   :/
+  alias :overloaded_pow   :**
+  alias :dot_graph :to_s
+
+  ##
+  # If `a` is a `CAS::Op` transform self in a `CAS::Const`
+  # and return a symbolic operation.
+  # If
+  def +(a)
+    return (CAS::const(self) + a) if a.is_a? CAS::Op
+    self.overloaded_plus a
+  end
+
+  ##
+  # If `a` is a `CAS::Op` transform self in a `CAS::Const`
+  # and return a symbolic operation
+  def -(a)
+    return (CAS::const(self) - a) if a.is_a? CAS::Op
+    self.overloaded_minus a
+  end
+
+  ##
+  # If `a` is a `CAS::Op` transform self in a `CAS::Const`
+  # and return a symbolic operation
+  def *(a)
+    return (CAS::const(self) * a) if a.is_a? CAS::Op
+    self.overloaded_mul a
+  end
+
+  ##
+  # If `a` is a `CAS::Op` transform self in a `CAS::Const`
+  # and return a symbolic operation
+  def /(a)
+    return (CAS::const(self) / a) if a.is_a? CAS::Op
+    self.overloaded_div a
+  end
+
+  ##
+  # If `a` is a `CAS::Op` transform self in a `CAS::Const`
+  # and return a symbolic operation
+  def **(a)
+    return (CAS::const(self) ** a) if a.is_a? CAS::Op
+    self.overloaded_pow a
+  end
+end

data/lib/ragni-cas.rb

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 
+##
 # ragni-cas
 # A very simple CAS engine with encapsuled graph
 # representation. This will make impossible to
@@ -20,206 +21,41 @@
 #
 # Author:: Matteo Ragni (mailto:info@ragni.me)
 # Copyright:: Copyright (c) 2016 Matteo Ragni
-# License:: Distributed under MIT license term
-
-#  ___               _
-# | _ \___ __ _ _  _(_)_ _ ___ ___
-# |   / -_) _` | || | | '_/ -_|_-<
-# |_|_\___\__, |\_,_|_|_| \___/__/
-#            |_|
-
-%w|op.rb numbers.rb fnc-base.rb fnc-trig.rb fnc-trsc.rb fnc-branch.rb version.rb|.each do |r|
-  require File.expand_path(r, File.dirname(__FILE__))
-end
-
+# License:: Distributed under MIT license terms
 module CAS
 
-  # Return a string representation of the graph that is
-  # a Graphviz tree. Requires a `CAS::Op` as argument.
-  # In the next releases probably it will be moved inside
-  # `CAS::Op`.
-  # <- `CAS::Op` instance
-  # -> `String`
-  def self.to_dot(op)
-    CAS::Help.assert(op, CAS::Op)
-
-    node = {}
-    string = op.dot_graph(node)
-    labels = ""
-    lab = {}
-
-    string.scan(/\w+\_\d+/) do |m|
-      if m =~ /(\w+)\_\d+/
-        case $1
-        when "Sum"
-          l = "+"
-        when "Diff"
-          l = "-"
-        when "Prod"
-          l = "×"
-        when "Div"
-          l = "÷"
-        when "Sqrt"
-          l = "√(∙)"
-        when "Abs"
-          l = "|∙|"
-        when "Invert"
-          l = "-(∙)"
-        when "Exp"
-          l = "exp(∙)"
-        when "Log"
-          l = "log(∙)"
-        when "Pow"
-          l = "(∙)^(∙)"
-        when "ZERO_CONSTANT"
-          l = "0"
-        when "ONE_CONSTANT"
-          l = "1"
-        when "TWO_CONSTANT"
-          l = "2"
-        when "PI_CONSTANT"
-          l= "π"
-        when "INFINITY_CONSTANT"
-          l = "∞"
-        when "E_CONSTANT"
-          l = "e"
-        when "MINUS_ONE_CONSTANT"
-          l = "-1"
-        else
-          l = $1
-        end
-        lab[m] = l
-      end
-    end
-    lab.each { |k, v| labels += "  #{k} [label=\"#{v}\"]\n" }
-
-    return <<-EOG
-digraph Op {
-  #{string}#{labels}}
-    EOG
-  end
-
-  # Export the input `CAS::Op` graphviz representation to a file.
-  # <- `String` with filename
-  # <- `CAS::Op` with the tree
-  # -> `CAS::Op` in input
-  def self.export_dot(fl, op)
-    CAS::Help.assert(fl, String)
-    CAS::Help.assert(op, CAS::Op)
-
-    File.open(fl, "w") do |f| f.puts CAS.to_dot(op) end
-    return op
-  end
-
-
   # Support functions are in this separate Helper class
   module Help
     # Check input `obj.class` against a `type` class
     # raises an ArgumentError if check fails
+    #
+    #  * **argument**: object to be cecked
+    #  * **argument**: type to be checked against
+    #  * **returns**: `TrueClass`, or raises an `ArgumentError`
     def self.assert(obj, type)
       raise ArgumentError, "required #{type}, received #{obj.class}" unless obj.is_a? type
+      return true
     end
   end
 end
 
+#  ___               _
+# | _ \___ __ _ _  _(_)_ _ ___ ___
+# |   / -_) _` | || | | '_/ -_|_-<
+# |_|_\___\__, |\_,_|_|_| \___/__/
+#            |_|
 
-#   ___              _              _ _             _  _                    _
-#  / _ \__ _____ _ _| |___  __ _ __| (_)_ _  __ _  | \| |_  _ _ __  ___ _ _(_)__
-# | (_) \ V / -_) '_| / _ \/ _` / _` | | ' \/ _` | | .` | || | '  \/ -_) '_| / _|
-#  \___/ \_/\___|_| |_\___/\__,_\__,_|_|_||_\__, | |_|\_|\_,_|_|_|_\___|_| |_\__|
-#                                           |___/
-class Fixnum
-  alias :overloaded_plus  :+
-  alias :overloaded_minus :-
-  alias :overloaded_mul   :*
-  alias :overloaded_div   :/
-  alias :overloaded_pow   :**
-
-  def +(a)
-    if a.is_a? CAS::Op
-      CAS::const(self) + a
-    else
-      self.overloaded_plus a
-    end
-  end
-
-  def -(a)
-    if a.is_a? CAS::Op
-      CAS::const(self) - a
-    else
-      self.overloaded_minus a
-    end
-  end
-
-  def *(a)
-    if a.is_a? CAS::Op
-      CAS::const(self) * a
-    else
-      self.overloaded_mul a
-    end
-  end
-
-  def /(a)
-    if a.is_a? CAS::Op
-      CAS::const(self) / a
-    else
-      self.overloaded_div a
-    end
-  end
-
-  def **(a)
-    if a.is_a? CAS::Op
-      CAS::const(self) ** a
-    else
-      self.overloaded_pow a
-    end
-  end
+%w|operators/op.rb operators/bary-op.rb operators/nary-op.rb
+   numbers/constants.rb numbers/variables.rb
+   functions/fnc-base.rb functions/fnc-trig.rb functions/fnc-trsc.rb
+   functions/fnc-conditions.rb functions/fnc-box-conditions.rb functions/fnc-piecewise.rb
+   overloading/fixnum.rb overloading/float.rb
+   version.rb|.each do |r|
+  require File.expand_path(r, File.dirname(__FILE__))
 end
 
-class Float
-  alias :overloaded_plus  :+
-  alias :overloaded_minus :-
-  alias :overloaded_mul   :*
-  alias :overloaded_div   :/
-  alias :overloaded_pow   :**
-
-  def +(a)
-    if a.is_a? CAS::Op
-      CAS::const(self) + a
-    else
-      self.overloaded_plus a
-    end
-  end
-
-  def -(a)
-    if a.is_a? CAS::Op
-      CAS::const(self) - a
-    else
-      self.overloaded_minus a
-    end
-  end
-
-  def *(a)
-    if a.is_a? CAS::Op
-      CAS::const(self) * a
-    else
-      self.overloaded_mul a
-    end
-  end
-
-  def /(a)
-    if a.is_a? CAS::Op
-      CAS::const(self) / a
-    else
-      self.overloaded_div a
-    end
-  end
-
-  def **(a)
-    if a.is_a? CAS::Op
-      CAS::const(self) ** a
-    else
-      self.overloaded_pow a
-    end
-  end
+module CAS
+  CAS::NumericToConst[-Math::PI] = (-CAS::Pi)
+  CAS::NumericToConst[-Math::E] = (-CAS::E)
+  CAS::NumericToConst[(-1.0/0.0)]  = (CAS::NegInfinity)
 end

data/lib/version.rb

@@ -2,6 +2,12 @@
 #!/usr/bin/env ruby
 
 module CAS
-  VERSION = [0, 2, 2]
+  # Version of the library
+  # Array of three `Fixnum` values:
+  #
+  #  * Major version
+  #  * Minor version
+  #  * Patchlevel
+  VERSION = [0, 2, 3]
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ragni-cas
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Matteo Ragni
@@ -29,7 +29,7 @@ cert_chain:
   XorZtzkkLImvKFj35xKLFfVkv0Vd8tGQoiL8vdmQNJjAjtE+C+Y7OI4dpiZPKO4G
   R/8JOvUuk9jPbyLxjQH/sFaFqqYGX2xo1zk2CRy/A0WhJrSaXVw1r5lEi7b0W5gg
   -----END CERTIFICATE-----
-date: 2016-08-02 00:00:00.000000000 Z
+date: 2016-10-07 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: info@ragni.me
@@ -37,12 +37,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/fnc-base.rb
-- lib/fnc-branch.rb
-- lib/fnc-trig.rb
-- lib/fnc-trsc.rb
-- lib/numbers.rb
-- lib/op.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-trig.rb
+- lib/functions/fnc-trsc.rb
+- lib/numbers/constants.rb
+- lib/numbers/variables.rb
+- lib/operators/bary-op.rb
+- lib/operators/nary-op.rb
+- lib/operators/op.rb
+- lib/overloading/fixnum.rb
+- lib/overloading/float.rb
 - lib/ragni-cas.rb
 - lib/version.rb
 homepage: https://github.com/MatteoRagni/cas-rb