ragni-cas 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f5aedceb3a3141a14a807fdbbac42e5bc66fd85
-  data.tar.gz: caa36f84a6e77cac0f1a6c5410c63cd2940297bd
+  metadata.gz: 84aec56cb941ff1f7b44e118dc3bed327272591d
+  data.tar.gz: 350d3a2064312c08c3a900633e2b0672bf140aa3
 SHA512:
-  metadata.gz: 9a56cda36bc0ac20cb444e1ad663b29c4ddeaac92e97239edfbc8631ef7ec054bc4d626919ed7efbf7200898f62bd7e731380f708bb0631345e60677eba684c2
-  data.tar.gz: 7c9ac6f8cb07d8a0a967b8afd655790a4d8d147fbcf4c2f9d939d763427e2e18405513c24b1bd0a4eb1bd72cee11d4c8ef710ed8c47e775afdda49ce3a12a606
+  metadata.gz: e2a944fe15271c1ef65184a6ab5dd8610617294648cfdb0d67efd351167f4a4e1bd764eeadb0f0c7bfbaf1c35f9d00ff16ca2cca2458c94039faf4018eb6d00c
+  data.tar.gz: 519a211ffcc69806c6c8b366a588e0258a73114f73dd0e8fd5445c9118e93c4f9ae2f71b75ff7682f3ad2ed3ae32bb9bf50726e715f8255f371035249d09dcc9

data/lib/functions/fnc-base.rb

@@ -296,6 +296,11 @@ module CAS
     #  * **returns**: `CAS::Op` simplified version
     def simplify
       super
+      return self if (@x == CAS::Zero and @y == CAS::Zero)
+      return self if (@x == CAS::Infinity and @y == CAS::Infinity)
+      return self if (@x == CAS::Infinity and @y == CAS::Zero)
+      return self if (@x == CAS::Zero and @y == CAS::Infinity)
+      
       return CAS::Zero if @x == CAS::Zero
       return CAS::One if @x == CAS::One
       return @x if @y == CAS::One
@@ -386,10 +391,16 @@ module CAS
     #  * **returns**: `CAS::Op` simplified version
     def simplify
       super
+      return self if (@x == CAS::Zero and @y == CAS::Zero)
+      return self if (@x == CAS::Infinity and @y == CAS::Infinity)
+      return self if (@x == CAS::Infinity and @y == CAS::Zero)
+      return self if (@x == CAS::Zero and @y == CAS::Infinity)
+
       return CAS::Zero if @x == CAS::Zero
       return CAS::Infinity if @y == CAS::Zero
       return @x if @y == CAS::One
       return CAS::Zero if @y == CAS::Infinity
+      return CAS::One if @x == @y
       return CAS.const(self.call({})) if (@x.is_a? CAS::Constant and @y.is_a? CAS::Constant)
       return self
     end
@@ -464,7 +475,7 @@ module CAS
     #  * **returns**: `CAS::Op` simplified version
     def simplify
       super
-      return CAS.pow(@x.x, @y - 0.5) if @x.is_a? CAS::Pow
+      return (CAS.pow(@x.x, @x.y - 0.5)).simplify if @x.is_a? CAS::Pow
       return CAS::Zero if @x == CAS::Zero
       return CAS::One if @x == CAS::One
       return CAS.const(self.call({})) if (@x.is_a? CAS::Constant and @y.is_a? CAS::Constant)
@@ -509,7 +520,7 @@ module CAS
     #  * **returns**: `CAS::Op` derivative
     def diff(v)
       if @x.depend? v
-        CAS::const(-1.0) * @x.diff(v)
+        -@x.diff(v)
       else
         CAS::Zero
       end
@@ -593,7 +604,7 @@ module CAS
     #  * **returns**: `CAS::Op` derivative
     def diff(v)
       if @x.depend? v
-        return @x.diff(x) * (@x/CAS.abs(@x))
+        return @x.diff(v) * (@x/CAS.abs(@x))
       else
         return CAS::Zero
       end

data/lib/functions/fnc-box-conditions.rb

@@ -272,30 +272,33 @@ module CAS
     end
   end # BoxConditionUpperClosed
 
