Mr.CAS 0.2.6

data/lib/functions/fnc-piecewise.rb

@@ -0,0 +1,186 @@
+#!/usr/bin/env ruby
+
+module CAS
+  #  ___ _                   _
+  # | _ (_)___ __ _____ __ _(_)___ ___
+  # |  _/ / -_) _/ -_) V  V / (_-</ -_)
+  # |_| |_\___\__\___|\_/\_/|_/__/\___|
+
+  ##
+  # Piecewise function. The function returns when called a result
+  # that dependes upon the evaluation of a condition. In practice:
+  #
+  # ```
+  #   /
+  #  |  f(x)   if condition(x) is True
+  # <
+  #  |  g(x)   otherwise
+  #   \
+  # ```
+  #
+  # From this class other classes will inherit like `CAS::Max` and `CAS::Min` classes
+  class Piecewise < CAS::BinaryOp
+    attr_reader :condition
+
+    # Initialize a new piecewise function. It requires first the function
+    # that returns when condition is true, than the function when condition is
+    # false, and finally the condition that must be of class `CAS::Condition`
+    #
+    #  * **argument**: `CAS::Op` first function
+    #  * **argument**: `CAS::Op` second function
+    #  * **argument**: `CAS::Condition` evaluated condition
+    #  * **returns**: `CAS::Piecewise` new instance
+    def initialize(x, y, condition)
+      CAS::Help.assert(condition, CAS::Condition)
+
+      super(x, y)
+      @condition = condition
+    end
+
+    # Derivative of a function is performed as derivative of the two internal functions
+    # while condition is unchanged
+    #
+    # warning:: Piecewise functions are in general not differentiable. Thus differentiability
+    # is left to the user
+    #
+    # ```
+    #      /                                     /
+    #  d  |  f(x)   if condition(x) is True     | f'(x)   if condition(x) is True
+    # -- <                                   = <
+    # dx  |  g(x)   otherwise                   | g'(x)   otherwise
+    #      \                                     \
+    # ```
+    #
+    #  * **argument**: `CAS::Op` argument of derivative
+    #  * **returns**: `CAS::Piecewise` with derivated functions and unchanged condition
+    def diff(v)
+      CAS::Help.assert(v, CAS::Op)
+      return CAS::Piecewise.new(@x.diff(v).simplify, @y.diff(v).simplify, @condition)
+    end
+
+    # Executes the condition. If it is `true` it returns the first function,
+    # else it returns the value of the second function.
+    #
+    #  * **argument**: `Hash` with value tables
+    #  * **returns**: `Numeric` the result of the call
+    def call(fd)
+      CAS::Help.assert(fd, Hash)
+      (@condition.call(fd) ? @x.call(fd) : @y.call(fd))
+    end
+
+    # Checks if two `CAS::Piecewise` are equal. Checks equality on all functions+
+    # and conditions
+    #
+    #  * **argument**: `CAS::Op` to be checked against
+    #  * **returns**: `TrueClass` or `FalseClass`
+    def ==(op)
+      CAS::Help.assert(op, CAS::Op)
+      if self.class != op.class
+        return false
+      else
+        return ((@x == op.x) and (@y == op.y) and (@condition == op.condition))
+      end
+    end
+
+    # Convert the piecewise funtion to a String of Ruby code
+    #
+    #  * **returns**: `String` of code
+    def to_code
+      "(#{@condition.to_code} ? (#{@x.to_code}) : (#{@y.to_code}))"
+    end
+
+    # Convert the piecewise function into a String
+    #
+    #  * **returns**: `String`
+    def to_s
+      "(#{@condition} ? #{@x} : #{@y})"
+    end
+
+    # Convert piecewise function into LaTeX representation
+    #
+    #  * **returns**: `String` of LaTeX code
+    def to_latex
+      "\\left\\{ \\begin{array}{lr} #{@x.to_latex} & #{@condition.to_latex} \\\\ #{@y.to_latex} \\end{array} \\right."
+    end
+  end
+
+  #  __  __ _      __  __
+  # |  \/  (_)_ _ |  \/  |__ ___ __
+  # | |\/| | | ' \| |\/| / _` \ \ /
+  # |_|  |_|_|_||_|_|  |_\__,_/_\_\
+
+  ##
+  # Class MinMax is an intermediate class for Min and Max functions. It contains shared code
+  # and methods
+  class MinMax < CAS::Piecewise
+    # Convert MinMax function into LaTeX representation
+    #
+    #  * **returns**: `String` of LaTeX code
+    def to_latex
+      "\\mathrm{#{@type}}\\left( \\begin{array}{c} #{@x.to_latex} \\\\ #{@y.to_latex} \\end{array} \\right)"
+    end
+
+    # Returns a string representation for the current operation
+    #
+    #  * **returns**: `String`
+    def to_s
+      "#{@type}(#{@x}, #{@y})"
+    end
+  end # MinMax
+
+  #  __  __
+  # |  \/  |__ ___ __
+  # | |\/| / _` \ \ /
+  # |_|  |_\__,_/_\_\
+
+  # Max class represent a piecewise in which the condition is `f(x) ≥ g(x)`. Derivate a `CAS::Max`
+  # will return a `CAS::Piecewise` (since condition will not depend anymore on object functions)
+  class Max < CAS::Piecewise
+    # To initialize `CAS::Max` only the two functions are necessary. The condition is automatically
+    # generated
+    #
+    #  * **argument**: `CAS::Op` first function
+    #  * **argument**: `CAS::Op` second function
+    def initialize(x, y)
+      super(x, y, CAS::greater_equal(x, y))
+      @type = "max"
+    end
+  end # Max
+
+  #  __  __ _
+  # |  \/  (_)_ _
+  # | |\/| | | ' \
+  # |_|  |_|_|_||_|
+
+  # Min class represent a piecewise in which the condition is `f(x) ≤ g(x)`. Derivate a `CAS::Min`
+  # will return a `CAS::Piecewise` (since condition will not depend anymore on object functions)
+  class Min < CAS::Piecewise
+    # To initialize `CAS::Min` only the two functions are necessary. The condition is automatically
+    # generated
+    #
+    #  * **argument**: `CAS::Op` first function
+    #  * **argument**: `CAS::Op` second function
+    def initialize(x, y)
+      super(x, y, CAS::smaller_equal(x, y))
+      @type = "min"
+    end
+  end # Min
+
+  # Shortcut for `CAS::Max` initializer
+  #
+  #  * **argument**: `CAS::Op` left function
+  #  * **argument**: `CAS::Op` right function
+  #  * **returns**: `CAS::Max` new instance
+  def self.max(x, y)
+    CAS::Max.new(x, y)
+  end
+
+  # Shortcut for `CAS::Min` initializer
+  #
+  #  * **argument**: `CAS::Op` left function
+  #  * **argument**: `CAS::Op` right function
+  #  * **returns**: `CAS::Min` new instance
+  def self.min(x, y)
+    CAS::Min.new(x, y, CAS::smaller_equal(x, y))
+  end
+end

