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/Expression

Expression

com.phasmidsoftware.number.expression.expr.Expression
See theExpression companion object
trait Expression extends Lazy, Approximate

Trait Expression which defines the behavior of a lazily evaluated tree of mathematical operations and operands.

NOTE there are only two subtypes of Expression: AtomicExpression and CompositeExpression We do not use "sealed" because this module would grow much too large.

Attributes

Companion
object
Graph
Supertypes
trait Approximate
trait Lazy
trait Valuable
trait TypeSafe
trait Exactitude
trait Unitary
trait Zeroable
trait Numeric
trait Renderable
class Object
trait Matchable
class Any
Show all
Known subtypes
class Noop
trait Root
class AbstractRoot
class LinearRoot
object L2
object LgE
class Literal
object E
object I
object Infinity
object Half
object MinusOne
object One
object Pi
object Two
object Zero
class Euler
trait Multiple
class Aggregate
class BiFunction
class UniFunction
Show all

Members list

Value members

Abstract methods

def depth: Int

Method to determine the depth of this Expression.

Method to determine the depth of this Expression.

Attributes

Returns

the depth (an atomic expression has a depth of 1).

def evaluate(context: Context): Option[Eager]

Action to evaluate this Expression as a Field, if possible. NOTE: no simplification or factor-based conversion occurs here.

Action to evaluate this Expression as a Field, if possible. NOTE: no simplification or factor-based conversion occurs here.

Attributes

Returns

an optional Field.

def isAtomic: Boolean

Method to determine if this Expression cannot be simplified on account of it being atomic.

Method to determine if this Expression cannot be simplified on account of it being atomic.

Attributes

Returns

true if this extends AtomicExpression

Concrete methods

def *(y: Expression): Expression
Implicitly added by ExpressionOps

Method to lazily multiply x by y.

Method to lazily multiply x by y.

Value parameters

y

a Number.

Attributes

Returns

an Expression which is the lazy product of x and y.

def +(y: Expression): Expression
Implicitly added by ExpressionOps

Method to add this Expression and another Expression, resulting in an Expression.

Method to add this Expression and another Expression, resulting in an Expression.

Value parameters

y

the other Expression.

Attributes

Returns

the sum of this and y.

def -(y: Expression): Expression
Implicitly added by ExpressionOps

Method to lazily subtract the Field y from x.

Method to lazily subtract the Field y from x.

Value parameters

y

a Field.

Attributes

Returns

an Expression which is the lazy product of x and y.

def /(y: Expression): Expression
Implicitly added by ExpressionOps

Method to lazily divide x by y.

Method to lazily divide x by y.

Value parameters

y

a Number.

Attributes

Returns

an Expression which is the lazy quotient of x / y.

def :*(y: Expression): Expression
Implicitly added by ExpressionOps

Method to lazily perform an operation on x and y.

Method to lazily perform an operation on x and y.

Value parameters

y

another Expression.

Attributes

Returns

an Expression which represents the result of the operation.

def :+(y: Expression): Expression
Implicitly added by ExpressionOps

Method to lazily append the given expression to this expression using addition.

Method to lazily append the given expression to this expression using addition.

Value parameters

y

an Expression to be added to this expression.

Attributes

Returns

an Expression resulting from the addition of this expression and the provided expression.

def atan(y: Expression): Expression
Implicitly added by ExpressionOps

Method to lazily get the value of atan2(x, y), i.e., if the result is z, then tan(z) = y/x.

Method to lazily get the value of atan2(x, y), i.e., if the result is z, then tan(z) = y/x.

Attributes

Returns

an Expression representing atan2(x, y).

def compare(comparand: Expression): Int
Implicitly added by ExpressionOps

Eagerly compare this expression with y.

Eagerly compare this expression with y.

XXX this appears to be recursive! But it isn't

Value parameters

comparand

the number to be compared.

Attributes

Returns

the result of the comparison.

def cos: Expression
Implicitly added by ExpressionOps

Method to lazily get the cosine of x.

Method to lazily get the cosine of x.

Attributes

Returns

an Expression representing the cos(x).

def cosh: Expression
Implicitly added by ExpressionOps

Method to lazily get the cosine of x.

Method to lazily get the cosine of x.

Attributes

Returns

an Expression representing the cos(x).

def exp: Expression
Implicitly added by ExpressionOps

Method to lazily get the value of e raised to the power of x.

Method to lazily get the value of e raised to the power of x.

Attributes

Returns

an Expression representing e raised to the power of x.