-  # Shortcut for creating a new box condition. It requires four arguments:
-  #
-  #  * **argument**: `CAS::Op` function for condition
-  #  * **argument**: `CAS::Constant` lower limit
-  #  * **argument**: `CAs::Constant` upper limit
-  #  * **argument**: `Symbol` of condition type it can be:
-  #     - `:closed` for `CAs::BoxConditionClosed`
-  #     - `:open` for `CAs::BoxConditionOpen`
-  #     - `:upper_closed` for `CAs::BoxConditionUpperClosed`
-  #     - `:lower_closed` for `CAs::BoxConditionLowerClosed`
-  #  * **returns**: `CAS::BoxCondition` new instance
-  def self.box(x, a, b, type=:closed)
-    case type
-    when :closed
-      return CAS::BoxConditionClosed.new(x, a, b)
-    when :open
-      return CAS::BoxConditionOpen.new(x, a, b)
-    when :upper_closed
-      return CAS::BoxConditionUpperClosed.new(x, a, b)
-    when :lower_closed
-      return CAS::BoxConditionLowerClosed.new(x, a, b)
-    else
-      raise CAS::CASError, "Unknown box condition type"
+  class << self
+    # Shortcut for creating a new box condition. It requires four arguments:
+    #
+    #  * **argument**: `CAS::Op` function for condition
+    #  * **argument**: `CAS::Constant` lower limit
+    #  * **argument**: `CAs::Constant` upper limit
+    #  * **argument**: `Symbol` of condition type it can be:
+    #     - `:closed` for `CAs::BoxConditionClosed`
+    #     - `:open` for `CAs::BoxConditionOpen`
+    #     - `:upper_closed` for `CAs::BoxConditionUpperClosed`
+    #     - `:lower_closed` for `CAs::BoxConditionLowerClosed`
+    #  * **returns**: `CAS::BoxCondition` new instance
+    def box(x, a, b, type=:closed)
+      case type
+      when :closed
+        return CAS::BoxConditionClosed.new(x, a, b)
+      when :open
+        return CAS::BoxConditionOpen.new(x, a, b)
+      when :upper_closed
+        return CAS::BoxConditionUpperClosed.new(x, a, b)
+      when :lower_closed
+        return CAS::BoxConditionLowerClosed.new(x, a, b)
+      else
+        raise CAS::CASError, "Unknown box condition type"
+      end
     end
+    alias :in :box
   end
 
   class Op

data/lib/functions/fnc-trig.rb

@@ -63,7 +63,8 @@ module CAS
     def self.init_simplify_dict
       @simplify_dict = {
         CAS::Zero => CAS::Zero,
-        CAS::Pi => CAS::Zero
+        CAS::Pi => CAS::Zero,
+        CAS::Pi/2 => CAS::One
       }
     end
 
@@ -152,14 +153,16 @@ module CAS
   end
   CAS::Asin.init_simplify_dict
 
-  # Shortcut for `CAS::Asin#new`
-  #
-  #  * **argument**: `CAS::Op` argument of the function
-  #  * **returns**: `CAS::Asin` operation
-  def self.asin(x)
-    CAS::Asin.new x
+  class << self
+    # Shortcuts for `CAS::Asin#new`
+    #
+    #  * **argument**: `CAS::Op` argument of the function
+    #  * **returns**: `CAS::Asin` operation
+    def asin(x)
+      CAS::Asin.new x
+    end
+    alias :arcsin :asin
   end
-  # alias :arcsin :asin
 
   #   ___
   #  / __|___ ___
@@ -223,7 +226,8 @@ module CAS
     def self.init_simplify_dict
       @simplify_dict = {
         CAS::Zero => CAS::One,
-        CAS::Pi => CAS::One
+        CAS::Pi => CAS::One,
+        CAS::Pi/2 => CAS::Zero
       }
     end
 
@@ -307,14 +311,16 @@ module CAS
   end
   CAS::Acos.init_simplify_dict
 
-  # Shortcut for `CAS::Acos#new`
-  #
-  #  * **argument**: `CAS::Op` argument of the function
-  #  * **returns**: `CAS::Acos` operation
-  def self.acos(x)
-    CAS::Acos.new x
+  class << self
+    # Shortcut for `CAS::Acos#new`
+    #
+    #  * **argument**: `CAS::Op` argument of the function
+    #  * **returns**: `CAS::Acos` operation
+    def acos(x)
+      CAS::Acos.new x
+    end
+    alias :arccos :acos
   end
