ragni-cas 0.2.2 → 0.2.3

data/lib/functions/fnc-trsc.rb

@@ -0,0 +1,196 @@
+#!/usr/bin/env ruby
+
+module CAS
+  #  ___                            _
+  # | __|_ ___ __  ___ _ _  ___ _ _| |_
+  # | _|\ \ / '_ \/ _ \ ' \/ -_) ' \  _|
+  # |___/_\_\ .__/\___/_||_\___|_||_\__|
+  #         |_|
+
+  ##
+  # Representation for the `e^x` function. It is implemented
+  # as a `CAS::Op`
+  class Exp < 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
+    # -- exp(f(x)) = f'(x) exp(f(x))
+    # 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.exp(@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::exp(@x.call(f))
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "exp(#{@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::Ln
+      return self.simplify_dictionary
+    end
+
+    def self.init_simplify_dict
+      @simplify_dict = {
+        CAS::Zero => CAS::One,
+        CAS::One => CAS::E,
+        CAS::Infinity => 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::exp(#{@x.to_code})"
+    end
+
+    # Returns the latex representation of the current Op.
+    #
+    #  * **returns**: `String`
+    def to_latex
+      "e^{#{@x.to_latex}}"
+    end
+  end # Exp
+
+  # Shortcut for `CAS::Exp#new`
+  #
+  #  * **argument**: `CAS::Op` argument of the function
+  #  * **returns**: `CAS::Exp` operation
+  def self.exp(x)
+    CAS::Exp.new x
+  end
+
+  #  _                       _ _   _
+  # | |   ___  __ _ __ _ _ _(_) |_| |_  _ __
+  # | |__/ _ \/ _` / _` | '_| |  _| ' \| '  \
+  # |____\___/\__, \__,_|_| |_|\__|_||_|_|_|_|
+  #           |___/
+
+  ##
+  # Representation for the `log(x)` function. It is implemented
+  # as a `CAS::Op`
+  class Ln < CAS::Op
+    # Return the derivative of the `log(x)` function using the chain
+    # rule. The input is a `CAS::Op` because it can handle derivatives
+    # with respect to functions.
+    #
+    # ```
+    #  d              f'(x)
+    # -- log(f(x)) = -------
+    # dx               f(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 CAS::One / @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)
+      # I'm leaving to Math the honor
+      # of handling negative values...
+      CAS::Help.assert(f, Hash)
+      Math::log(@x.call(f))
+    end
+
+    # Convert expression to string
+    #
+    #  * **returns**: `String` to print on screen
+    def to_s
+      "log(#{@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::Exp
+      return self.simplify_dictionary
+    end
+
+    def self.init_simplify_dict
+      @simplify_dict = {
+        CAS::Zero => CAS.invert(CAS::Infinity),
+        CAS::One => CAS::Zero,
+        CAS::E => 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::log(#{@x.to_code})"
+    end
+
+    # Returns the latex representation of the current Op.
+    #
+    #  * **returns**: `String`
+    def to_latex
+      "\\log\\left( #{@x.to_latex} \\right)"
+    end
+  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
+  end
+end

data/lib/numbers/constants.rb

@@ -0,0 +1,358 @@
+#!/usr/bin/env ruby
+
+module CAS
+  #   ___             _            _
+  #  / __|___ _ _  __| |_ __ _ _ _| |_
+  # | (__/ _ \ ' \(_-<  _/ _` | ' \  _|
+  #  \___\___/_||_/__/\__\__,_|_||_\__|
+
+  ##
+  # Constant is a `CAS::Op` container for a `Numeric` value, that is
+  # not a `CAS::Variable`, thus its derivative it is always zero
+  class Constant < CAS::Op
+    def initialize(x)
+      @x = x
+    end
+
+    # Evaluates the derivative of a constant. The derivative is
+    # always a `CAS::Zero`
+    #
+    # ```
+    #  d
+    # -- c = 0
+    # dx
+    # ```
+    def diff(_v)
+      CAS::Zero
+    end
+
+    # Calling a constant will return the value of the constant
+    # itself.
+    #
+    #  * **argument**: Unused argument
+    #  * **returns**: `Numeric` value of the constant
+    def call(_f)
+      @x
+    end
+
+    # There is no dependency in a constant, thus this method will
+    # always return false
+    #
+    #  * **argument**: Unused argument
+    #  * **returns**: `FalseClass`
+    def depend?(_v)
+      false
+    end
+
+    # The string representation of a constant is the value
+    # of the constant
+    #
+    #  * **returns**: `String`
+    def to_s
+      "#{@x}"
+    end
+
+    # Subs for a constant is a dummy method that returns always `self`
+    #
+    #  * **argument**: Unused argument
+    #  * **returns**: `CAS::Constant` that represent `self`
+    def subs(_dt)
+      return self
+    end
+
+    # Simplification callback. It simplify the subgraph of each node
+    # until all possible simplification are performed (thus the execution
+    # time is not deterministic).
+    #
+    #  * **returns**: `CAS::Op` simplified version
+    def simplify
+      return self
+    end
+    @@simplify_dict = { }
+
+    # Args of a constant is an empty `Array`
+    #
+    #  * **returns**: `Array` empty
+    def args
+      []
+    end
+
+    # Check if a constant is equal to another `CAS::Op` object
+    #
+    #  * **argument**: `CAs::Op`
+    #  * **returns**: `TrueClass` or `FalseClass`
+    def ==(op)
+      if op.is_a? CAS::Constant
+        return @x == op.x
+      else
+        return false
+      end
+    end
+
+    # Inspection for `CAS::Constant` class
+    #
+    #  * **returns**: `String`
+    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.
+  #
+  # ``` ruby
+  # a, b = CAS::const 1.0, 100
+  # ```
+  #
+  #  * **argument**: `Array` of Numeric
+  #  * **returns**: `Array` of `CAS::Contant`
+  def self.const(*val)
+    #(val = [val]) if val.size == 1
+    ret = []
+    val.each do |n|
+      ret << (NumericToConst[n] ? NumericToConst[n] : CAS::Constant.new(n))
+    end
+    return (ret.size == 1 ? ret[0] : ret)
+  end
+
+  #  _______ ___  ___
+  # |_  / __| _ \/ _ \
+  #  / /| _||   / (_) |
+  # /___|___|_|_\\___/
+
+  ##
+  # Class that represents the constant Zero (0)
+  class ZERO_CONSTANT < CAS::Constant
+    # Initializer for the zero constant
+    #
+    #  * **returns**: `CAS::ZERO_CONSTANT` new instance
+    def initialize
+      @x = 0.0
+    end
+
+    # String representation for the constant
+    #
+    #  * **returns**: `String`
+    def to_s
+      "0"
+    end
+  end # Zero
+
+  # Zero (0) constant representation
+  Zero = CAS::ZERO_CONSTANT.new
+
+  #   ___
+  #  / _ \ _ _  ___
+  # | (_) | ' \/ -_)
+  #  \___/|_||_\___|
+
+  ##
+  # Class that represents the constant One (1)
+  class ONE_CONSTANT < CAS::Constant
+    # Initializer for the one constant
+    #
+    #  * **returns**: `CAS::ONE_CONSTANT` new instance
+    def initialize
+      @x = 1.0
+    end
+
+    # String representation for the constant
+    #
+    #  * **returns**: `String`
+    def to_s
+      "1"
+    end
+  end # Zero
+
+  # One (1) constant representation
+  One = CAS::ONE_CONSTANT.new
+
+  #  _____
+  # |_   _|_ __ _____
+  #   | | \ V  V / _ \
+  #   |_|  \_/\_/\___/
+
+  ##
+  # Class that represents the constant Two (2)
+  class TWO_CONSTANT < CAS::Constant
+    # Initializer for the two constant
+    #
+    #  * **returns**: `CAS::TWO_CONSTANT` new instance
+    def initialize
+      @x = 2.0
+    end
+
+    # String representation for the constant
+    #
+    #  * **returns**: `String`
+    def to_s
+      "2"
+    end
+  end # Zero
+
+  # Two (2) constant representation
+  Two = CAS::TWO_CONSTANT.new
+
+  #  ___ ___
+  # | _ \_ _|
+  # |  _/| |
+  # |_| |___|
+
+  ##
+  # Class that represents the constant Pi (π)
+  class PI_CONSTANT < CAS::Constant
+    # Initializer for the pi constant
+    #
+    #  * **returns**: `CAS::PI_CONSTANT` new instance
+    def initialize
+      @x = Math::PI
+    end
+
+    # String representation for the constant
+    #
+    #  * **returns**: `String`
+    def to_s
+      "π"
+    end
+  end
+
+  # Pi (3.14...) constant representation
+  Pi = CAS::PI_CONSTANT.new
+
+  #  ___
+  # | __|
+  # | _|
+  # |___|
+
+  ##
+  # Class that represents the constant E (e)
+  class E_CONSTANT < CAS::Constant
+    # Initializer for the E constant
+    #
+    #  * **returns**: `CAS::E_CONSTANT` new instance
+    def initialize
+      @x = Math::E
+    end
+
+    # String representation for the constant
+    #
+    #  * **returns**: `String`
+    def to_s
+      "e"
+    end
+  end
+
+  # E (2.57...) constant representation
+  E = CAS::E_CONSTANT.new
+
+  #  ___       __ _      _ _
+  # |_ _|_ _  / _(_)_ _ (_) |_ _  _
+  #  | || ' \|  _| | ' \| |  _| || |
+  # |___|_||_|_| |_|_||_|_|\__|\_, |
+  #                            |__/
+
+  ##
+  # Class that represents the constant Infinity (∞)
+  class INFINITY_CONSTANT < CAS::Constant
+    # Initializer for the infinity constant
+    #
+    #  * **returns**: `CAS::INFINITY_CONSTANT` new instance
+    def initialize
+      @x = (1.0/0.0)
+    end
+
+    # String representation for the constant
+    #
+    #  * **returns**: `String`
+    def to_s
+      "∞"
+    end
+  end
+
+  # Infinity constant representation
+  Infinity = CAS::INFINITY_CONSTANT.new
+
+  #  _  _          ___       __ _      _ _
+  # | \| |___ __ _|_ _|_ _  / _(_)_ _ (_) |_ _  _
+  # | .` / -_) _` || || ' \|  _| | ' \| |  _| || |
+  # |_|\_\___\__, |___|_||_|_| |_|_||_|_|\__|\_, |
+  #          |___/                           |__/
+
+  ##
+  # Class that represents the constant Negative Infinity (-∞)
+  class NEG_INFINITY_CONSTANT < CAS::Constant
+    # Initializer for the negative infinity constant
+    #
+    #  * **returns**: `CAS::NEG_INFINITY_CONSTANT` new instance
+    def initialize
+      @x = -(1.0/0.0)
+    end
+
+    # String representation for the constant
+    #
+    #  * **returns**: `String`
+    def to_s
+      "-∞"
+    end
+  end
+
+  # Negative Infinity constant representation
+  NegInfinity = CAS::NEG_INFINITY_CONSTANT.new
+
+  #      _
+  #  ___/ |
+  # |___| |
+  #     |_|
+
+  ##
+  # Class that represents the constant Minus One (-1)
+  class MINUS_ONE_CONSTANT < CAS::Constant
+    # Initializer for the minus one constant
+    #
+    #  * **returns**: `CAS::MINUS_ONE_CONSTANT` new instance
+    def initialize
+      @x = -1.0
+    end
+
+    # String representation for the constant
+    #
+    #  * **returns**: `String`
+    def to_s
+      "-1"
+    end
+  end
+
+  # Minus One (-1) constant representation
+  MinusOne = CAS::MINUS_ONE_CONSTANT.new
+
+  # Series of useful numeric constant, Based upon
+  # `Numeric` keys, with `CAs::Constant` value
+  NumericToConst = {
+    0 => CAS::Zero,
+    0.0 => CAS::Zero,
+    1 => CAS::One,
+    1.0 => CAS::One,
+    2 => CAS::Two,
+    2.0 => CAS::Two,
+    Math::PI => CAS::Pi,
+    Math::E => CAS::E,
+    (1.0/0.0) => CAS::Infinity,
+  }
+
+  class Constant
+    @@simplify_dict = {
+      0 => CAS::Zero,
+      1 => CAS::One,
+      Math::PI => CAS::Pi,
+      Math::E => CAS::E,
+      (1.0/0.0) => CAS::Infinity
+    }
+  end
+end