def ln: Expression
Implicitly added by ExpressionOps

Method to lazily get the natural log of x.

Method to lazily get the natural log of x.

Attributes

Returns

an Expression representing the log of x.

def log(b: Expression): Expression
Implicitly added by ExpressionOps

Computes the logarithm of a given expression to the specified base.

Computes the logarithm of a given expression to the specified base.

Value parameters

b

the base of the logarithm, represented as an Expression.

Attributes

Returns

an Expression representing the logarithm of this expression to the base b.

def multiply(other: Lazy): Lazy

Multiplies this Expression with another Lazy instance. If the other instance is of type Expression, a product operation is performed, and the result is simplified. If the other instance is not of type Expression, an ExpressionException is thrown.

Multiplies this Expression with another Lazy instance. If the other instance is of type Expression, a product operation is performed, and the result is simplified. If the other instance is not of type Expression, an ExpressionException is thrown.

Value parameters

other

the Lazy instance to multiply with this Expression

Attributes

Returns

a new Lazy instance representing the product of this Expression and the supplied Lazy instance

Throws
ExpressionException

if the provided other is not of type Expression

infix def plus(y: Expression): Expression
Implicitly added by ExpressionOps

Method to lazily multiply x by y.

Method to lazily multiply x by y.

Value parameters

y

another Expression.

Attributes

Returns

an Expression which is the lazy product of x and y.

def reciprocal: Expression
Implicitly added by ExpressionOps

Method to lazily yield the reciprocal of x.

Method to lazily yield the reciprocal of x.

NOTE we shouldn't really be trying to simplify here. That should be taken care of downstream.

Attributes

Returns

an Expression representing the reciprocal of x.

def sin: Expression
Implicitly added by ExpressionOps

Method to lazily get the sine of x.

Method to lazily get the sine of x.

Attributes

Returns

an Expression representing the sin(x).

def sinh: Expression
Implicitly added by ExpressionOps

Method to lazily get the sine of x.

Method to lazily get the sine of x.

Attributes

Returns

an Expression representing the sin(x).

def sqrt: Expression
Implicitly added by ExpressionOps

Method to lazily get the square root of x.

Method to lazily get the square root of x.

Attributes

Returns

an Expression representing the square root of x.

def tan: Expression
Implicitly added by ExpressionOps

Method to lazily get the tangent of x.

Method to lazily get the tangent of x.

Attributes

Returns

an Expression representing the tan(x).

def tanh: Expression
Implicitly added by ExpressionOps

Method to lazily get the tangent of x.

Method to lazily get the tangent of x.

Attributes

Returns

an Expression representing the tan(x).

infix def times(y: Expression): Expression
Implicitly added by ExpressionOps

Method to lazily multiply this expression by another expression.

Method to lazily multiply this expression by another expression.

Value parameters

y

another Expression to be multiplied with this expression.

Attributes

Returns

an Expression representing the lazy product of this expression and the given expression.

def unary_-: Expression
Implicitly added by ExpressionOps

Method to lazily change the sign of this expression.

Method to lazily change the sign of this expression.

Attributes

Returns

an Expression which is this negated.

def unit(x: Eager): Lazy

Transforms an instance of the Eager type into a Lazy instance, allowing for deferred computation or evaluation. NOTE that this method ignores this.

Transforms an instance of the Eager type into a Lazy instance, allowing for deferred computation or evaluation. NOTE that this method ignores this.

Value parameters

x

an instance of Eager that is to be converted into a Lazy representation

Attributes

Returns

a Lazy instance representing the deferred computation or evaluation of the input

def ∧(y: Expression): Expression
Implicitly added by ExpressionOps

Method to lazily raise x to the power of y. NOTE that this is not the caret character.

Method to lazily raise x to the power of y. NOTE that this is not the caret character.

Value parameters

y

the power to which x should be raised (an Expression).

Attributes

Returns

an Expression representing x to the power of y.

Inherited methods

def approximate: Real

Computes an approximate representation of the current value.

Computes an approximate representation of the current value.

This method utilizes the approximation mechanism to derive the most likely value in the form of a Real. Should the approximation fail, an AlgebraException will be raised to indicate the error.

Attributes

Returns

the approximate value as a Real if successful; throws an AlgebraException otherwise.

Inherited from:
Approximate
def approximationComplex(force: Boolean = ...): Option[Eager]

Attempts to compute an approximate complex representation of the current value.

Attempts to compute an approximate complex representation of the current value.