-  # alias :arccos :acos
 
   #  _____
   # |_   _|_ _ _ _
@@ -378,7 +384,8 @@ module CAS
     def self.init_simplify_dict
       @simplify_dict = {
         CAS::Zero => CAS::Zero,
-        CAS::Pi => CAS::Zero
+        CAS::Pi => CAS::Zero,
+        CAS::Pi/2 => CAS::Infinity
       }
     end
 
@@ -466,22 +473,17 @@ module CAS
     def to_code
       "Math::atan(#{@x.to_code})"
     end
-
-    # Returns the latex representation of the current Op.
-    #
-    #  * **returns**: `String`
-    def to_latex
-      "\\arctan\\left( #{@x.to_latex} \\right)"
-    end
   end
   CAS::Atan.init_simplify_dict
 
-  # Shortcut for `CAS::Atan#new`
-  #
-  #  * **argument**: `CAS::Op` argument of the function
-  #  * **returns**: `CAS::Atan` operation
-  def self.atan(x)
-    CAS::Atan.new x
+  class << self
+    # Shortcut for `CAS::Atan#new`
+    #
+    #  * **argument**: `CAS::Op` argument of the function
+    #  * **returns**: `CAS::Atan` operation
+    def atan(x)
+      CAS::Atan.new x
+    end
+    alias :arctan :atan
   end
-  # alias :arctan :atan
 end

data/lib/functions/fnc-trsc.rb

@@ -83,6 +83,7 @@ module CAS
       "e^{#{@x.to_latex}}"
     end
   end # Exp
+  CAS::Exp.init_simplify_dict
 
   # Shortcut for `CAS::Exp#new`
   #
@@ -178,19 +179,14 @@ module CAS
   end # Ln
   CAS::Ln.init_simplify_dict
 
-  # Shortcut for `CAS::Ln#new`
-  #
-  #  * **argument**: `CAS::Op` argument of the function
-  #  * **returns**: `CAS::Ln` operation
-  def self.ln(x)
-    CAS::Ln.new x
-  end
-
-  # Shortcut for `CAS::Ln#new`
-  #
-  #  * **argument**: `CAS::Op` argument of the function
-  #  * **returns**: `CAS::Ln` operation
-  def self.log(x)
-    CAS::Ln.new x
+  class << self
+    # Shortcut for `CAS::Ln#new`
+    #
+    #  * **argument**: `CAS::Op` argument of the function
+    #  * **returns**: `CAS::Ln` operation
+    def ln(x)
+      CAS::Ln.new x
+    end
+    alias :log :ln
   end
 end

data/lib/numbers/constants.rb

@@ -95,14 +95,6 @@ module CAS
     def inspect
       "Const(#{self})"
     end
-
-    # Return the local Graphviz node of the tree
-    #
-    #  * **returns**: `String` of local Graphiz node
-    def dot_graph
-      n = "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id}"
-      "#{n};\n  #{n} [label=\"#{@x}\"];"
-    end
   end
 
   # Allows to define a series of new constants.

data/lib/numbers/functions.rb

@@ -0,0 +1,185 @@
+#!/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::Variable
+      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].args - xs.uniq == [] 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
+    #
+    #  * **returns**: `Array` containing `CAs:;Variable`
+    def args
+      @x
+    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)
+      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
+      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)
+      if self.depend? v
+        return CAS.declare :"d#{@name}[#{v}]", @x
+      else
+        return CAS::Zero
+      end
+    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 == op.args)
+      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

@@ -12,20 +12,20 @@ module CAS
   class Variable < CAS::Op
     # Contains all define variable, in an hash. Variables are
     # accessible through variable name.
-    @@vars = {}
+    @@container = {}
 
     # Returns the `Hash` that contains all the variable
     #
     #  * **returns**: `Hash`
     def self.list
-      @@vars
+      @@container
     end
 
     # Return the number of variable defined
     #
     #  * **returns**: `Fixnum`
     def self.size
-      @@vars.keys.size
+      @@container.keys.size
     end
 
     # Returns a variable given its name
@@ -33,7 +33,7 @@ module CAS
     #  * **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)
+      @@container[s] || CAS::vars(s)
     end
 
     # Returns `true` if a variable already exists
