Mr.CAS 0.2.6

data/lib/Mr.CAS/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/Mr.CAS/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/Mr.CAS/matlab.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+#  __  __      _   _      _      ___ _           _
+# |  \/  |__ _| |_| |__ _| |__  | _ \ |_  _ __ _(_)_ _
+# | |\/| / _` |  _| / _` | '_ \ |  _/ | || / _` | | ' \
+# |_|  |_\__,_|\__|_\__,_|_.__/ |_| |_|\_,_\__, |_|_||_|
+#                                          |___/
+
+module CAS
+  {
+    # Terminal nodes
+    CAS::Constant              => Proc.new { |_v| "#{x}", nil },
+    CAS::Variable              => Proc.new { |_v| "#{name}", nil },
+    CAS::PI_CONSTANT           => Proc.new { |_v| "pi", nil },
+    CAS::INFINITY_CONSTANT     => Proc.new { |_v| "Inf", nil },
+    CAS::NEG_INFINITY_CONSTANT => Proc.new { |_v| "(-Inf)", nil },
+    CAS::E_CONSTANT            => Proc.new { |_v|
+    },
+    # Base functions
+    CAS::Sum    => Proc.new { "(#{x.to_c} + #{y.to_c})" },
+    CAS::Diff   => Proc.new { "(#{x.to_c} - #{y.to_c})" },
+    CAS::Prod   => Proc.new { "(#{x.to_c} * #{y.to_c})" },
+    CAS::Pow    => Proc.new { "pow(#{x.to_c}, #{y.to_c})" },
+    CAS::Div    => Proc.new { "(#{x.to_c}) / (#{y.to_c} + )" },
+    CAS::Sqrt   => Proc.new { "sqrt(#{x.to_c})" },
+    CAS::Invert => Proc.new { "(-#{x.to_c})" },
+    CAS::Abs    => Proc.new { "fabs(#{x.to_c})" },
+
+    # Trigonometric functions
+    CAS::Sin    => Proc.new { "sin(#{x.to_c})" },
+    CAS::Asin   => Proc.new { "asin(#{x.to_c})" },
+    CAS::Cos    => Proc.new { "cos(#{x.to_c})" },
+    CAS::Acos   => Proc.new { "acos(#{x.to_c})" },
+    CAS::Tan    => Proc.new { "tan(#{x.to_c})" },
+    CAS::Atan   => Proc.new { "atan(#{x.to_c})" },
+
+    # Trascendent functions
+    CAS::Exp    => Proc.new { "exp(#{x.to_c})" },
+    CAS::Ln     => Proc.new { "log(#{x.to_c})" },
+
+    # Box Conditions
+    # CAS::BoxConditionOpen => Proc.new {
+    #   ["double __t_#{x.object_id} = #{x.to_c};",
+    #    "(__t_#{x.object_id} > #{lower.latex} && __t_#{x.object_id} < #{upper.latex})"]
+    # },
+    # CAS::BoxConditionUpperClosed => Proc.new {
+    #   ["double __t_#{x.object_id} = #{x.to_c};",
+    #    "(__t_#{x.object_id} > #{lower.latex} && __t_#{x.object_id} <= #{upper.latex})"]
+    # },
+    # CAS::BoxConditionLowerClosed => Proc.new {
+    #   ["double __t_#{x.object_id} = #{x.to_c};",
+    #    "(__t_#{x.object_id} >= #{lower.latex} && __t_#{x.object_id} < #{upper.latex})"]
+    # },
+    # CAS::BoxConditionClosed => Proc.new {
+    #   ["double __t_#{x.object_id} = #{x.to_c};",
+    #    "(__t_#{x.object_id} >= #{lower.latex} && __t_#{x.object_id} <= #{upper.latex})"]
+    # },
+
+    # Conditions
+    CAS::Equal        => Proc.new { "(#{x.to_c} == #{y.to_c})" },
+    CAS::Smaller      => Proc.new { "(#{x.to_c} < #{y.to_c})" },
+    CAS::Greater      => Proc.new { "(#{x.to_c} > #{y.to_c})" },
+    CAS::SmallerEqual => Proc.new { "(#{x.to_c} <= #{y.to_c})" },
+    CAS::GreaterEqual => Proc.new { "(#{x.to_c} >= #{y.to_c})" },
+
+    # Piecewise
+    CAS::Piecewise => Proc.new { raise CASError, "Not implemented yet" },
+    CAS::Max       => Proc.new { raise CASError, "Not implemented yet" },
+    CAS::Min       => Proc.new { raise CASError, "Not implemented yet" }
+  }.each do |cls, blk|
+    cls.send(:define_method, "__to_matlab", &blk)
+  end
+
+  class Op
+    def to_c_lib(name)
+      CAS::Help.assert(name, String)
+      [CAS::C_PLUGIN.write_header(self, name), CAS::C_PLUGIN.write_source(self, name)]
+    end
+  end
+
+end