This method provides an optional approximation in the form of an Eager type. By default, it does not perform the computation unless explicitly requested through the force flag. The method may return None if no approximation can be computed or if the operation fails.

Value parameters

force

a boolean flag indicating whether to force computation of the approximation. If true, the method will attempt to perform a complex approximation even if it is resource-intensive or otherwise unwarranted.

Attributes

Returns

an Option containing the approximate value as an Eager if successful, or None if no approximation is available.

Inherited from:
Approximate
def category: String

Returns the category of this value in the Valuable type hierarchy.

Returns the category of this value in the Valuable type hierarchy.

Attributes

Returns

a string indicating the high-level category (e.g., "Expression", "Structure", "Nat", "Complex")

Inherited from:
TypeSafe
def describe: String

Returns a descriptive string combining category and type name. Useful for debugging to understand both the hierarchy level and concrete type.

Returns a descriptive string combining category and type name. Useful for debugging to understand both the hierarchy level and concrete type.

Attributes

Returns

a string in the format "Category.TypeName" (e.g., "Structure.WholeNumber")

Inherited from:
TypeSafe
def product(other: Valuable): Valuable

Obtains the product of this Valuable instance and another Valuable instance. The behavior of the method is determined by whether the instances are of type Lazy or Eager. If the provided instances do not conform to the expected types, an AlgebraException is thrown. CONSIDER supporting sum also.

Obtains the product of this Valuable instance and another Valuable instance. The behavior of the method is determined by whether the instances are of type Lazy or Eager. If the provided instances do not conform to the expected types, an AlgebraException is thrown. CONSIDER supporting sum also.

CONSIDER using lazify

Value parameters

other

the other Valuable instance to compute the product with

Attributes

Returns

a Valuable instance representing the product of this and the other instance

Note

throws AlgebraException if the computation involves unsupported Valuable types

Inherited from:
Valuable
def show: String

Renders and returns a string representation of the object. By default, this is the same as render but it can be overridden in subclasses.

Renders and returns a string representation of the object. By default, this is the same as render but it can be overridden in subclasses.

Attributes

Returns

a string representing the object

Inherited from:
Valuable
def typeName: String

Returns a simple string representation of the runtime type. Useful for debugging and logging.

Returns a simple string representation of the runtime type. Useful for debugging and logging.

Attributes

Returns

the simple class name (e.g., "WholeNumber", "RationalNumber")

Inherited from:
TypeSafe

Inherited and Abstract methods

def approximation(force: Boolean = ...): Option[Real]

Attempts to compute an approximate representation of the current value.

Attempts to compute an approximate representation of the current value.

This method provides an optional approximation of the value represented by the implementing class. The approximation may account for uncertainties or computational limitations. By default, this method does not force computation of the approximation unless explicitly requested.

Value parameters

force

a boolean flag indicating whether to force computation of the approximation. If true, the method will attempt to generate an approximation even if such computation is resource-intensive or not strictly necessary.

Attributes

Returns

an Option containing the approximate value as a Real if available, or None if no approximation can be computed.

Inherited from:
Approximate
def isExact: Boolean

Determines whether this object is exact, i.e., is not any kind of approximation.

Determines whether this object is exact, i.e., is not any kind of approximation.

CONSIDER it may be possible that there are non-approximatable entities that are not exact either.

The method returns true if the value is represented exactly in IEEE 754 format, or Two's complement or the exact value must be represented symbolically. Examples of the first type include the number one (represented here as either WholeNumber(1) or Succ(NatZero). Examples of the second type include 1.5 or the square root of two (represented here as InversePower(2,2)).

When we are forced to approximate a value, for example when we want to print the decimal value of 𝛗, the Golden Ratio, then we mark such a representation as approximate, i.e., this method returns false.

Attributes

Returns

a Boolean indicating whether the entity is exact (true) or is an approximation (false).

Inherited from:
Exactitude
def isUnity: Boolean

Determines whether this object represents unity.

Determines whether this object represents unity.

Attributes

Returns

true if the object represents unity, false otherwise

Inherited from:
Unitary
def isZero: Boolean

Determines if the current number is equal to zero.

Determines if the current number is equal to zero.

Attributes

Returns

true if the number is zero, false otherwise

Inherited from:
Zeroable
def maybeDouble: Option[Double]

If this is exact, it returns the exact value as a Double. Otherwise, it returns None. NOTE: do NOT implement this method to return a Double for a fuzzy Real--only for exact numbers.

If this is exact, it returns the exact value as a Double. Otherwise, it returns None. NOTE: do NOT implement this method to return a Double for a fuzzy Real--only for exact numbers.