@@ -41,19 +41,23 @@ module CAS
     #  * **argument**: `Object` that represent the variable
     #  * **returns**: `TrueClass` if variable exists, `FalseClass` if not
     def self.exist?(name)
-      @@vars.keys.include? 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
-      @@vars[@name] = self
+      @@container[@name] = self
     end
 
     # Overrides new method. This will return an existing variable if in variable container
@@ -61,8 +65,9 @@ module CAS
     # * **requires**: `Object` that is an identifier for the variable
     # * **returns**: new variable instance o
     def Variable.new(name)
-      @@vars[name] || super
+      @@container[name] || super
     end
+
     # Returns the derivative of a variable
     #
     # ```
@@ -176,20 +181,6 @@ module CAS
     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.

data/lib/operators/nary-op.rb

@@ -33,9 +33,7 @@ module CAS
     #  * **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
+      @x.include? v
     end
 
     # Return a list of derivative using the chain rule. The input is a

data/lib/operators/op.rb

@@ -201,11 +201,7 @@ module CAS
     #
     #  * **returns**: `CAS::Op` self
     def simplify_dictionary
-      if self.class.simplify_dict(@x)
-        return self.class.simplify_dict(@x)
-      else
-        return self
-      end
+      self.class.simplify_dict(@x) || self
     end
 
     # Initializes the simplification dictionary (one for each class)
@@ -217,7 +213,10 @@ module CAS
 
     # Returns an element of a
     def self.simplify_dict(k)
-      @simplify_dict[k]
+      @simplify_dict.keys.each do |op|
+        return @simplify_dict[op] if op.simplify == k.simplify
+      end
+      return nil
     end
 
     # Inspector for the current object

data/lib/ragni-cas/plugins/graphviz.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+
+#   ___               _       _      ___ _           _
+#  / __|_ _ __ _ _ __| |___ _(_)___ | _ \ |_  _ __ _(_)_ _
+# | (_ | '_/ _` | '_ \ ' \ V / |_ / |  _/ | || / _` | | ' \
+#  \___|_| \__,_| .__/_||_\_/|_/__| |_| |_|\_,_\__, |_|_||_|
+#               |_|                            |___/
+
+module CAS
+  #   ___         _        _
+  #  / __|___ _ _| |_ __ _(_)_ _  ___ _ _ ___
+  # | (__/ _ \ ' \  _/ _` | | ' \/ -_) '_(_-<
+  #  \___\___/_||_\__\__,_|_|_||_\___|_| /__/
+
+  class Op
+    # Return the local Graphviz node of the tree
+    #
+    #  * **returns**: `String` of local Graphiz node
+    def dot_graph
+      cls = "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id}"
+      "#{cls} -> #{@x.dot_graph}\n"
+    end
+  end
+
+  class BinaryOp
+    # Return the local Graphviz node of the tree
+    #
+    #  * **returns**: `String` of local Graphiz node
+    def dot_graph
+      cls = "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id}"
+      "#{cls} -> #{@x.dot_graph}\n  #{cls} -> #{@y.dot_graph}"
+    end
+  end
+
+  class NaryOp
+    # Return the local Graphviz node of the tree
+    #
+    #  * **returns**: `String` of local Graphiz node
+    def dot_graph
+      cls = "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id}"
+      ret = ""
+      @x.each do |x|
+        ret += "#{cls} -> #{x.dot_graph}\n"
+      end
+      return ret
+    end
+  end
+
+  class Variable
+    # Return the local Graphviz node of the tree
+    #
+    #  * **returns**: `String` of local Graphiz node
+    def to_dot
+      "#{@name}"
+    end
+  end
+
+  class Constant
+    # Return the local Graphviz node of the tree
+    #
+    #  * **returns**: `String` of local Graphiz node
+    def to_dot
+      "Const(#{@x})"
+    end
+  end
+
+  class Piecewise
+    # Convert piecewise function into a dot graphviz representation
+    #
+    #  * **returns**: `String`
+    def dot_graph
+      cls = "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id}"
+      "#{cls} -> #{@x.dot_graph}\n  #{cls} -> #{@y.dot_graph}\n  #{cls} -> #{@condition.dot_graph}"
+    end
+  end
+
+  # 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`.
+  #
+  #  * **argument**: `CAS::Op` instance
+  #  * **returns**: `String`
+  def self.to_dot(op)
+    CAS::Help.assert(op, CAS::Op)
+    string = op.dot_graph
+    labels = ""
+
+    dot_subs_hash = {
+      "Sum"                => "+",
+      "Diff"               => "-",
+      "Prod"               => "×",
+      "Div"                => "÷",
+      "Sqrt"               => "√(∙)",
+      "Abs"                => "|∙|",
+      "Invert"             => "-(∙)",
+      "Exp"                => "exp(∙)",
+      "Log"                => "log(∙)",
+      "Pow"                => "(∙)^(∙)",
+      "ZERO_CONSTANT"      => "0",
+      "ONE_CONSTANT"       => "1",
+      "TWO_CONSTANT"       => "2",
+      "PI_CONSTANT"        => "π",
+      "INFINITY_CONSTANT"  => "∞",
+      "E_CONSTANT"         => "e",
+      "MINUS_ONE_CONSTANT" => "-1"
+    }
+
+    lab = {}
+    string.scan(/\w+\_\d+/) do |m|
+      if m =~ /(\w+)\_\d+/
+        lab[m] = dot_subs_hash[$1] || $1
+      end
+    end
+    lab.each { |k, v| labels += "  #{k} [label=\"#{v}\"]\n" }
+
+    return "digraph Op {\n  #{string}#{labels}}"
+  end
+
+  # Export the input `CAS::Op` graphviz representation to a file.
+  #
+  #  * **argument**: `String` with filename
+  #  * **argument**: `CAS::Op` with the tree
+  #  * **returns**: `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
+end

