Number - Scala Mathematical Library
1.10.6
API
Generated with
Number - Scala Mathematical Library/com.phasmidsoftware.number/com.phasmidsoftware.number.expression/com.phasmidsoftware.number.expression.expr/Product

Product

com.phasmidsoftware.number.expression.expr.Product
case object Product extends ExpressionBiFunction

Represents a specific implementation of the ExpressionBiFunction that performs multiplication between two Valuable values.

This object embodies a binary operation where the function takes two inputs and computes their product using the multiply method defined on Valuable. The operation is represented by the symbol "*".

  • The operation is marked as exact, ensuring the result is always precise when the inputs are exact.
  • It inherits the commutative property from ExpressionBiFunction, as multiplication is commutative.

Attributes

Graph
Supertypes
trait Singleton
trait Product
trait Mirror
trait Serializable
trait Product
trait Equals
trait ((Eager, Eager)) => Valuable
class Object
trait Matchable
class Any
Show all
Self type
Product.type

Members list

Type members

Inherited types

type MirroredElemLabels = EmptyTuple

The names of the product elements.

The names of the product elements.

Attributes

Inherited from:
Singleton
type MirroredElemTypes = EmptyTuple

Attributes

Inherited from:
Singleton
type MirroredMonoType = this.type

The mirrored *-type.

The mirrored *-type.

Attributes

Inherited from:
Singleton
type MirroredType = this.type

Attributes

Inherited from:
Singleton

Inherited and Abstract types

type MirroredLabel <: String

The name of the type.

The name of the type.

Attributes

Inherited from:
Mirror

Value members

Concrete methods

def applyExact(a: Eager, b: Eager): Option[Eager]

Applies a binary operation to the provided Valuable elements a and b, with stricter evaluation rules, and returns an optional result. The evaluation succeeds only if the operation satisfies specific conditions (e.g., exact representations or mathematical constraints).

Applies a binary operation to the provided Valuable elements a and b, with stricter evaluation rules, and returns an optional result. The evaluation succeeds only if the operation satisfies specific conditions (e.g., exact representations or mathematical constraints).

Value parameters

a

the first operand, a Valuable instance.

b

the second operand, a Valuable instance.

Attributes

Returns

an Option[Valuable] containing the result of the operation if it can be computed exactly, or None if the operation fails to meet exactness requirements.

def leftContext(context: Context): Context

Retrieves the left-hand evaluation context associated with this function.

Retrieves the left-hand evaluation context associated with this function.

Attributes

Returns

None.

def rightContext(factor: Factor)(context: Context): Context

Determines the right-hand evaluation context for a given Context.

Determines the right-hand evaluation context for a given Context.

The method evaluates the provided context and returns a new Context that is derived based on the specific rules for different types of contexts.

CONSIDER reworking this method to take a Factor (from the left-hand parameter) and a Context (the overall context). Otherwise, I don't think it's going to work properly.

Value parameters

context

the initial Context to be evaluated and transformed.

Attributes

Returns

the resulting Context after applying the transformation logic.

Inherited methods

def andThen[A](g: Valuable => A): (Eager, Eager) => A

Composes two instances of Function1 in a new Function1, with this function applied first.

Composes two instances of Function1 in a new Function1, with this function applied first.

Type parameters

A

the result type of function g

Value parameters

g

a function R => A

Attributes

Returns

a new function f such that f(x) == g(apply(x))

Inherited from:
Function1
def apply(ff: (Eager, Eager)): Eager

Alternative apply method which satisfies the type declaration. Applies the binary function f to the given tuple of Eager elements.

Alternative apply method which satisfies the type declaration. Applies the binary function f to the given tuple of Eager elements.

Value parameters

ff

a tuple containing two Eager elements, representing the inputs to the binary function.

Attributes

Returns

a Eager that is the result of applying the binary function to the input tuple.

Inherited from:
ExpressionBiFunction
def apply(a: Eager, b: Eager): Eager

Evaluate this function on x.

Evaluate this function on x.

Value parameters

a

the first parameter to the function.

b

the second parameter to the function.

Attributes

Returns