Attributes

Returns

Some(x) where x is a Double if this is exact, else None.

Inherited from:
Numeric
def maybeFactor(context: Context): Option[Factor]

Attempts to retrieve a factor based on the provided context. This method evaluates whether there is an applicable factor within the given context.

Attempts to retrieve a factor based on the provided context. This method evaluates whether there is an applicable factor within the given context.

Value parameters

context

the context in which the factor is evaluated.

Attributes

Returns

an optional Factor if one qualifies under the provided context; otherwise, None.

Inherited from:
Valuable
def render: String

Method to render this Valuable for presentation to the user. NOTE to implementors: never ever invoke this.toString in your implementation lest you get a StackOverflow.

Method to render this Valuable for presentation to the user. NOTE to implementors: never ever invoke this.toString in your implementation lest you get a StackOverflow.

Attributes

Returns

a String

Inherited from:
Renderable
def signum: Int

Determines the sign of the Structure value represented by this instance. Returns an integer indicating whether the value is positive, negative, or zero.

Determines the sign of the Structure value represented by this instance. Returns an integer indicating whether the value is positive, negative, or zero.

Attributes

Returns

1 if the value is positive, -1 if the value is negative, and 0 if the value is zero

Inherited from:
Zeroable

Concrete fields

lazy val approximation: Option[Real]

A lazily evaluated optional approximation of this Expression.

A lazily evaluated optional approximation of this Expression.

This field holds the result of simplifying the Expression with the approximation flag set to true. If the approximation is possible, it will store the approximated Real value; otherwise, it will remain None.

This approximation is computed based on the context of the simplify method, which determines how the expression should be approximated.

Attributes

lazy val approximationComplex: Option[Eager]

Represents the optional approximate evaluation of a complex Expression. The property retrieves the result of invoking the approximationComplex method on the simplify field, passing true as an argument to indicate that the result should be computed for complex approximations.

Represents the optional approximate evaluation of a complex Expression. The property retrieves the result of invoking the approximationComplex method on the simplify field, passing true as an argument to indicate that the result should be computed for complex approximations.

This lazy value ensures that the computation is deferred until accessed, and only computed once for performance optimization.

Attributes

Returns

An Option of type Eager, containing the approximate complex representation of this Expression, if available. Otherwise, None.

lazy val asCoreNumber: Option[Number]

Method to determine if the materialized value of this Expression is defined and corresponds to a Number. If this expression is exact, then evaluate as is and convert the result to a Number. Otherwise, we simply materialize this expression and convert the result to a Number.

Method to determine if the materialized value of this Expression is defined and corresponds to a Number. If this expression is exact, then evaluate as is and convert the result to a Number. Otherwise, we simply materialize this expression and convert the result to a Number.

Attributes

Returns

a Some(x) if this materializes as a Number; otherwise None.

lazy val containsI: Boolean

Determines if the current Expression or any of its sub-expressions contains the constant I.

Determines if the current Expression or any of its sub-expressions contains the constant I.

For Expression instances:

  • If the Expression is exactly the constant I, returns true.
  • If the Expression is a composite of other expressions (CompositeExpression), recursively searches through the terms to check if any of them contains the constant I.
  • For all other cases, returns false.

Attributes

Returns

true if the constant I is present in the Expression or its components, false otherwise.

lazy val debug: String

Method to use when debugging to know exactly what an Expression is in tree form. This is needed because toString and other renderers all use some sort of syntactic sugar to make things look nice for us humans.

Method to use when debugging to know exactly what an Expression is in tree form. This is needed because toString and other renderers all use some sort of syntactic sugar to make things look nice for us humans.

Creates a string representation of this Expression for debugging purposes. Depending on the type of this Expression, the output format varies:

  • For atomic Product instances (arity 0), the productPrefix is returned.
  • For non-atomic Product instances, the productPrefix is combined with the debug representation of contained sub-expressions (if they are Expressions) or their toString representation otherwise.
  • For all other cases, the default toString implementation is used.

Attributes

Returns

a String representation useful for debugging.

lazy val evaluateAsIs: Option[Eager]

Evaluates this Expression in the context of AnyContext without simplification or factor-based conversion. This allows obtaining a direct evaluation of the Expression as a Eager, if possible. NOTE: no simplification or factor-based conversion occurs here.

Evaluates this Expression in the context of AnyContext without simplification or factor-based conversion. This allows obtaining a direct evaluation of the Expression as a Eager, if possible. NOTE: no simplification or factor-based conversion occurs here.