data/lib/ragni-cas/plugins/latex.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+#  _        _____ ____      ___ _           _
+# | |   __ |_   _|__ /_ __ | _ \ |_  _ __ _(_)_ _
+# | |__/ _` || |  |_ \ \ / |  _/ | || / _` | | ' \
+# |____\__,_||_| |___/_\_\ |_| |_|\_,_\__, |_|_||_|
+#                                     |___/
+
+module CAS
+  {
+    # Terminal nodes
+    CAS::Constant              => Proc.new { "#{x}" },
+    CAS::Variable              => Proc.new { "#{name}" },
+    CAS::PI_CONSTANT           => Proc.new { "\\pi" },
+    CAS::INFINITY_CONSTANT     => Proc.new { "\\infty" },
+    CAS::NEG_INFINITY_CONSTANT => Proc.new { "-\\infty" },
+    # Base functions
+    CAS::Sum    => Proc.new { "\\left( #{x.latex} + #{y.latex} \\right)" },
+    CAS::Diff   => Proc.new { "\\left( #{x.latex} - #{y.latex} \\right)" },
+    CAS::Prod   => Proc.new { "\\left( #{x.latex} \\, #{y.latex} \\right)"},
+    CAS::Pow    => Proc.new { "{#{x.latex}}^{#{y.latex}}" },
+    CAS::Div    => Proc.new { "\\dfrac{#{x.latex}}{#{y.latex}}" },
+    CAS::Sqrt   => Proc.new { "\\sqrt{#{x.latex}}" },
+    CAS::Invert => Proc.new { "-#{x.latex}" },
+    CAS::Abs    => Proc.new { "\\left| #{}{x.latex} \\right|" },
+
+    # Trigonometric functions
+    CAS::Sin    => Proc.new { "\\sin \\left( #{x.latex} \\right)" },
+    CAS::Asin   => Proc.new { "\\arcsin \\left( #{x.latex} \\right)" },
+    CAS::Cos    => Proc.new { "\\cos \\left( #{x.latex} \\right)" },
+    CAS::Acos   => Proc.new { "\\arccos \\left( #{x.latex} \\right)" },
+    CAS::Tan    => Proc.new { "\\tan \\left( #{x.latex} \\right)" },
+    CAS::Atan   => Proc.new { "\\arctan \\left( #{x.latex} \\right)" },
+
+    # Trascendent functions
+    CAS::Exp    => Proc.new { "e^#{x.latex}" },
+    CAS::Ln     => Proc.new { "\\log \\left( #{x.latex} \\right)" },
+
+    # Box Conditions
+    CAS::BoxConditionOpen        => Proc.new { "#{lower.latex} < #{x.latex} < #{upper.latex}" },
+    CAS::BoxConditionClosed      => Proc.new { "#{lower.latex} \\leq #{x.latex} \\leq #{upper.latex}" },
+    CAS::BoxConditionUpperClosed => Proc.new { "#{lower.latex} < #{x.latex} \\leq #{upper.latex}" },
+    CAS::BoxConditionLowerClosed => Proc.new { "#{lower.latex} \\leq #{x.latex} < #{upper.latex}" },
+
+    # Conditions
+    CAS::Equal        => Proc.new { "#{x.latex} = #{y.latex}" },
+    CAS::Smaller      => Proc.new { "#{x.latex} < #{y.latex}" },
+    CAS::Greater      => Proc.new { "#{x.latex} > #{y.latex}" },
+    CAS::SmallerEqual => Proc.new { "#{x.latex} \\leq #{y.latex}" },
+    CAS::GreaterEqual => Proc.new { "#{x.latex} \\geq #{y.latex}" },
+
+    # Piecewise
+    CAS::Piecewise => Proc.new {
+      "\\left\\{ " +
+      "  \\begin{array}{lr} " +
+      "    #{x.latex} & #{condition.latex} \\\\" +
+      "    #{y.latex}" +
+      "  \\end{array}" +
+      "\\right."
+    },
+    CAS::Max => Proc.new { "\\max \\left( #{x.latex}, \\, #{y.latex} \\right)" },
+    CAS::Min => Proc.new { "\\min \\left( #{x.latex}, \\, #{y.latex} \\right)" }
+
+
+  }.each do |cls, blk|
+    cls.send(:define_method, "to_latex", &blk)
+  end
+end

