ragni-cas 0.2.2 → 0.2.3

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-trig.rb

@@ -0,0 +1,487 @@
+#!/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
+      }
+    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
+
+  # Shortcut for `CAS::Asin#new`
+  #
+  #  * **argument**: `CAS::Op` argument of the function
+  #  * **returns**: `CAS::Asin` operation
+  def self.asin(x)
+    CAS::Asin.new x
+  end
+  # alias :arcsin :asin
+
+  #   ___
+  #  / __|___ ___
+  # | (__/ _ (_-<
+  #  \___\___/__/
+
+  ##
+  # 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
+      }
+    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
+
+  # Shortcut for `CAS::Acos#new`
+  #
+  #  * **argument**: `CAS::Op` argument of the function
+  #  * **returns**: `CAS::Acos` operation
+  def self.acos(x)
+    CAS::Acos.new x
+  end
+  # alias :arccos :acos
+
+  #  _____
+  # |_   _|_ _ _ _
+  #   | |/ _` | ' \
+  #   |_|\__,_|_||_|
+
+  ##
+  # 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
+      }
+    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
+
+    # 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
+  end
+  # alias :arctan :atan
+end