data/lib/functions/fnc-prod.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+
+module CAS
+
+  #  ___             _
+  # | _ \_ _ ___  __| |
+  # |  _/ '_/ _ \/ _` |
+  # |_| |_| \___/\__,_|
+
+  ##
+  # Product class. Performs the product between two elements.
+  # This class will be soon modified as an n-ary operator.
+  class Prod < CAS::NaryOp
+    # The new element of a sum accumulates inside the
+    # vector that holds the elements
+    def *(op)
+      CAS::Help.assert(op, CAS::Op)
+      @x << op
+      self
+    end
+
+    # Performs the product between two `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- (f(x) * g(x) * h(x)) = f'(x) * g(x) * h(x) +
+    #  dx
+    #                           + f(x) * g'(x) * h(x) +
+    #
+    #                           + f(x) * g(x) * h'(x)
+    # ```
+    #
+    #  * **argument**: `CAS::Op` argument of derivative
+    #  * **returns**: `CAS::Op` derivative
+    def diff(v)
+      xdiff = @x.map { |y| y.diff(v) }
+
+      xdiff.each_with_index { |y, i|
+        xdiff[i] = y * CAS::Prod.new(@x[0...i] + @x[(i + 1)..-1])
+      }
+
+      return CAS::Sum.new(xdiff)
+    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)
+
+      return @x.inject { |p, y| p = p.overloaded_mul(y.call(f)) }
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "(#{@x.map(&:to_s).join(" * ")})"
+    end
+
+    # Same as `CAS::Op`
+    #
+    # Simplifcation engine supports:
+    #
+    #  * x * 0 = x * y = 0
+    #  * 1 * y = y
+    #  * x * 1 = x
+    #  * x * x = x²
+    #  * a * b = c (constants reduction)
+    #
+    #  * **returns**: `CAS::Op` simplified version
+    def simplify
+      super
+      return CAS::Zero if @x.include? CAS::Zero
+      @x = @x - [CAS::One]
+      return CAS::One if @x.size == 0
+      return @x[0] if @x.size == 1
+
+      @x = self.__reduce_constants(@x) do |cs, xs|
+        [cs.inject { |t, c| t *= c.call({}) }] + xs
+      end
+
+      @x = self.__reduce_multeplicity(@x) do |op, count|
+        count > 1 ? (op ** count) : op
+      end
+      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.map(&:to_code).join(" * ")})"
+    end
+  end # Prod
+  CAS::Prod.init_simplify_dict
+end

