class CAS::Prod

Product class. Performs the product between two elements. This class will be soon modified as an n-ary operator.

Public Instance Methods

*(op) click to toggle source

The new element of a sum accumulates inside the vector that holds the elements

# File lib/functions/fnc-prod.rb, line 16
def *(op)
  CAS::Help.assert(op, CAS::Op)
  @x << op
  self
end
call(f) click to toggle source

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`
# File lib/functions/fnc-prod.rb, line 53
def call(f)
  CAS::Help.assert(f, Hash)

  return @x.inject { |p, y| p = p.overloaded_mul(y.call(f)) }
end
diff(v) click to toggle source

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
# File lib/functions/fnc-prod.rb, line 35
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
simplify() click to toggle source

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
Calls superclass method CAS::NaryOp#simplify
# File lib/functions/fnc-prod.rb, line 77
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
to_code() click to toggle source

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`
# File lib/functions/fnc-prod.rb, line 97
def to_code
  "(#{@x.map(&:to_code).join(" * ")})"
end
to_s() click to toggle source

Convert expression to string

* **returns**: `String` to print on screen
# File lib/functions/fnc-prod.rb, line 62
def to_s
  "(#{@x.map(&:to_s).join(" * ")})"
end