Number - Scala Mathematical Library/com.phasmidsoftware.number/com.phasmidsoftware.number.expression/com.phasmidsoftware.number.expression.expr/CompositeExpression

CompositeExpression

com.phasmidsoftware.number.expression.expr.CompositeExpression

See theCompositeExpression companion object

trait CompositeExpression extends Expression

A trait representing a composite mathematical or logical expression. It is a higher-order expression that combines multiple sub-expressions into a structured form. This trait provides methods and utilities for simplifying, rendering, and interpreting such expressions.

CompositeExpression inherits from the Expression trait and serves as a foundation for more specific composite structures, such as aggregates or compound expressions.

NOTE: this trait was formerly sealed. It has been unsealed to allow splitting across multiple files.

Attributes

Companion: object
Graph
Supertypes: trait Expression

trait Approximate

trait Lazy

trait Valuable

trait TypeSafe

trait Normalizable[Valuable]

trait Exactitude

trait Unitary

trait Zeroable

trait Numeric

trait Renderable

class Object

trait Matchable

class Any
Show all
Known subtypes: class Euler

trait Multiple

class Aggregate

class BinaryFunction

class BiFunction

class UniFunction
Show all

Members list

Value members

Abstract methods

Attempts to simplify the CompositeExpression by identifying and reducing trivial expressions into their simpler or more elementary forms, if possible. A trivial simplification is one that depends on fortuitous expressions, not necessarily constants, that can therefore be combined in some way.

Attributes

Returns: an em.AutoMatcher[Expression] encapsulating the logic to simplify trivial forms within the CompositeExpression. The result contains either the simplified Expression or indicates that no trivial simplifications were possible.

Simplifies the components of this CompositeExpression using a matching mechanism to identify and transform sub-expressions into simpler forms if possible.

Attributes

Returns: the result of the simplification attempt encapsulated in a MatchResult, which either contains a simplified Expression or indicates that no simplification was possible.

Renders this CompositeExpression as a string representation of the expression itself, typically in a structured or human-readable mathematical format.

Attributes

Returns: a string representation of the CompositeExpression as an expression.

Attempts to simplify this CompositeExpression by applying pattern-based rewrites. It delegates the simplification logic to the defined matchers that aim to reduce the expression into its simpler or optimized form, if possible.

Attributes

Returns: an em.AutoMatcher[Expression] encapsulating the logic to simplify the CompositeExpression. The result contains either the simplified Expression or indicates no further simplifications were possible.

Provides the terms that comprise this CompositeExpression.

Attributes

Returns: a sequence of Expression objects representing the individual terms of this CompositeExpression.

Concrete methods

Indicates whether the operands of this CompositeExpression should remain unaltered during processing.

This property determines whether simplification or transformations should be applied to the operands of the expression, or if they are to be left unchanged. The exact behavior is specific to the context of the CompositeExpression.

Attributes

Returns: true if the operands are to remain as is; false otherwise.

Determines if all components within a given Expression are named.

TODO handle the specific cases at their proper level in the type hierarchy.

This method recursively checks whether each component of the provided Expression either has a name (in the case of a Nameable expression) or, if it is a composite expression (CompositeExpression), ensures that all of its terms also have names.

Attributes

Returns: true if all components of the expression are named, otherwise false.

Inherited methods

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

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

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

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

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
Inherited from:: Expression

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

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

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

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
Inherited from:: Expression

Inherited and Abstract methods

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

Method to determine the depth of this Expression.

Attributes

Returns: the depth (an atomic expression has a depth of 1).
Inherited from:: Expression

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

Attributes

Returns: an optional Field.
Inherited from:: Expression

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

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

Concrete fields

Indicates whether this expression is atomic.

Attributes

Returns: false as the default value, indicating the expression is not atomic.

Determines whether this object represents unity.

Attributes

Returns: true if the object represents unity, false otherwise

Determines if the current number is equal to zero.

Attributes

Returns: true if the number is zero, false otherwise

If this Valuable 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.

Provides a lazy string representation of the CompositeExpression, delegating the rendering logic to the renderAsExpression method.

This value is computed only once, upon its first access, and caches the result for subsequent accesses. It is intended to present the CompositeExpression in a structured or human-readable mathematical format by reusing the string output generated by renderAsExpression.

Attributes

Returns: the string representation of this CompositeExpression.

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

Simplifies the exact form of a CompositeExpression by identifying and transforming sub-expressions into their precise, simplified forms. This method focuses on exact mathematical simplifications that can be performed without introducing approximations.

TODO try to merge this method with Expression.simplifyByEvaluation.

Attributes

Returns: an em.AutoMatcher[Expression] that encapsulates the logic for simplifying exact expressions. The result contains the simplified Expression if successful, or indicates no simplification was possible.

Inherited fields

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

Inherited from:: Expression

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.
Inherited from:: Expression

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.
Inherited from:: Expression

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

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

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.
Inherited from:: Expression

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.
Inherited from:: Expression

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.
Inherited from:: Expression

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
Inherited from:: Expression

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.
Inherited from:: Expression

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.
Inherited from:: Expression

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

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 from:: Expression

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

In this article

Generated with