data/lib/functions/fnc-sum.rb

@@ -0,0 +1,151 @@
+module CAS
+  #  ___
+  # / __|_  _ _ __
+  # \__ \ || | '  \
+  # |___/\_,_|_|_|_|
+
+  ##
+  # **Sum basic operation**. As for now it is implemented as a simple
+  # binary operation. It will be implemented as n-ary op.
+  class Sum < CAS::NaryOp
+    # Performs the sum between arbitrary number of `CAS::Op`
+    #
+    # ```
+    #   d
+    # ---- (f(x) + g(x) + h(x)) = f'(x) + g'(x) + h'(x)
+    #  dx
+    # ```
+    #
+    #  * **argument**: `CAS::Op` argument of derivative
+    #  * **returns**: `CAS::Op` derivative
+    def diff(v)
+      @x.map { |x| x.diff(v) }.inject { |sum_x, dx| sum_x += dx }
+    end
+
+    # The added element of a sum accumulates inside the
+    # vector that holds the elements
+    def +(op)
+      CAS::Help.assert(op, CAS::Op)
+      @x << op
+      self
+    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)
+      return @x.inject { |val, x_i| val += x_i.call(f) }
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "(#{@x.map(&:to_s).join(" + ")})"
+    end
+
+    # Same as `CAS::Op`
+    #
+    # Simplifcation engine supports:
+    #
+    #  * x + 0 = x
+    #  * 0 + y = y
+    #  * x + x = 2 x
+    #  * x + (-x) = 0
+    #  * x + (-y) = x - y
+    #  * 1 + 2 = 3 (constants reduction)
+    #
+    #  * **returns**: `CAS::Op` simplified version
+    def simplify
+      super
+      return @x[0] if @x.size == 1
+
+      # return CAS::Zero if @x == -@y or -@x == @y
+      # return (@x - @y.x) if @y.is_a? CAS::Invert
+      # return CAS.const(self.call({})) if (@x.is_a? CAS::Constant and @y.is_a? CAS::Constant)
+      # Removing Zeros
+      @x = @x - [CAS::Zero]
+      return CAS::Zero if @x.size == 0
+      # Reduce constants
+      @x = self.__reduce_constants(@x) do |cs, xs|
+        xs + [cs.inject { |t, c| t += c.call({}) }]
+      end
+      # Multeplicity and associativity executed
+      return self.reduce_associativity
+    end
+
+    # Reduces from an associative point of view, by a segregation
+    # of "negative" and positive elements. Negatives comes from
+    # Diff operations and Invert operations. All the others are considered
+    # positive. This function implements an internal heuristic. Should
+    # not be used outside
+    #
+    #  * **returns**: A `CAS::Diff` or a `CAS::Sum`
+    def reduce_associativity
+      pos, neg = [], []
+
+      @x.each do |x_el|
+        case x_el
+        when CAS::Invert
+          neg << x_el.x
+        when CAS::Diff
+          pos << x_el.x
+          neg << x_el.y
+        else
+          pos << x_el
+        end
+      end
+
+      pos, neg = self.reduce_associativity_array pos, neg
+      pos = self.__reduce_multeplicity(pos)
+      neg = self.__reduce_multeplicity neg
+
+      # TODO : Add rules for simplifications
+      left, right = nil, nil
+      left  = CAS::Sum.new(pos) if pos.size > 1
+      left  = pos[0]            if pos.size == 1
+      right = CAS::Sum.new(neg) if neg.size > 1
+      right = neg[0]            if neg.size == 1
+
+      return  CAS::Zero unless left || right
+      return  left unless right
+      return  -right unless left
+      return left - right
+    end
+
+    # Reduce the positive and the negative associative part of
+    # the sum to perform the symbolic difference. Does not take into account
+    # multeplicity
+    #
+    #  * **requires**: positive `Array`
+    #  * **requires**: negative `Array`
+    #  * **returns**: positive, reduced `Array` and negative `Array`
+    def reduce_associativity_array(p_old, n_old)
+      p_del, n_del = [], []
+      p_old.each do |p|
+        n_old.each do |n|
+          if p == n
+            p_del << p
+            n_del << n
+          end
+        end
+      end
+
+      return (p_old - p_del), (n_old - n_del)
+    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.map(&:to_code).join(" + ")})"
+    end
+  end # Sum
+  CAS::Sum.init_simplify_dict
+end

data/lib/functions/fnc-trig.rb

@@ -0,0 +1,489 @@
+#!/usr/bin/env ruby
+
+module CAS
+  #  ___ _
+  # / __(_)_ _
+  # \__ \ | ' \
+  # |___/_|_||_|
+
+  ##
+  # Representation for the `sin(x)` function. It is implemented
+  # as a `CAS::Op`
+  class Sin < CAS::Op
+    # Return the derivative of the `sin(x)` function using the chain
+    # rule. The input is a `CAS::Op` because it can handle derivatives
+    # with respect to functions.
+    #
+    # ```
+    #  d
+    # -- sin(f(x)) = f'(x) cos(fx)
+    # dx
+    # ```
+    #
+    #  * **argument**: `CAS::Op` object of the derivative
+    #  * **returns**: `CAS::Op` a derivated object, or `CAS::Zero` for constants
+    def diff(v)
+      if @x.depend? v
+        return @x.diff(v) * CAS.cos(@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
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+      Math::sin(@x.call(f))
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "sin(#{@x})"
+    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
+      super
+      return @x.x if @x.is_a? CAS::Asin
+      return self.simplify_dictionary
+    end
+
+    def self.init_simplify_dict
+      @simplify_dict = {
+        CAS::Zero => CAS::Zero,
+        CAS::Pi => CAS::Zero,
+        CAS::Pi/2 => CAS::One
+      }
+    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::sin(#{@x.to_code})"
+    end
+  end # Sin
+  CAS::Sin.init_simplify_dict
+
+  # Shortcut for `CAS::Sin#new`
+  #
+  #  * **argument**: `CAS::Op` argument of the function
+  #  * **returns**: `CAS::Sin` operation
+  def self.sin(x)
+    CAS::Sin.new x
+  end
+
+  #    _       _
+  #   /_\   __(_)_ _
+  #  / _ \ (_-< | ' \
+  # /_/ \_\/__/_|_||_|
+
+  ##
+  # Representation for the `arcsin(x)` function. It is implemented
+  # as a `CAS::Op`. It is the inverse of the `sin(x)` function
+  class Asin < CAS::Op
+    # Return the derivative of the `arcsin(x)` function using the chain
+    # rule. The input is a `CAS::Op`
+    #
+    #  * **argument**: `CAS::Op` object of the derivative
+    #  * **returns**: `CAS::Op` a derivated object, or `CAS::Zero` for constants
+    def diff(v)
+      if @x.depend? v
+        return @x.diff(v) / CAS.sqrt(CAS::One - CAS.pow(@x, CAS::Two))
+      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
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+      Math::acos(@x.call(f))
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "asin(#{@x})"
+    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
+      super
+      return @x.x if @x.is_a? CAS::Sin
+      return self.simplify_dictionary
+    end
+
+    def self.init_simplify_dict
+      @simplify_dict = {
+        CAS::Zero => CAS::Zero,
+        CAS::One => (CAS::Pi / 2)
+      }
+    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::asin(#{@x.to_code})"
+    end
+  end
+  CAS::Asin.init_simplify_dict
+
+  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
+
+  #   ___
+  #  / __|___ ___
+  # | (__/ _ (_-<
+  #  \___\___/__/
+
+  ##
+  # Representation for the `cos(x)` function. It is implemented
+  # as a `CAS::Op`.
+  class Cos < CAS::Op
+    # Return the derivative of the `cos(x)` function using the chain
+    # rule. The input is a `CAS::Op` because it can handle derivatives
+    # with respect to functions.
+    #
+    # ```
+    #  d
+    # -- cos(f(x)) = -f'(x) sin(fx)
+    # dx
+    # ```
+    #
+    #  * **argument**: `CAS::Op` object of the derivative
+    #  * **returns**: `CAS::Op` a derivated object, or `CAS::Zero` for constants
+    def diff(v)
+      if @x.depend? v
+        return CAS.invert(@x.diff(v) * CAS.sin(@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
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+      Math::cos(@x.call(f))
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "cos(#{@x})"
+    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
+      super
+      return @x.x if @x.is_a? CAS::Acos
+      return self.simplify_dictionary
+    end
+
+    def self.init_simplify_dict
+      @simplify_dict = {
+        CAS::Zero => CAS::One,
+        CAS::Pi => CAS::One,
+        CAS::Pi/2 => 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
+      "Math::cos(#{@x.to_code})"
+    end
+  end
+  CAS::Cos.init_simplify_dict
+
+  # Shortcut for `CAS::Cos#new`
+  #
+  #  * **argument**: `CAS::Op` argument of the function
+  #  * **returns**: `CAS::Cos` operation
+  def self.cos(x)
+    CAS::Cos.new x
+  end
+
+  #    _
+  #   /_\  __ ___ ___
+  #  / _ \/ _/ _ (_-<
+  # /_/ \_\__\___/__/
+
+  ##
+  # Representation for the `arccos(x)` function. It is implemented
+  # as a `CAS::Op`. It is the inverse of the `cos(x)` function
+  class Acos < CAS::Op
+    def diff(v)
+      if @x.depend? v
+        return CAS.invert(@x.diff(v)/CAS.sqrt(CAS::One - CAS.pow(@x, CAS::Two)))
+      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
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+      return Math::acos(@x.call(f))
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "acos(#{@x})"
+    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
+      super
+      return @x.x if @x.is_a? CAS::Cos
+      return self.simplify_dictionary
+    end
+
+    def self.init_simplify_dict
+      @simplify_dict = {
+        CAS::Zero => (CAS::Pi / 2),
+        CAS::One => 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
+      "Math::acos(#{@x.to_code})"
+    end
+  end
+  CAS::Acos.init_simplify_dict
+
+  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
+
+  #  _____
+  # |_   _|_ _ _ _
+  #   | |/ _` | ' \
+  #   |_|\__,_|_||_|
+
+  ##
+  # Representation for the `tan(x)` function. It is implemented
+  # as a `CAS::Op`.
+  class Tan < CAS::Op
+    # Return the derivative of the `tan(x)` function using the chain
+    # rule. The input is a `CAS::Op` because it can handle derivatives
+    # with respect to functions. E.g.:
+    #
+    # ```
+    #  d              f'(x)
+    # -- sin(f(x)) = -------
+    # dx             cos²(x)
+    # ```
+    #
+    #  * **argument**: `CAS::Op` object of the derivative
+    #  * **returns**: `CAS::Op` a derivated object, or `CAS::Zero` for constants
+    def diff(v)
+      if @x.depend? v
+        return @x.diff(v) * CAS.pow(CAS::One/CAS.cos(@x), CAS::Two)
+      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
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+      Math::tan(@x.call(f))
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "tan(#{@x})"
+    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
+      super
+      return @x.x if @x.is_a? CAS::Atan
+      return self.simplify_dictionary
+    end
+
+    def self.init_simplify_dict
+      @simplify_dict = {
+        CAS::Zero => CAS::Zero,
+        CAS::Pi => CAS::Zero,
+        CAS::Pi/2 => CAS::Infinity
+      }
+    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::tan(#{@x.to_code})"
+    end
+  end
+  CAS::Tan.init_simplify_dict
+
+  # Shortcut for `CAS::Tan#new`
+  #
+  #  * **argument**: `CAS::Op` argument of the function
+  #  * **returns**: `CAS::Tan` operation
+  def self.tan(x)
+    CAS::Tan.new x
+  end
+
+  #    _  _
+  #   /_\| |_ __ _ _ _
+  #  / _ \  _/ _` | ' \
+  # /_/ \_\__\__,_|_||_|
+
+  ##
+  # Representation for the `arctan(x)` function. It is implemented
+  # as a `CAS::Op`. It is the inverse of the `tan(x)` function
+  class Atan < CAS::Op
+    # Return the derivative of the `arctan(x)` function using the chain
+    # rule. The input is a `CAS::Op` because it can handle derivatives
+    # with respect to functions.
+    #
+    #  * **argument**: `CAS::Op` object of the derivative
+    #  * **returns**: `CAS::Op` a derivated object, or `CAS::Zero` for constants
+    def diff(v)
+      if @x.depend? v
+        return (@x.diff(v) / (CAS.pow(@x, CAS::Two) + CAS::One))
+      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
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Numeric`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+      Math::atan(@x.call(f))
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "atan(#{@x})"
+    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
+      super
+      return @x.x if @x.is_a? CAS::Tan
+      return self.simplify_dictionary
+    end
+
+    def self.init_simplify_dict
+      @simplify_dict = {
+        CAS::Zero => CAS::Zero,
+        CAS::One => (CAS::Pi/4),
+        CAS::Infinity => (CAS::Pi/2)
+      }
+    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::atan(#{@x.to_code})"
+    end
+  end
+  CAS::Atan.init_simplify_dict
+
+  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
+end