data/lib/ragni-cas.rb

@@ -27,7 +27,7 @@ module CAS
   # Support functions are in this separate Helper class
   module Help
     # Check input `obj.class` against a `type` class
-    # raises an ArgumentError if check fails
+    # raises an `ArgumentError` if check fails
     #
     #  * **argument**: object to be cecked
     #  * **argument**: type to be checked against
@@ -36,6 +36,17 @@ module CAS
       raise ArgumentError, "required #{type}, received #{obj.class}" unless obj.is_a? type
       return true
     end
+
+    # Check if input object is feasible to be a name of a `CAS::Variable` or a `CAS::Function`
+    # raise an `ArgumentError` if the check fails. To be feasible the object must be a `String`
+    # instance or `Symbol` instance
+    #
+    #  * **argument**: object to be checked
+    #  * **returns**: `TrueClass` or raises `ArgumentError`
+    def self.assert_name(obj)
+      raise ArgumentError, "Input name must be a String/Symbol" unless [Symbol, String].include? obj.class
+      return true
+    end
   end
 end
 
@@ -46,7 +57,7 @@ end
 #            |_|
 
 %w|operators/op.rb operators/bary-op.rb operators/nary-op.rb
-   numbers/constants.rb numbers/variables.rb
+   numbers/constants.rb numbers/variables.rb numbers/functions.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

data/lib/version.rb

@@ -8,6 +8,6 @@ module CAS
   #  * Major version
   #  * Minor version
   #  * Patchlevel
-  VERSION = [0, 2, 3]
+  VERSION = [0, 2, 5]
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ragni-cas
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Matteo Ragni
@@ -29,7 +29,7 @@ cert_chain:
   XorZtzkkLImvKFj35xKLFfVkv0Vd8tGQoiL8vdmQNJjAjtE+C+Y7OI4dpiZPKO4G
   R/8JOvUuk9jPbyLxjQH/sFaFqqYGX2xo1zk2CRy/A0WhJrSaXVw1r5lEi7b0W5gg
   -----END CERTIFICATE-----
-date: 2016-10-07 00:00:00.000000000 Z
+date: 2016-10-13 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: info@ragni.me
@@ -44,6 +44,7 @@ files:
 - lib/functions/fnc-trig.rb
 - lib/functions/fnc-trsc.rb
 - lib/numbers/constants.rb
+- lib/numbers/functions.rb
 - lib/numbers/variables.rb
 - lib/operators/bary-op.rb
 - lib/operators/nary-op.rb
@@ -51,6 +52,8 @@ files:
 - 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: