Number - Scala Mathematical Library
1.10.6
API
Generated with
Number - Scala Mathematical Library/com.phasmidsoftware.number/com.phasmidsoftware.number.algebra/com.phasmidsoftware.number.algebra.eager/Structure

Structure

com.phasmidsoftware.number.algebra.eager.Structure
See theStructure companion object
trait Structure extends Eager, WithFuzziness, Negatable[Structure]

Represents a Structure, which is one-dimensional Structure that supports various mathematical operations and properties. Structures include both exact and approximate numerical entities.

Structure does not support ordering because not all Structures are comparable.

Multidimensional mathematical quantities like Solution cannot be represented by a Structure object.

Attributes

Companion
object
Graph
Supertypes
trait Eager
trait DyadicOps
trait Approximate
trait Valuable
trait TypeSafe
trait Exactitude
trait Unitary
trait Zeroable
trait Numeric
trait Renderable
class Object
trait Matchable
class Any
Show all
Known subtypes
trait Functional
trait Radians
class Angle
trait Transformed
class Exponential
class InversePower
trait Scalar
object NoScalar
trait Number
trait ExactNumber
class WholeNumber
class Real
Show all

Members list

Value members

Abstract methods

def convert[T <: Structure : ClassTag](t: T): Option[T]

Converts the given Structure object to an optional instance of the same type.

Converts the given Structure object to an optional instance of the same type.

TODO refactor this method to use a type class instance of CanConvert[T, Structure] instead of ClassTag.

Value parameters

t

the input object of type T which is a subtype of Structure.

Attributes

Returns

an Option containing a transformed instance of type T if the conversion is successful, or None otherwise.

Concrete methods

def add(y: Structure): Try[Structure]

Adds the specified Structure instance to the current instance, producing a new Structure.

Adds the specified Structure instance to the current instance, producing a new Structure.

Value parameters

y

The Structure instance to be added.

Attributes

Returns

A Try wrapping the resulting Structure instance, or a failure if the operation cannot be completed.

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

Attempts to approximate the current instance to a Real value. If the instance is already of type Real, it is simply returned, wrapped inside Some. Otherwise, depending on the value of force, it either attempts a conversion to a default Real (if force is true), or returns None.

Attempts to approximate the current instance to a Real value. If the instance is already of type Real, it is simply returned, wrapped inside Some. Otherwise, depending on the value of force, it either attempts a conversion to a default Real (if force is true), or returns None.

NOTE that this method tries to keep exact quantities exact.

Value parameters

force

a boolean flag indicating whether to force the conversion to a default Real value when the current instance is not of type Real

Attributes

Returns

an Option[Real] containing the approximated value if successful, or None if approximation fails

def asJavaNumber: Option[Number]

Converts this Structure object into an optional java.lang.Number provided that the conversion can be performed without loss of precision.

Converts this Structure object into an optional java.lang.Number provided that the conversion can be performed without loss of precision.

The method determines whether the current Structure object can be represented as a java.lang.Number by leveraging the asNumber method and further evaluating certain conditions:

  • If the Structure object is an ExactNumber and its factor is PureNumber, the result is converted using Value.asJavaNumber.
  • If the Structure object is a Real with a wiggle value below a specified tolerance, the result is also converted using Value.asJavaNumber.
  • In all other cases, None is returned.

Attributes

Returns

an optional java.lang.Number representation of this object. The result is Some(java.lang.Number) if the conversion is successful under the stated conditions; otherwise, None.

def divide(y: Structure): Try[Structure]

Divides the current Structure instance by another Structure instance. The operation is performed using the DyadicOperator defined for Structure. The result is wrapped in a Try to handle potential failures during the operation.

Divides the current Structure instance by another Structure instance. The operation is performed using the DyadicOperator defined for Structure. The result is wrapped in a Try to handle potential failures during the operation.

Value parameters

y

the Structure instance to divide the current instance by

Attributes

Returns

a Try[Structure] containing the result of the division if successful, or a failure if the operation cannot be performed

override def fuzzyEqv(confidence: Double)(that: Eager): Try[Boolean]

Performs a fuzzy equality comparison between the current Structure instance and another Eager instance. The comparison is based on a specified tolerance level.