the result of f(x).

Inherited from:
ExpressionBiFunction
def applyExact(p: (Eager, Eager)): Option[Eager]

Applies the function exactly to the given input of type P, returning an Option of type Valuable if the application is successful.

Applies the function exactly to the given input of type P, returning an Option of type Valuable if the application is successful.

If defined, the output is guaranteed to be exact.

Value parameters

p

the input parameter of type P to which the function is applied

Attributes

Returns

an Option containing a Valuable result if the function executes successfully, or None if the operation cannot produce a valid result

Inherited from:
ExpressionBiFunction
def compose[A](g: A => (Eager, Eager)): A => Valuable

Composes two instances of Function1 in a new Function1, with this function applied last.

Composes two instances of Function1 in a new Function1, with this function applied last.

Type parameters

A

the type to which function g can be applied

Value parameters

g

a function A => T1

Attributes

Returns

a new function f such that f(x) == apply(g(x))

Inherited from:
Function1
def evaluate(a: Expression, b: Expression)(context: Context): Option[Eager]

Evaluates two expressions x and y in a given context and determines the resulting Valuable based on specific identity and evaluation rules. Trivial identities are recognized and evaluated appropriately.

Evaluates two expressions x and y in a given context and determines the resulting Valuable based on specific identity and evaluation rules. Trivial identities are recognized and evaluated appropriately.

Value parameters

a

the first expression to be evaluated.

b

the second expression to be evaluated.

context

the evaluation context providing the necessary environment for resolving expressions.

Attributes

Returns

an Option[Valuable] containing the result of the evaluation if successful, or None if evaluation fails.

Inherited from:
ExpressionBiFunction
def evaluateAsIs(x: Expression, y: Expression): Option[Eager]

Evaluates two expressions as-is (without any simplification or conversion) and applies the function f to the results if both evaluations are successful.

Evaluates two expressions as-is (without any simplification or conversion) and applies the function f to the results if both evaluations are successful.

Value parameters

x

the first expression to be evaluated.

y

the second expression to be evaluated.

Attributes

Returns

an Option[Valuable] containing the result of applying the binary function to the evaluated results of x and y, or None if either evaluation fails.

Inherited from:
ExpressionBiFunction
def fromProduct(p: Product): MirroredMonoType

Creates a new instance of type T with elements taken from product p.

Creates a new instance of type T with elements taken from product p.

Attributes

Inherited from:
Singleton
def productElementNames: Iterator[String]

An iterator over the names of all the elements of this product.

An iterator over the names of all the elements of this product.

Attributes

Inherited from:
Product
def productIterator: Iterator[Any]

An iterator over all the elements of this product.

An iterator over all the elements of this product.

Attributes

Returns

in the default implementation, an Iterator[Any]

Inherited from:
Product
override def toString: String

Generate helpful debugging information about this ExpressionMonoFunction.

Generate helpful debugging information about this ExpressionMonoFunction.

Attributes

Returns

a String.

Definition Classes
ExpressionBiFunction -> Function1 -> Any
Inherited from:
ExpressionBiFunction

Inherited fields

lazy val commutes: Boolean

Indicates whether the binary operation represented by this instance commutes, meaning the result remains unchanged for arbitrary swapping of inputs. This is determined based on the absence of a right-hand identity (maybeIdentityR).

Indicates whether the binary operation represented by this instance commutes, meaning the result remains unchanged for arbitrary swapping of inputs. This is determined based on the absence of a right-hand identity (maybeIdentityR).

Attributes

Inherited from:
ExpressionBiFunction
val f: (Eager, Eager) => Eager

Attributes

Inherited from:
ExpressionBiFunction
val isExact: Boolean

Attributes

Inherited from:
ExpressionBiFunction
val maybeIdentityL: Option[Eager]

Attributes

Inherited from:
ExpressionBiFunction
val maybeIdentityR: Option[Eager]

Attributes

Inherited from:
ExpressionBiFunction
val name: String

Returns the name of the expression function.

Returns the name of the expression function.

Attributes

Returns

a string representing the name of the function

Inherited from:
ExpressionBiFunction
Generated with