data/lib/functions/fnc-base.rb

@@ -0,0 +1,515 @@
+#!/usr/vin/env ruby
+
+module CAS
+  #  ___  _  __  __
+  # |   \(_)/ _|/ _|
+  # | |) | |  _|  _/
+  # |___/|_|_| |_|
+
+  ##
+  # **Difference basic operation**. It's a binary operation. This cannot
+  # be implemented as a n-ary op, thus will not be changed
+  class Diff < CAS::BinaryOp
+    # Performs the difference between two `CAS::Op`s
+    #
+    # ```
+    #   d
+    # ---- (f(x) - g(x)) = f'(x) - g'(x)
+    #  dx
+    # ```
+    #
+    #  * **argument**: `CAS::Op` argument of derivative
+    #  * **returns**: `CAS::Op` derivative
+    def diff(v)
+      left, right = super v
+      return left if right == CAS::Zero
+      return CAS::Invert.new(right) if left == CAS::Zero
+      left - right
+    end
+
+    # Same as `CAS::Op`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+
+      return @x.call(f).overloaded_minus(@y.call(f))
+    end
+
+    # Same as `CAS::Op`
+    def to_s
+      "(#{@x} - #{@y})"
+    end
+
+    # Same as `CAS::Op`
+    #
+    # Simplifcation engine supports:
+    #
+    #  * 0 - y = -y
+    #  * x - 0 = x
+    #  * a - b = c (constants reduction)
+    #  * x - x = 0
+    #  * x - (-y) = x + y
+    #
+    #  * **returns**: `CAS::Op` simplified version
+    def simplify
+      super
+      return CAS.invert(@y) if @x == CAS::Zero
+      return @x if @y == CAS::Zero
+      return CAS::Zero if @x == @y
+      return CAS.const(self.call({})) if (@x.is_a? CAS::Constant and @y.is_a? CAS::Constant)
+      return @x + @y.x if @y.is_a? CAS::Invert
+      return -(@x.x + @y) if @x.is_a? CAS::Invert
+      return self
+    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.to_code} - #{@y.to_code})"
+    end
+  end # Difference
+  CAS::Diff.init_simplify_dict
+
+  #  ___
+  # | _ \_____ __ __
+  # |  _/ _ \ V  V /
+  # |_| \___/\_/\_/
+
+  ##
+  # Power function.
+  class Pow < CAS::BinaryOp
+    # Performs the power between two `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- (f(x)^a) = f(x)^(a - 1) * a * f'(x)
+    #  dx
+    #
+    #   d
+    # ---- (a^f(x)) = a^f(x) * f'(x) * ln a
+    #  dx
+    #
+    #   d
+    # ---- (f(x)^g(x)) = (f(x)^g(x)) * (g'(x) * ln f(x) + g(x) * f'(x) / f(x))
+    #  dx
+    # ```
+    #
+    #  * **argument**: `CAS::Op` argument of derivative
+    #  * **returns**: `CAS::Op` derivative
+    def diff(v)
+      diff_x, diff_y = super v
+      if diff_y == CAS::Zero
+        return ((@x ** (@y - 1.0)) * @y * diff_x)
+      elsif diff_x == CAS::Zero
+        return (@x ** @y) * diff_y * CAS.ln(@x)
+      else
+        return (@x ** @y) * ((diff_y * CAS.ln(@x)) + (@y * diff_x / @x))
+      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. In this case it will call
+    # the `Fixnum#overloaded_plus`, that is the old plus function.
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+      @x.call(f).overloaded_pow(@y.call(f))
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "(#{@x})^(#{@y})"
+    end
+
+    # Same as `CAS::Op`
+    #
+    # Simplifcation engine supports:
+    #
+    #  * 0 ^ y = 0
+    #  * x ^ 0 = 1
+    #  * a ^ b = c (constants reduction)
+    #  * x ^ 1 = x
+    #  * 1 ^ y = 1
+    #
+    #  * **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
+      return CAS::One if @y == CAS::Zero
+      return CAS.const(self.call({})) if (@x.is_a? CAS::Constant and @y.is_a? CAS::Constant)
+      return self
+    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.to_code} ** #{@y.to_code})"
+    end
+  end # Pow
+  CAS::Pow.init_simplify_dict
+
+  # Shortcut for `CAS::Pow` initializer
+  #
+  #  * **argument**: `CAS::Op` base
+  #  * **argument**: `CAS::Op` exponent
+  #  * **returns**: `CAS::Pow` new instance
+  def self.pow(x, y)
+    CAS::Pow.new x, y
+  end
+
+  #  ___  _
+  # |   \(_)_ __
+  # | |) | \ V /
+  # |___/|_|\_/
+
+  ##
+  # Division between two functions. A function divided by zero it is considered
+  # as an Infinity.
+  class Div < CAS::BinaryOp
+    # Performs the division between two `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- (f(x) / g(x)) = (f'(x) * g(x) - f(x) * g'(x))/(g(x)^2)
+    #  dx
+    # ```
+    #
+    #  * **argument**: `CAS::Op` argument of derivative
+    #  * **returns**: `CAS::Op` derivative
+    def diff(v)
+      diff_x, diff_y = super v
+      if diff_y == CAS::Zero
+        return (diff_x/@y)
+      elsif diff_x == CAS::Zero
+        return CAS.invert(@x * diff_y / CAS.pow(@y, CAS.const(2.0)))
+      else
+        return ((diff_x * @y) - (diff_y * @x))/CAS.pow(@y, CAS.const(2.0))
+      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. In this case it will call
+    # the `Fixnum#overloaded_plus`, that is the old plus function.
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+
+      @x.call(f).overloaded_div(@y.call(f))
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "(#{@x}) / (#{@y})"
+    end
+
+    # Same as `CAS::Op`
+    #
+    # Simplifcation engine supports:
+    #
+    #  * 0 / y = 0
+    #  * x / 0 = Inf
+    #  * x / 1 = x
+    #  * x / Inf = 0
+    #  * a / b = c (constants reduction)
+    #
+    #  * **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
+
+    # 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.to_code} / #{@y.to_code})"
+    end
+  end # Div
+  CAS::Div.init_simplify_dict
+
+  #  ___           _
+  # / __| __ _ _ _| |_
+  # \__ \/ _` | '_|  _|
+  # |___/\__, |_|  \__|
+  #         |_|
+
+  ##
+  # Square Root of a function. Even if it can be implemented as a power function,
+  # it is a separated class.
+  class Sqrt < CAS::Op
+    # Performs the square root between two `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- √f(x) = 1/2 * f'(x) * √f(x)
+    #  dx
+    # ```
+    #
+    #  * **argument**: `CAS::Op` argument of derivative
+    #  * **returns**: `CAS::Op` derivative
+    def diff(v)
+      if @x.depend? v
+        return (@x.diff(v) / (CAS.const(2.0) * CAS.sqrt(@x)))
+      else
+        return CAS::Zero
+      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. In this case it will call
+    # the `Fixnum#overloaded_plus`, that is the old plus function.
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+
+      Math::sqrt @x.call(f)
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "√(#{@x})"
+    end
+
+    # Same as `CAS::Op`
+    #
+    # Simplifcation engine supports:
+    #
+    #  * √(x^z) = x^(z - 1/2)
+    #  * √x = 0
+    #  * √x = 1
+    #  * √a = b (constants reduction)
+    #
+    #  * **returns**: `CAS::Op` simplified version
+    def simplify
+      super
+      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)
+      return self
+    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
+      "Math::sqrt(#{@x.to_code})"
+    end
+  end # Sqrt
+  CAS::Sqrt.init_simplify_dict
+
+  # Shortcut for `CAS::Sqrt` initializer
+  #
+  #  * **argument**: `CAS::Op` argument of square root
+  #  * **returns**: `CAS::Sqrt` new instance
+  def self.sqrt(x)
+    CAS::Sqrt.new x
+  end
+
+  #  ___                 _
+  # |_ _|_ ___ _____ _ _| |_
+  #  | || ' \ V / -_) '_|  _|
+  # |___|_||_\_/\___|_|  \__|
+
+  ##
+  # Invert is the same as multiply by `-1` a function.
+  # `Invert(x)` is equal to `-x`
+  class Invert < CAS::Op
+    # Performs the inversion of a `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- (-f(x)) = -f'(x)
+    #  dx
+    # ```
+    #
+    #  * **argument**: `CAS::Op` argument of derivative
+    #  * **returns**: `CAS::Op` derivative
+    def diff(v)
+      if @x.depend? v
+        -@x.diff(v)
+      else
+        CAS::Zero
+      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. In this case it will call
+    # the `Fixnum#overloaded_plus`, that is the old plus function.
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+
+      -1.0 * @x.call(f)
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "-#{@x}"
+    end
+
+    # Same as `CAS::Op`
+    #
+    # Simplifcation engine supports:
+    #
+    #  * -(-x) = x
+    #  * -0 = 0
+    #
+    #  * **returns**: `CAS::Op` simplified version
+    def simplify
+      super
+      return @x.x if @x.is_a? CAS::Invert
+      return self.simplify_dictionary
+    end
+
+    def self.init_simplify_dict
+      @simplify_dict = {
+        CAS::Zero => CAS::Zero
+      }
+    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.to_code})"
+    end
+  end # Invert
+  CAS::Invert.init_simplify_dict
+
+  # Shortcut for `CAs::Invert` initializer
+  #
+  #  * **argument**: `CAs::Op` argument of the inversion
+  #  * **returns**: `CAS::Invert` new instance
+  def self.invert(x)
+    CAS::Invert.new x
+  end
+
+  #    _   _
+  #   /_\ | |__ ___
+  #  / _ \| '_ (_-<
+  # /_/ \_\_.__/__/
+
+  ##
+  # Absolute value of a function. It can be also implemented as a Piecewise function.
+  class Abs < CAS::Op
+    # Performs the absolute value of a `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- |f(x)| = f'(x) * (f(x) / |f(x)|)
+    #  dx
+    # ```
+    #
+    #  * **argument**: `CAS::Op` argument of derivative
+    #  * **returns**: `CAS::Op` derivative
+    def diff(v)
+      if @x.depend? v
+        return @x.diff(v) * (@x/CAS.abs(@x))
+      else
+        return CAS::Zero
+      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. In this case it will call
+    # the `Fixnum#overloaded_plus`, that is the old plus function.
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+
+      s = (@x.call(f) >= 0 ? 1 : -1)
+      return s * @x.call(f)
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "|#{@x}|"
+    end
+
+    # Same as `CAS::Op`
+    #
+    # Simplifcation engine supports:
+    #
+    #  * |-x| = x
+    #  * |0| = 0
+    #
+    #  * **returns**: `CAS::Op` simplified version
+    def simplify
+      super
+      return CAS.abs(@x.x) if @x.is_a? CAS::Invert
+      return self.simplify_dictionary
+    end
+
+    def self.init_simplify_dict
+      @simplify_dict = {
+        CAS::Zero => CAS::Zero
+      }
+    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.to_code}).abs"
+    end
+  end # Abs
+  CAS::Abs.init_simplify_dict
+
+  # Shortcut for `CAs::Abs` initializer
+  #
+  #  * **argument**: `CAs::Op` argument of absolute value
+  #  * **returns**: `CAS::Abs` new instance
+  def self.abs(x)
+    CAS::Abs.new x
+  end
+end