Performs a fuzzy equality comparison between the current Structure instance and another Eager instance. The comparison is based on a specified tolerance level.

If both instances are of type Structure, this method attempts to convert them to Real and performs a fuzzy equality check with the specified tolerance. If the conversion or comparison fails, a failure with an appropriate AlgebraException is returned.

If either of the instances is not of type Structure, a failure with an AlgebraException is returned.

Value parameters

confidence

the tolerance level (as a Double) to be used for the fuzzy equality comparison.

that

the Eager instance to compare against the current instance.

Attributes

Returns

a Try[Boolean] indicating whether the two instances are fuzzy equal within the specified tolerance. Returns a Success(true) or Success(false) if the comparison completes successfully, or a Failure(AlgebraException) if an error occurs.

Definition Classes
def multiply(y: Structure): Try[Structure]

Multiplies the current Structure instance by the specified Structure operand. The result of the operation is wrapped in a Try, allowing for safe handling of failures.

Multiplies the current Structure instance by the specified Structure operand. The result of the operation is wrapped in a Try, allowing for safe handling of failures.

Value parameters

y

the Structure operand with which the current instance is multiplied

Attributes

Returns

a Try[Structure] containing the result of the multiplication if successful, or a failure if the operation is not valid or cannot be performed

def subtract(y: Structure): Try[Structure]

Subtracts the given Structure instance (y) from the current instance. The operation is performed using a dyadic operator that ensures type safety and handles any failures during the subtraction via a Try.

Subtracts the given Structure instance (y) from the current instance. The operation is performed using a dyadic operator that ensures type safety and handles any failures during the subtraction via a Try.

Value parameters

y

the Structure instance to be subtracted from the current instance

Attributes

Returns

a Try[Structure] containing the result of the subtraction if successful, or a failure if the subtraction operation cannot be performed

Inherited methods

infix def add(y: Eager): Try[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.

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 Eager instance to be added to this Eager instance

Attributes

Returns

a Try[Eager] containing the result of the addition if successful, or a failure if the operation fails

Inherited from:
Eager
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 compare(x: Eager, y: Eager): Try[Int]

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 Eager instance to compare

y

the second Eager instance to compare

Attributes

Returns

a Try[Int] that contains the comparison result: - 0 if x and y are equal, - a negative result if x is less than y, - and a positive result if x is greater than y. As the method is unimplemented, it will always return a failure with an AlgebraException.

Inherited from:
Eager
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
infix def divide(y: Eager): Try[Eager]

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 Eager instance 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
def eqv(that: Eager): Try[Boolean]

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 Eager instance 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 an AlgebraException.

Inherited from:
Eager
def fuzzy: 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 Eager if the approximation is successful.

Inherited from:
Eager
def fuzzyCompare(p: Double)(x: Eager, y: Eager): Try[Int]

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 Eager instance to be compared

y

the second Eager instance to be compared

Attributes

Returns

a Try[Int] representing the result of the comparison: - A negative integer if x is less than y - Zero if x is approximately equal to y within the tolerance p - A positive integer if x is greater than y - A Failure(AlgebraException) if the comparison cannot be performed

Inherited from:
Eager
def maybeDouble: Option[Double]

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
infix def multiply(y: Eager): Try[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 Eager instance to multiply with this Eager instance

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
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
infix def subtract(y: Eager): Try[Eager]

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 Eager instance to be subtracted from this Eager instance

Attributes

Returns

a Try[Eager] containing the result of the subtraction if successful, or a failure if the operation fails

Inherited from:
Eager
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 fuzz: Option[Fuzziness[Double]]

Retrieves an optional fuzziness value associated with this instance.

Retrieves an optional fuzziness value associated with this instance.

The fuzziness value, if present, provides information about the level of uncertainty or imprecision, modeled as a Fuzziness[Double].

Attributes

Returns

an Option containing the Fuzziness[Double] value if defined, or None if no fuzziness is specified.

Inherited from:
WithFuzziness
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 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 maybeName: Option[String]

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, otherwise None

Inherited from:
Eager
def negate: 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.

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 Structure representing the negation of this instance

Inherited from:
Negatable
def normalize: Eager

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 Eager as Self

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

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 materialize: Eager

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 Eager instance representing the resolved value

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