Represents a Solution that is Eager, negatable, and branched with monotonic properties. This trait combines the characteristics of eagerly evaluated values, negatable structures, and entities with multiple branches (or solutions) represented by Structure.
Attributes
- Companion
- object
- Graph
-
- Supertypes
-
trait Eagertrait DyadicOpstrait Approximatetrait Valuabletrait TypeSafetrait Normalizable[Valuable]trait Exactitudetrait Unitarytrait Zeroabletrait Numerictrait Renderableclass Objecttrait Matchableclass AnyShow all
- Known subtypes
Members list
Value members
Abstract methods
Adds another Solution instance to the current instance, combining their effects or values based on the implementation of the + operation in the Solution trait.
Adds another Solution instance to the current instance, combining their effects or values based on the implementation of the + operation in the Solution trait.
CONSIDER this should be defined in CanAdd[Solution] rather than Solution. Maybe we could achieve that by defining Can as a subtype of Eager, rather than of Structure.
Value parameters
- other
-
the
Solutioninstance to add to the current instance
Attributes
- Returns
-
a new
Solutioninstance representing the result of the addition
Computes and returns the conjugate of the current Solution instance.
Computes and returns the conjugate of the current Solution instance.
The conjugate represents a value or transformation that is mathematically paired oppositely with the current instance based on the structure and properties of the Solution implementation.
Normally, the branch of the conjugate, added to the current branch should equal branches.
Attributes
- Returns
-
a new
Solutioninstance representing the conjugate of the current instance
Scales the current Solution instance by a given Rational factor. CONSIDER this could be merged with *.
Scales the current Solution instance by a given Rational factor. CONSIDER this could be merged with *.
The scaling operation adjusts the Solution based on the value of the provided Rational parameter, resulting in a new Solution instance that reflects the modification.
Value parameters
- r
-
the
Rationalvalue by which to scale the currentSolution
Attributes
- Returns
-
a new
Solutioninstance representing the result of the scaling operation
If this Solution can be represented as a Structure, return it wrapped in Some, otherwise return None.
If this Solution can be represented as a Structure, return it wrapped in Some, otherwise return None.
Attributes
- Returns
-
an
Option[Structure].
Inherited methods
Adds the current Eager instance to another Eager instance using the DyadicOperator mechanism. The addition operation is implemented by delegating to the addEagers function for specific behavior, ensuring proper handling of various subtypes of Eager.
Adds the current Eager instance to another Eager instance using the DyadicOperator mechanism. The addition operation is implemented by delegating to the addEagers function for specific behavior, ensuring proper handling of various subtypes of Eager.
Value parameters
- y
-
the
Eagerinstance to be added to thisEagerinstance
Attributes
- Returns
-
a
Try[Eager]containing the result of the addition if successful, or a failure if the operation fails - Inherited from:
- Eager
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
Realif successful; throws anAlgebraExceptionotherwise. - Inherited from:
- Approximate
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
Optioncontaining the approximate value as anEagerif successful, orNoneif no approximation is available. - Inherited from:
- Approximate
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
Compares two instances of Eager and determines their relative ordering. This method is not yet implemented and will raise an com.phasmidsoftware.number.algebra.util.AlgebraException if called.
Compares two instances of Eager and determines their relative ordering. This method is not yet implemented and will raise an com.phasmidsoftware.number.algebra.util.AlgebraException if called.
Value parameters
- x
-
the first
Eagerinstance to compare - y
-
the second
Eagerinstance to compare
Attributes
- Returns
-
a
Try[Int]that contains the comparison result: -0ifxandyare equal, - a negative result ifxis less thany, - and a positive result ifxis greater thany. As the method is unimplemented, it will always return a failure with anAlgebraException. - Inherited from:
- Eager
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
Performs division of the current Eager instance by another Eager instance. This operation is implemented using the DyadicOperator mechanism, delegating the actual division logic to the divideEagers function.
Performs division of the current Eager instance by another Eager instance. This operation is implemented using the DyadicOperator mechanism, delegating the actual division logic to the divideEagers function.
Value parameters
- y
-
the
Eagerinstance to divide the current instance by
Attributes
- Returns
-
a
Try[Eager]containing the result of the division if successful, or a failure if the operation cannot be performed - Inherited from:
- Eager
Compares this Eager instance with another Eager instance for equality. This method is unimplemented and currently returns a failure with an AlgebraException.
Compares this Eager instance with another Eager instance for equality. This method is unimplemented and currently returns a failure with an AlgebraException.
Value parameters
- that
-
the
Eagerinstance to compare against
Attributes
- Returns
-
a
Try[Boolean]indicating whether the two instances are equal. As the method is unimplemented, it always returns a failure containing anAlgebraException. - Inherited from:
- Eager
Attempts to convert the current object to an instance of Eager using an approximation method. If the conversion fails, it recovers by throwing an AlgebraException with a descriptive error message.
Attempts to convert the current object to an instance of Eager using an approximation method. If the conversion fails, it recovers by throwing an AlgebraException with a descriptive error message.
Attributes
- Returns
-
An instance of
Eagerif the approximation is successful. - Inherited from:
- Eager
Performs a fuzzy comparison between two Eager instances. The comparison is based on a specified tolerance and determines their relative ordering. If the comparison cannot be performed, an AlgebraException is returned as a failure.
Performs a fuzzy comparison between two Eager instances. The comparison is based on a specified tolerance and determines their relative ordering. If the comparison cannot be performed, an AlgebraException is returned as a failure.
Value parameters
- p
-
the tolerance (as a
Double) to be used for the comparison - x
-
the first
Eagerinstance to be compared - y
-
the second
Eagerinstance to be compared
Attributes
- Returns
-
a
Try[Int]representing the result of the comparison: - A negative integer ifxis less thany- Zero ifxis approximately equal toywithin the tolerancep- A positive integer ifxis greater thany- AFailure(AlgebraException)if the comparison cannot be performed - Inherited from:
- Eager
Performs a fuzzy equality comparison between the current Eager instance and another Eager instance. The comparison is based on a specified tolerance level. This method is unimplemented and currently returns a failure containing an AlgebraException.
Performs a fuzzy equality comparison between the current Eager instance and another Eager instance. The comparison is based on a specified tolerance level. This method is unimplemented and currently returns a failure containing an AlgebraException.
Value parameters
- confidence
-
the tolerance level (as a
Double) to be used for the fuzzy equality comparison - that
-
the
Eagerinstance to compare against this instance
Attributes
- Returns
-
a
Try[Boolean]indicating whether the two instances are fuzzy equal. As the method is unimplemented, it always returns a failure containing anAlgebraException. - Inherited from:
- Eager
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.
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.
- Inherited from:
- Eager
Multiplies the current Eager instance with another Eager instance. The multiplication operation is carried out using the DyadicOperator mechanism, which delegates to the multiplyEagers function for specific behavior. This ensures proper handling of various subtypes of Eager.
Multiplies the current Eager instance with another Eager instance. The multiplication operation is carried out using the DyadicOperator mechanism, which delegates to the multiplyEagers function for specific behavior. This ensures proper handling of various subtypes of Eager.
Value parameters
- y
-
the
Eagerinstance to multiply with thisEagerinstance
Attributes
- Returns
-
a
Try[Eager]containing the result of the multiplication if successful, or a failure if the operation cannot be performed - Inherited from:
- Eager
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
Valuableinstance to compute the product with
Attributes
- Returns
-
a
Valuableinstance representing the product of this and the other instance - Note
-
throws AlgebraException if the computation involves unsupported
Valuabletypes - 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.
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
Subtracts the given Eager instance y from the current Eager instance. This operation is performed using the DyadicOperator mechanism, which delegates to the subtractEagers function to handle the specific subtraction behavior.
Subtracts the given Eager instance y from the current Eager instance. This operation is performed using the DyadicOperator mechanism, which delegates to the subtractEagers function to handle the specific subtraction behavior.
Value parameters
- y
-
the
Eagerinstance to be subtracted from thisEagerinstance
Attributes
- Returns
-
a
Try[Eager]containing the result of the subtraction if successful, or a failure if the operation fails - Inherited from:
- Eager
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
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
Optioncontaining the approximate value as aRealif available, orNoneif no approximation can be computed. - Inherited from:
- Approximate
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
Booleanindicating whether the entity is exact (true) or is an approximation (false). - Inherited from:
- Exactitude
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
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
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
Factorif one qualifies under the provided context; otherwise,None. - Inherited from:
- Valuable
Retrieves an optional name associated with this instance.
Retrieves an optional name associated with this instance.
Attributes
- Returns
-
an
Option[String]containing the name if present, otherwiseNone - Inherited from:
- Eager
Returns a new instance of T that is the negation of the current instance. CONSIDER sorting out the use of CanNegate so that we can extend that for Structure.
Returns a new instance of T that is the negation of the current instance. CONSIDER sorting out the use of CanNegate so that we can extend that for Structure.
Attributes
- Returns
-
a
Structurerepresenting the negation of this instance - Inherited from:
- Negatable
Normalizes the current instance of Eager. This operation ensures that the instance is in its standard or canonical form. Be very wary of changing the way normalization works! One place that we don't routinely normalize (maybe we should) is in the Eq and FuzzyEq comparisons.
Normalizes the current instance of Eager. This operation ensures that the instance is in its standard or canonical form. Be very wary of changing the way normalization works! One place that we don't routinely normalize (maybe we should) is in the Eq and FuzzyEq comparisons.
Attributes
- Returns
-
the normalized instance of
EagerasSelf - Inherited from:
- Eager
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
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
Inherited fields
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
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
Optioncontaining the instance as aNumberif applicable, orNoneif not. - Inherited from:
- Valuable
Converts the current Lazy instance into an Eager instance by forcing the resolution or evaluation of its underlying value.
Converts the current Lazy instance into an Eager instance by forcing the resolution or evaluation of its underlying value.
The materialize method ensures that the computation of the value represented by this Lazy instance is completed and encapsulated within an appropriate Eager representation. This is particularly useful in scenarios where deferred computation needs to be explicitly resolved prior to further processing.
Attributes
- Returns
-
the materialized
Eagerinstance representing the resolved value - Inherited from:
- Eager
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