Mr.CAS 0.2.6

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

@@ -0,0 +1,319 @@
+#!//usr/bin/env ruby
+
+module CAS
+  #  ___           ___             _ _ _   _
+  # | _ ) _____ __/ __|___ _ _  __| (_) |_(_)___ _ _
+  # | _ \/ _ \ \ / (__/ _ \ ' \/ _` | |  _| / _ \ ' \
+  # |___/\___/_\_\\___\___/_||_\__,_|_|\__|_\___/_||_|
+
+  ##
+  # BoxCondition class constructs a condition of the type:
+  #
+  # ```
+  # L < f(x) < U
+  # ```
+  #
+  # and this is a metaclass for different type of box conditions:
+  #
+  #  * open: `a < f(x) < b`
+  #  * lower closed: `a ≤ f(x) < b`
+  #  * upper closed: `a < f(x) ≤ b`
+  #  * closed: `a ≤ f(x) ≤ b`
+  class BoxCondition < CAS::Condition
+    # Contained operation
+    attr_reader :x
+    # Upper bound as `CAS::Constant`
+    attr_reader :lower
+    # Lower bound as `CAs::Constant`
+    attr_reader :upper
+
+    # Initializes a new box condition. A function is required as central term,
+    # while the second and the third elements are lower and upper bounds
+    # as `CAS::Constant`
+    #
+    #  * **argument**: `CAS::Op` central term of the box condition
+    #  * **argument**: `CAS::Constant` lower bound
+    #  * **argument**: `CAS::Constant` upper bound
+    #  * **returns**: `CAS::BoxCondition` new instance
+    def initialize(x, lower, upper)
+      if lower.is_a? Numeric
+        lower = CAS::const lower
+      end
+      if upper.is_a? Numeric
+        upper = CAS::const upper
+      end
+      CAS::Help.assert(lower, CAS::Constant)
+      CAS::Help.assert(upper, CAS::Constant)
+
+      CAS::Help.assert(x, CAS::Op)
+
+      lower, upper = upper, lower if lower.x > upper.x
+
+      @lower = lower
+      @upper = upper
+      @x = x
+    end
+
+    # Saves some required elements
+    def representative
+      @lower_cond  = @upper_cond = "<"
+      @lower_str   = @upper_str  = "<"
+      self
+    end
+
+    # Returns true if one the central function depends upon the expression included
+    #
+    #  * **argument**: `CAS::Op` operator to check against for dependencies
+    #  * **returns**: `TrueClass` or `FalseClass`
+    def depend?(v)
+      @x.depend? v
+    end
+
+    # Simplify left and right term of the operator
+    #
+    #  * **returns**: `CAS::BoxCondition`
+    def simplify
+      @x.simplify
+      return self
+    end
+
+    # Substitute in the central element using a dictionary
+    #
+    #  * **returns**: `Hash` of substitutions
+    def subs(fd)
+      @x = @x.subs(fd)
+      return self
+    end
+
+    # Performs the derivative of the box condition. The derivative of
+    # a box condition is a `CAS::Equal` object (the derivative of a constant
+    # is zero):
+    #
+    # ```
+    #   d
+    #  -- [a < f(x) < b] = f'(x) == 0
+    #  dx
+    # ```
+    #
+    # since between the two there is a difference relation.
+    #
+    #  * **argument**: `CAS::Op` to perform the derivative
+    def diff(v)
+      CAS::equal(@x.diff(v).simplify, CAS::Zero)
+    end
+
+    # Returns an array of variables of the central function
+    #
+    #  * **returns**: `Array` of `CAS::Variable`
+    def args
+      @x.args
+    end
+
+    # Return true if two BoxConditions are equal, false if different
+    #
+    #  * **argument**: `CAS::Op` operator to check against for equality
+    #  * **returns**: `TrueClass` or `FalseClass`
+    def ==(cond)
+      return false if not self.class != cond.class
+      return (@x == cond.x and @lower == cond.lower and @upper == cond.upper)
+    end
+
+    # Function call will evaluate left and right functions to solve the
+    # relation
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Trueclass` or `Falseclass`
+    def call(_fd)
+      raise CAS::CASError, "This is a virtual method"
+    end
+
+    # Inspector for the class. It is class specific
+    #
+    #  * **returns**: `String`
+    def inspect
+      "(#{@lower.inspect} #{@lower_cond} #{@x.inspect} #{@upper_cond} #{@upper.inspect})"
+    end
+
+    # Returns a string that represents the object to be printed
+    #
+    # `String`
+    def to_s
+      "#{@lower} #{@lower_str} #{@x} #{@upper_str} #{@upper}"
+    end
+
+    # Return the code that performs a condition evaluation
+    #
+    #  * **returns**: `String`
+    def to_code
+      "((#{@lower.to_code} #{@lower_cond} (#{@x.to_code})) and ((#{@x.to_code}) #{@upper_cond} #{@upper.to_code}))"
+    end
+  end # BoxCondition
+
+  #  ___           ___             _ _ _   _          ___
+  # | _ ) _____ __/ __|___ _ _  __| (_) |_(_)___ _ _ / _ \ _ __  ___ _ _
+  # | _ \/ _ \ \ / (__/ _ \ ' \/ _` | |  _| / _ \ ' \ (_) | '_ \/ -_) ' \
+  # |___/\___/_\_\\___\___/_||_\__,_|_|\__|_\___/_||_\___/| .__/\___|_||_|
+  #                                                       |_|
+
+  ##
+  # Implements the box condition with both bounds are open
+  #
+  # ```
+  # a < f(x) < b
+  # ```
+  class BoxConditionOpen < CAS::BoxCondition
+    # Saves some required elements
+    def representative
+      @lower_cond = @upper_cond = @lower_str = @upper_str = "<"
+      self
+    end
+
+    # Function call will evaluate box condition to evaluate
+    # relation
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Trueclass` or `Falseclass`
+    def call(fd)
+      x_call = @x.call(fd)
+      return ((@lower.call(fd) < x_call) and (x_call < @upper))
+    end
+  end # BoxConditionOpen
+
+  #  ___           ___             _ _ _   _          _                        ___ _                _
+  # | _ ) _____ __/ __|___ _ _  __| (_) |_(_)___ _ _ | |   _____ __ _____ _ _ / __| |___ ___ ___ __| |
+  # | _ \/ _ \ \ / (__/ _ \ ' \/ _` | |  _| / _ \ ' \| |__/ _ \ V  V / -_) '_| (__| / _ (_-</ -_) _` |
+  # |___/\___/_\_\\___\___/_||_\__,_|_|\__|_\___/_||_|____\___/\_/\_/\___|_|  \___|_\___/__/\___\__,_|
+
+  ##
+  # Implements the box condition with lower bound closed and upper open
+  #
+  # ```
+  # a ≤ f(x) < b
+  # ```
+  class BoxConditionLowerClosed < CAS::BoxCondition
+    # Saves some required elements
+    def representative
+      @lower_cond  = "<="
+      @lower_str   = "≤"
+      @upper_cond  =  @upper_str = "<"
+      self
+    end
+
+    # Function call will evaluate box condition to evaluate
+    # relation
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Trueclass` or `Falseclass`
+    def call(fd)
+      x_call = @x.call(fd)
+      return ((@lower.call(fd) <= x_call) and (x_call < @upper))
+    end
+  end # BoxConditionLowerClosed
+
+  #  ___           ___             _ _ _   _         _   _                     ___ _                _
+  # | _ ) _____ __/ __|___ _ _  __| (_) |_(_)___ _ _| | | |_ __ _ __  ___ _ _ / __| |___ ___ ___ __| |
+  # | _ \/ _ \ \ / (__/ _ \ ' \/ _` | |  _| / _ \ ' \ |_| | '_ \ '_ \/ -_) '_| (__| / _ (_-</ -_) _` |
+  # |___/\___/_\_\\___\___/_||_\__,_|_|\__|_\___/_||_\___/| .__/ .__/\___|_|  \___|_\___/__/\___\__,_|
+  #                                                       |_|  |_|
+
+  ##
+  # Implements the box condition with lower bound open and upper closed
+  #
+  # ```
+  # a < f(x) ≤ b
+  # ```
+  class BoxConditionUpperClosed < CAS::BoxCondition
+    # Saves some required elements
+    def representative
+      @lower_cond = @lower_str = "<"
+      @upper_cond = "<="
+      @upper_str  = "≤"
+      self
+    end
+
+    # Function call will evaluate box condition to evaluate
+    # relation
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Trueclass` or `Falseclass`
+    def call(fd)
+      x_call = @x.call(fd)
+      return ((@lower.call(fd) < x_call) and (x_call <= @upper))
+    end
+  end # BoxConditionUpperClosed
+
+  #  ___           ___             _ _ _   _          ___ _                _
+  # | _ ) _____ __/ __|___ _ _  __| (_) |_(_)___ _ _ / __| |___ ___ ___ __| |
+  # | _ \/ _ \ \ / (__/ _ \ ' \/ _` | |  _| / _ \ ' \ (__| / _ (_-</ -_) _` |
+  # |___/\___/_\_\\___\___/_||_\__,_|_|\__|_\___/_||_\___|_\___/__/\___\__,_|
+
+  ##
+  # Implements the box condition with both bounds closed
+  #
+  # ```
+  # a ≤ f(x) ≤ b
+  # ```
+  class BoxConditionClosed < CAS::BoxCondition
+    # Saves some required elements
+    def representative
+      @lower_cond  = @upper_cond  = "<="
+      @lower_str   = @upper_str   = "≤"
+      self
+    end
+
+    # Function call will evaluate box condition to evaluate
+    # relation
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Trueclass` or `Falseclass`
+    def call(fd)
+      x_call = @x.call(fd)
+      return ((@lower.call(fd) <= x_call) and (x_call <= @upper))
+    end
+  end # BoxConditionUpperClosed
+
+  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
+    # Shortcut for creating a new box condition. It requires limits and type:
+    #
+    #  * **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 limit(a, b, type=:closed)
+      return CAS::box(self, a, b, type)
+    end
+  end # Op
+end

data/lib/functions/fnc-conditions.rb

@@ -0,0 +1,365 @@
+#!/usr/bin/env ruby
+
+module CAS
+  #   ___             _ _ _   _
+  #  / __|___ _ _  __| (_) |_(_)___ _ _
+  # | (__/ _ \ ' \/ _` | |  _| / _ \ ' \
+  #  \___\___/_||_\__,_|_|\__|_\___/_||_|
+
+  ##
+  # Condition class is a pseudo-class for all the other kind of conditions:
+  #
+  #  * Equal
+  #  * Greater
+  #  * GreaterEqual
+  #  * Smaller
+  #  * SmallerEqual
+  #
+  # When derivated, the two functions (that can be considered as the difference of two elements)
+  # are derived autonoumouosly. A condition is composed by:
+  #
+  #  * left function (x)
+  #  * right function (y)
+  #  * type of condition
+  class Condition
+    # Left hand side
+    attr_reader :x
+    # Right hand side
+    attr_reader :y
+
+    # Initializer for a new condition. The condition is implicit in the class, thus a
+    # pure `CAS::Condition` cannot be used.
+    #
+    #  * **argument**: `CAS::Op` left argument
+    #  * **argument**: `CAS::Op` right argument
+    #  * **returns**: `CAS::Condition` new instance
+    def initialize(x, y)
+      @x = x
+      @y = y
+      self.representative
+    end
+
+    # Saves some required elements
+    def representative
+      @cond_type  = "??"
+      @cond_repr  = "??"
+      self
+    end
+
+    # Function call will evaluate left and right functions to solve the
+    # relation
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Trueclass` or `Falseclass`
+    def call(_fd)
+      raise CAS::CASError, "This is a virtual method"
+    end
+
+    # Inspector for the class. It is class specific
+    #
+    #  * **returns**: `String`
+    def inspect
+      "#{self.class}(#{@x.inspect}, #{@y.inspect})"
+    end
+
+    # Returns a string that represents the object to be printed
+    #
+    # `String`
+    def to_s
+      "(#{@x} #{@cond_repr} #{@y})"
+    end
+
+    # Return the code that performs a condition evaluation
+    #
+    #  * **returns**: `String`
+    def to_code
+      "(#{@x} #{@cond_type} #{@y})"
+    end
+
+    # Returns an array of variables of the two functions in the condition
+    #
+    #  * **returns**: `Array` of `CAS::Variable`
+    def args
+      (@x.args + @y.args).uniq
+    end
+
+    # Performs the derivative of the two elements:
+    #
+    # ```
+    #  d
+    # -- [f(x) > g(y)] = f'(x) > g'(x)
+    # dx
+    # ```
+    #
+    # since between the two there is a difference relation.
+    #
+    #  * **argument**: `CAS::Op` to perform the derivative
+    def diff(v)
+      CAS::Help.assert v, CAS::Op
+
+      @x.diff(v)
+      @y.diff(v)
+      self.simplify
+    end
+
+    # Returns true if one of the two functions depends upon the expression included
+    #
+    #  * **argument**: `CAS::Op` operator to check against for dependencies
+    #  * **returns**: `TrueClass` or `FalseClass`
+    def depend?(v)
+      CAS::Help.assert v, CAS::Op
+
+      @x.depend?(v) or @y.depend?(v)
+    end
+
+    # Return true if two functions are equal, false if different
+    #
+    #  * **argument**: `CAS::Op` operator to check against for equality
+    #  * **returns**: `TrueClass` or `FalseClass`
+    def ==(op)
+      CAS::Help.assert(op, CAS::Op)
+
+      # condB = (@x == op.y) and (@y == op.x)
+      return ((@x == op.x) and (@y == op.y) and (self.class == op.class))
+    end
+
+    # Simplify left and right term of the operator
+    #
+    #  * **returns**: `CAS::Condition`
+    def simplify
+      @x.simplify
+      @y.simplify
+      return self
+    end
+
+    # Substitute in the two elements using a dictionary
+    #
+    #  * **returns**: `Hash` of substitutions
+    def subs(fd)
+      CAS::Help.assert(fd, Hash)
+      @x.subs(fd)
+      @y.subs(fd)
+      return self
+    end
+
+    # Returns the dot graphviz representation of the code
+    #
+    #  * **returns**: `String`
+    def dot_graph(node)
+      cls = "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id}"
+      "#{cls} -> #{@x.dot_graph node}\n  #{cls} -> #{@y.dot_graph node}"
+    end
+  end # Condition
+
+  #  ___                _
+  # | __|__ _ _  _ __ _| |
+  # | _|/ _` | || / _` | |
+  # |___\__, |\_,_\__,_|_|
+  #        |_|
+
+  ##
+  # This class is a Condition for two equal function
+  class Equal < CAS::Condition
+    # Saves some required elements
+    def representative
+      @cond_type, @cond_repr = "==", "≡"
+      self
+    end
+
+    # Function call will evaluate left and right functions to solve the
+    # relation
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Trueclass` or `Falseclass`
+    def call(fd)
+      CAS::Help.assert fd, Hash
+
+      return (@x.call(fd) == @y.call(fd))
+    end
+
+    # Return true if two functions are equal, false if different
+    #
+    #  * **argument**: `CAS::Op` operator to check against for equality
+    #  * **returns**: `TrueClass` or `FalseClass`
+    def ==(op)
+      CAS::Help.assert(op, CAS::Op)
+      cond_f = ((@x == op.x) and (@y == op.y)) or ((@x == op.y) and (@y == op.x))
+      return (cond_f and (self.class == op.class))
+    end
+  end # Equal
+
+  #  ___            _ _
+  # / __|_ __  __ _| | |___ _ _
+  # \__ \ '  \/ _` | | / -_) '_|
+  # |___/_|_|_\__,_|_|_\___|_|
+
+  ##
+  # This class is a Condition for left smaller function
+  class Smaller < CAS::Condition
+    # Saves some required elements
+    def representative
+      @cond_type = @cond_repr = "<"
+      self
+    end
+
+    # Function call will evaluate left and right functions to solve the
+    # relation
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Trueclass` or `Falseclass`
+    def call(fd)
+      CAS::Help.assert fd, Hash
+
+      return (@x.call(fd) < @y.call(fd))
+    end
+  end # Smaller
+
+  #   ___              _
+  #  / __|_ _ ___ __ _| |_ ___ _ _
+  # | (_ | '_/ -_) _` |  _/ -_) '_|
+  #  \___|_| \___\__,_|\__\___|_|
+
+  ##
+  # This class is a Condition for right smaller function
+  class Greater < CAS::Condition
+    # Saves some required elements
+    def representative
+      @cond_type = @cond_repr = ">"
+      self
+    end
+
+    # Function call will evaluate left and right functions to solve the
+    # relation
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Trueclass` or `Falseclass`
+    def call(fd)
+      CAS::Help.assert fd, Hash
+
+      return (@x.call(fd) > @y.call(fd))
+    end
+  end # Greater
+
+  #  ___            _ _         ___                _
+  # / __|_ __  __ _| | |___ _ _| __|__ _ _  _ __ _| |
+  # \__ \ '  \/ _` | | / -_) '_| _|/ _` | || / _` | |
+  # |___/_|_|_\__,_|_|_\___|_| |___\__, |\_,_\__,_|_|
+  #                                   |_|
+
+  ##
+  # This class is a Condition for left smaller or equal function
+  class SmallerEqual < CAS::Condition
+    # Saves some required elements
+    def representative
+      @cond_type = "<="
+      @cond_repr = "≤"
+      self
+    end
+
+    # Function call will evaluate left and right functions to solve the
+    # relation
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Trueclass` or `Falseclass`
+    def call(fd)
+      CAS::Help.assert fd, Hash
+
+      return (@x.call(fd) <= @y.call(fd))
+    end
+  end # SmallerEqual
+
+  #   ___              _           ___                _
+  #  / __|_ _ ___ __ _| |_ ___ _ _| __|__ _ _  _ __ _| |
+  # | (_ | '_/ -_) _` |  _/ -_) '_| _|/ _` | || / _` | |
+  #  \___|_| \___\__,_|\__\___|_| |___\__, |\_,_\__,_|_|
+  #                                      |_|
+
+  ##
+  # This class is a condition for right smaller or equal function
+  class GreaterEqual < CAS::Condition
+    # Saves some required elements
+    def representative
+      @cond_type = ">="
+      @cond_repr = "≥"
+      self
+    end
+
+    # Function call will evaluate left and right functions to solve the
+    # relation
+    #
+    #  * **argument**: `Hash` with feed dictionary
+    #  * **returns**: `Trueclass` or `Falseclass`
+    def call(fd)
+      CAS::Help.assert fd, Hash
+
+      return (@x.call(fd) >= @y.call(fd))
+    end
+  end # SmallerEqual
+
+  # Shortcut creates a `CAS::Equal` object
+  def self.equal(x, y)
+    CAS::Equal.new(x, y)
+  end
+
+  # Shortcut creates a `CAS::Greater` object
+  def self.greater(x, y)
+    CAS::Greater.new(x, y)
+  end
+
+  # Shortcut creates a `CAS::GreaterEqual` object
+  def self.greater_equal(x, y)
+    CAS::GreaterEqual.new(x, y)
+  end
+
+  # Shortcut creates `CAS::Smaller` object
+  def self.smaller(x, y)
+    CAS::Smaller.new(x, y)
+  end
+
+  # Shortcut creates a `CAs::SmallerEqual` object
+  def self.smaller_equal(x, y)
+    CAS::SmallerEqual.new(x, y)
+  end
+
+  class Op
+    # Shortcut for creating equality condition.
+    #
+    #  * **argument**: `CAS::Op` ther element of the condition
+    #  * **returns**: `CAS::Equal` new instance
+    def equal(v)
+      CAS.equal(self, v)
+    end
+
+    # Shortcut for creating greater kind condition.
+    #
+    #  * **argument**: `CAS::Op` ther element of the condition
+    #  * **returns**: `CAS::Greater` new instance
+    def greater(v)
+      CAS.greater(self, v)
+    end
+
+    # Shortcut for creating a smaller kind condition.
+    #
+    #  * **argument**: `CAS::Op` ther element of the condition
+    #  * **returns**: `CAS::Smaller` new instance
+    def smaller(v)
+      CAS.smaller(self, v)
+    end
+
+    # Shortcut for creating a greater equal kind condition.
+    #
+    #  * **argument**: `CAS::Op` ther element of the condition
+    #  * **returns**: `CAS::GreaterEqual` new instance
+    def greater_equal(v)
+      CAS.greater_equal(self, v)
+    end
+
+    # Shortcut for creating a smaller equal kind condition.
+    #
+    #  * **argument**: `CAS::Op` ther element of the condition
+    #  * **returns**: `CAS::SmallerEqual` new instance
+    def smaller_equal(v)
+      CAS.smaller_equal(self, v)
+    end
+  end # Op
+end