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 39 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 76 def call(f) CAS::Help.assert(f, Hash) p = 1 @x.each do |y| p = p.overloaded_mul(y.call(f)) end p 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 58 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 103 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 123 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 88 def to_s "(#{@x.map(&:to_s).join(" * ")})" end