Attributes

Returns

either a Some[Eager] containing the value if evaluation is successful, or None otherwise.

lazy val fuzzy: Eager

Computes the fuzzy (approximate) value of this Expression. If the current Expression can be matched to a simpler form via matchSimpler, its fuzzy value is derived from the simplified expression. Otherwise, the fuzzy result is delegated to the superclass implementation.

Computes the fuzzy (approximate) value of this Expression. If the current Expression can be matched to a simpler form via matchSimpler, its fuzzy value is derived from the simplified expression. Otherwise, the fuzzy result is delegated to the superclass implementation.

Attributes

Returns

an eager.Real representing the approximate value of this Expression

lazy val isEager: Boolean

Method to determine if this Expression can be evaluated as is. If so, then materialize will not lose any precision because no approximation will be required. NOTE that, it is conceivable that simplifying this Expression first might result in an eager value even though this method would return false.

Method to determine if this Expression can be evaluated as is. If so, then materialize will not lose any precision because no approximation will be required. NOTE that, it is conceivable that simplifying this Expression first might result in an eager value even though this method would return false.

Attributes

Returns

true if evaluateAsIs is defined.

lazy val materialize: Eager

Materializes this Expression into an Eager object by simplifying it, evaluating as-is, optionally approximating it, and recovering with a defined exception in case of failure.

Materializes this Expression into an Eager object by simplifying it, evaluating as-is, optionally approximating it, and recovering with a defined exception in case of failure.

This method should be the final step when dealing with an Expression. Do not materialize early because that defeats the entire purpose of lazy evaluation.

The method first simplifies the expression, attempts to evaluate it directly, and then tries an approximation if necessary. Ultimately, it ensures the resulting materialized object is an instance of Eager.

The Eager result will be normalized if appropriate.

Attributes

Returns

an Eager representation of this Expression achieved through evaluation and/or approximation.

lazy val simplify: Expression

Simplifies the current Expression instance. If a simpler representation of the Expression can be determined, it returns that representation. Otherwise, it returns the current Expression unchanged. NOTE: be careful not to invoke recursively.

Simplifies the current Expression instance. If a simpler representation of the Expression can be determined, it returns that representation. Otherwise, it returns the current Expression unchanged. NOTE: be careful not to invoke recursively.

Attributes

Returns

the simplified Expression, or the current Expression if no simplification is possible

Inherited fields

lazy val asMonotone: Structure

Casts this Valuable instance into a Structure type if it already is a Structure. If the instance is not a Structure, an AlgebraException is thrown. CONSIDER returning Option[Structure] instead.

Casts this Valuable instance into a Structure type if it already is a Structure. If the instance is not a Structure, an AlgebraException is thrown. CONSIDER returning Option[Structure] instead.

Attributes

Returns

the current instance as a Structure

Note

Throws com.phasmidsoftware.number.algebra.util.AlgebraException if the instance is not of type Structure

Inherited from:
Valuable
lazy val asNumber: Option[Number]

Attempts to cast this instance to a Number. If the instance is of type Number, it is wrapped in an Option and returned. Otherwise, returns None.

Attempts to cast this instance to a Number. If the instance is of type Number, it is wrapped in an Option and returned. Otherwise, returns None.

Attributes

Returns

an Option containing the instance as a Number if applicable, or None if not.

Inherited from:
Valuable
lazy val normalize: Valuable

Normalizes the current Lazy instance to its simplest Valuable equivalent. The method first attempts to simplify the instance using the simplify method. If the simplified result is exact, the method materializes it and normalizes the resulting value. Otherwise, the simplified value is returned as is.

Normalizes the current Lazy instance to its simplest Valuable equivalent. The method first attempts to simplify the instance using the simplify method. If the simplified result is exact, the method materializes it and normalizes the resulting value. Otherwise, the simplified value is returned as is.

Attributes

Returns

the simplest Valuable representation of this value after normalization

Inherited from:
Lazy
lazy val toDouble: Double

Converts the approximate representation of this number into a Double.

Converts the approximate representation of this number into a Double.

This method attempts to approximate the value of this number by invoking the approximation method with force = true. If the approximation exists, it is converted to a Double. If no approximation can be obtained, an AlgebraException is thrown to indicate a logic error.

Attributes

Returns

the approximate value as a Double.

Note

Throws an com.phasmidsoftware.number.algebra.util.AlgebraException if no approximation can be obtained.

Inherited from:
Approximate
Generated with