AbstractScalar (Java Accumulators and Variants)

java.lang.Object
- java.lang.Number
- - net.sf.jaccumulator.scalars.AbstractScalar<SCALAR>

Type Parameters:
SCALAR - this scalar type (used to facilitate operation chaining on write operations)

All Implemented Interfaces:

Serializable, AlgebraicStructure<SCALAR>, BooleanValue<SCALAR>, MutableBooleanValue<SCALAR>, SealedBooleanValue, ByteValue<SCALAR>, MutableByteValue<SCALAR>, SealedByteValue, CharacterValue<SCALAR>, MutableCharacterValue<SCALAR>, SealedCharacterValue, DoubleValue<SCALAR>, MutableDoubleValue<SCALAR>, SealedDoubleValue, FloatValue<SCALAR>, MutableFloatValue<SCALAR>, SealedFloatValue, IntegerValue<SCALAR>, MutableIntegerValue<SCALAR>, SealedIntegerValue, LongValue<SCALAR>, MutableLongValue<SCALAR>, SealedLongValue, Mutable, MutableAlgebraicStructure<SCALAR>, MutableKernel<SCALAR>, Replicator<SCALAR>, CharacterProperties, MutableScalar<SCALAR>, MutableScalarDomain<SCALAR>, NumericProperties, Scalar<SCALAR>, ScalarDomain<SCALAR>, ScalarInductor<SCALAR>, ScalarReplicator<SCALAR>, SealedScalar<SCALAR>, SealedScalarBag, SealedScalarDomain, SealedAlgebraicStructure, SealedKernel, MutableShortValue<SCALAR>, SealedShortValue, ShortValue<SCALAR>, StructureProperties

Direct Known Subclasses:

AbstractReal
```
public abstract class AbstractScalar<SCALAR extends Scalar<SCALAR>>
extends Number
implements Scalar<SCALAR>, Serializable
```
Common read and write behavior for system supported primitives

Since:

JAccumulator 4.0

Author:

Nicole Tedesco (Nicole@NicoleTedesco.com)

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static Double NaN

static Integer ONEI

static long ZERO_DOUBLE_LONG_BITS

static int ZERO_FLOAT_INT_BITS

static Integer ZEROI

Fields
Modifier and Type	Field and Description
`static Double`	`NaN`
`static Integer`	`ONEI`
`static long`	`ZERO_DOUBLE_LONG_BITS`
`static int`	`ZERO_FLOAT_INT_BITS`
`static Integer`	`ZEROI`

Constructor Summary

Constructors
Constructor and Description

AbstractScalar()

AbstractScalar(Domain aDomain, NumericPrecision aPrecision)

Constructors
Constructor and Description
`AbstractScalar()`
`AbstractScalar(Domain aDomain, NumericPrecision aPrecision)`

Method Summary

Methods
Modifier and Type	Method and Description
`SCALAR`	`absoluteValue()` Replace the current value with the absolute value of itself
`SCALAR`	`and(boolean aValue)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`and(byte aValue)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`and(char aValue)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`and(int aValue)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`and(long aValue)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`and(short aValue)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`andOfNumber(Number aValue)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`andOfScalar(SealedScalar<?> aValue)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`angleWith(double aValue)` Set this value to the angle formed by the rectangular coordinates given by the current value, x, and the specified value, y.
`SCALAR`	`angleWithNumber(Number y)` Set this value to the angle formed by the rectangular coordinates given by the current value, x, and the specified value, y.
`SCALAR`	`angleWithScalar(SealedScalar<?> aValue)` Set this value to the angle formed by the rectangular coordinates given by the current value, x, and the specified value, y.
`SCALAR`	`arcCosine()` Replace the current value with its arc `cosine`
`SCALAR`	`arcSine()` Replace the current value with its arc `sine`
`SCALAR`	`arcTangent()` Replace the current value with its arc `tangent`
`SCALAR`	`assertDomain(Domain aDomain)` Attempt to convert the implementation `domain` of this structure to the closest available match for the proposed domain.
`SCALAR`	`assertPrecision(NumericPrecision prec)` Convert the numeric `precision` of this implementation to the closest available match for the proposed precision.
`SCALAR`	`base10Log()` Replace the current value with its base 10 logarithm
`static void`	`boundsCheck(int anIndex, int anOrdinalBound)`
`static byte`	`byteMaskAt(int aBitPosition)`
`static byte`	`byteNotMaskAt(int aBitPosition)`
`static byte`	`byteValue(boolean[] aBooleanArray)`
`SCALAR`	`ceiling()` Replace the current value with the smallest (closest to negative infinity) value that is greater than or equal to the current value and is equal to a mathematical integer
`static char`	`charMaskAt(int aBitPosition)`
`static char`	`charNotMaskAt(int aBitPosition)`
`static char`	`charValue(boolean[] aBooleanArray)`
`static byte`	`clearByteBitAt(int anIndex, byte myValue)`
`static char`	`clearCharBitAt(int anIndex, char myValue)`
`static double`	`clearDoubleBitAt(int anIndex, double myValue)`
`static float`	`clearFloatBitAt(int anIndex, float myValue)`
`static int`	`clearIntBitAt(int anIndex, int myValue)`
`static long`	`clearLongBitAt(int anIndex, long myValue)`
`static short`	`clearShortBitAt(int anIndex, short myValue)`
`static BigDecimal`	`clearUnlimitedDecimalBitAt(int anIndex, BigDecimal myValue)`
`static BigInteger`	`clearUnlimitedIntegerBitAt(int anIndex, BigInteger myValue)`
`static int`	`compareTo(BigDecimal p0, BigDecimal p1)`
`static int`	`compareTo(BigInteger p0, BigInteger p1)`
`static int`	`compareTo(boolean p0, boolean p1)`
`static int`	`compareTo(byte p0, byte p1)`
`static int`	`compareTo(char p0, char p1)`
`static int`	`compareTo(CharSequence p0, CharSequence p1)`
`static int`	`compareTo(double p0, double p1)`
`static int`	`compareTo(float p0, float p1)`
`static int`	`compareTo(int p0, int p1)`
`static int`	`compareTo(long p0, long p1)`
`static int`	`compareTo(short p0, short p1)`
`int`	`compareToNumber(Number aValue)` Compares this object with the specified object for order
`int`	`compareToScalar(boolean aValue)` Compares this object with the specified scalar for order
`int`	`compareToScalar(byte aValue)` Compares this object with the specified scalar for order
`int`	`compareToScalar(char aValue)` Compares this object with the specified scalar for order
`int`	`compareToScalar(double aValue)` Compares this object with the specified scalar for order
`int`	`compareToScalar(float aValue)` Compares this object with the specified scalar for order
`int`	`compareToScalar(int aValue)` Compares this object with the specified scalar for order
`int`	`compareToScalar(long aValue)` Compares this object with the specified scalar for order
`int`	`compareToScalar(SealedScalar<?> aValue)` Compares this object with the specified object for order
`int`	`compareToScalar(short aValue)` Compares this object with the specified scalar for order
`int`	`compareToZero()` Compares this object with zero for order
`SCALAR`	`cosine()` Replace the current value, assumed to be an angle in radians, to its `cosine`
`SCALAR`	`cubeRoot()` Replace the current value with the cube root of itself
`SCALAR`	`degrees()` Replace the current value, assumed to be an angle in radians, to its equivalent angle in degrees
`SCALAR`	`difference(boolean aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`SCALAR`	`difference(byte aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`SCALAR`	`difference(char aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`SCALAR`	`difference(double aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`SCALAR`	`difference(float aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`SCALAR`	`difference(int aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`SCALAR`	`difference(long aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`SCALAR`	`difference(short aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`SCALAR`	`differenceOfNumber(Number aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`SCALAR`	`differenceOfScalar(SealedScalar<?> aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`static void`	`divideByZero()`
`SCALAR`	`down()` Round the current value towards zero (truncate)
`boolean`	`equals(Object anObject)`
`SCALAR`	`exponential()` Replace the current value with e (Napier's constant) raised to the current value (eⁿ)
`SCALAR`	`exponentialLessOne()` Replace the current value with e (Napier's constant) raised to the current value, less 1 (eⁿ-1)
`SCALAR`	`floor()` Replace the current value with the largest (closest to positive infinity) value that is less than or equal to the current value and is equal to a mathematical integer
`SCALAR`	`gcd(byte aValue)` Replace the current value with the greatest common factor between this value and the specific one
`SCALAR`	`gcd(char aValue)` Replace the current value with the greatest common factor between this value and the specific one
`SCALAR`	`gcd(int aValue)` Replace the current value with the greatest common factor between this value and the specific one
`SCALAR`	`gcd(long aValue)` Replace the current value with the greatest common factor between this value and the specific one
`SCALAR`	`gcd(short aValue)` Replace the current value with the greatest common factor between this value and the specific one
`SCALAR`	`gcdOfNumber(Number aValue)` Replace the current value with the greatest common factor between this value and the specific one
`SCALAR`	`gcdOfScalar(Scalar<?> aScalar)` Replace the current value with the greatest common factor between this value and the specific one
`static boolean`	`getBooleanBitAt(int anIndex, boolean myValue)`
`static boolean`	`getByteBitAt(int anIndex, byte myValue)`
`static boolean`	`getCharBitAt(int anIndex, char myValue)`
`Domain`	`getDomain()`
`static boolean`	`getDoubleBitAt(int anIndex, double myValue)`
`static boolean`	`getFloatBitAt(int anIndex, float myValue)`
`static boolean`	`getIntBitAt(int anIndex, int myValue)`
`static boolean`	`getLongBitAt(int anIndex, long myValue)`
`NumericPrecision`	`getPrecision()`
`static boolean`	`getShortBitAt(int anIndex, short myValue)`
`static boolean`	`getUnlimitedDecimalBitAt(int anIndex, BigDecimal myValue)`
`static boolean`	`getUnlimitedIntegerBitAt(int anIndex, BigInteger myValue)`
`SCALAR`	`halfDown()` Round towards "nearest neighbor" unless both neighbors are equidistant, in which case round down
`SCALAR`	`halfEven()` Round towards "nearest neighbor" unless both neighbors are equidistant, in which case round to the even neighbor
`SCALAR`	`halfUp()` Round towards "nearest neighbor" unless both neighbors are equidistant, in which case round up
`static int`	`hashCode(boolean aValue)`
`static int`	`hashCode(byte aValue)`
`static int`	`hashCode(char aValue)`
`static int`	`hashCode(double aValue)`
`static int`	`hashCode(float aValue)`
`static int`	`hashCode(int aValue)`
`static int`	`hashCode(long aValue)`
`static int`	`hashCode(short aValue)`
`SCALAR`	`hyperbolicCosine()` Replace the current value, assumed to be an angle in radians, to its hyperbolic `cosine`
`SCALAR`	`hyperbolicSine()` Replace the current value, assumed to be an angle in radians, to its hyperbolic `sine`
`SCALAR`	`hyperbolicTangent()` Replace the current value, assumed to be an angle in radians, to its hyperbolic `tangent`
`SCALAR`	`hypotenuseWith(double aValue)` Set this value to the hypotenuse formed by the square root of the sum of the square of the current value, x, and the square of the specified value, y, without intermediate overflow or underflow
`SCALAR`	`hypotenuseWithNumber(Number aValue)` Set this value to the hypotenuse formed by the square root of the sum of the square of the current value, x, and the square of the specified value, y, without intermediate overflow or underflow
`SCALAR`	`hypotenuseWithScalar(SealedScalar<?> aValue)` Set this value to the hypotenuse formed by the square root of the sum of the square of the current value, x, and the square of the specified value, y, without intermediate overflow or underflow
`static void`	`indexOutOfBoundsAt(int anIndex)`
`<S extends Scalar<?>> S`	`induceScalarSize(S aTarget)` Update the target `scalar` with the element count in this structure
`static int`	`intGCD(int p0, int p1)`
`static int`	`intMaskAt(int aBitPosition)`
`static int`	`intModularInverse(int p0, int p1)`
`static int`	`intModularQuotient(int aDividend, int aDivisor, int aModulus)`
`static int`	`intNotMaskAt(int aBitPosition)`
`static int`	`intValue(boolean[] aBooleanArray)`
`SCALAR`	`invalidate()` Replace the current value an invalid value such `INVALID` if possible, otherwise replace it with zero
`boolean`	`isAlphabetic()`
`boolean`	`isBmpCodePoint()`
`boolean`	`isConfigurable()` Answer `true` if the implementation of this object can be changed. A configurable object has a structure that can be `expanded`, or `reduced`, or has replaceable components.
`boolean`	`isCountable()` Answer `true` if this structure contains a countable number of elements.
`boolean`	`isDigit()` Determine if this `char`-width or `int`-width character is a digit within Unicode
`boolean`	`isElastic()` Answer `true` if this structure, in principle, can be reduced via element removal or expanded via element addition.
`boolean`	`isEmpty()` Answer `true` if this structure contains no elements.
`boolean`	`isEqual(boolean aScalar)`
`boolean`	`isEqual(byte aScalar)`
`boolean`	`isEqual(char aScalar)`
`boolean`	`isEqual(double aScalar)`
`boolean`	`isEqual(float aScalar)`
`boolean`	`isEqual(int aScalar)`
`boolean`	`isEqual(long aScalar)`
`boolean`	`isEqual(short aScalar)`
`boolean`	`isEqualToNumber(Number aNumber)`
`boolean`	`isEqualToScalar(SealedScalar<?> aScalar)`
`boolean`	`isExpandable()`
`boolean`	`isFalse()`
`boolean`	`isFinite()`
`boolean`	`isGreater(boolean aScalar)`
`boolean`	`isGreater(byte aScalar)`
`boolean`	`isGreater(char aScalar)`
`boolean`	`isGreater(double aScalar)`
`boolean`	`isGreater(float aScalar)`
`boolean`	`isGreater(int aScalar)`
`boolean`	`isGreater(long aScalar)`
`boolean`	`isGreater(short aScalar)`
`boolean`	`isGreaterOrEqual(boolean aScalar)`
`boolean`	`isGreaterOrEqual(byte aScalar)`
`boolean`	`isGreaterOrEqual(char aScalar)`
`boolean`	`isGreaterOrEqual(double aScalar)`
`boolean`	`isGreaterOrEqual(float aScalar)`
`boolean`	`isGreaterOrEqual(int aScalar)`
`boolean`	`isGreaterOrEqual(long aScalar)`
`boolean`	`isGreaterOrEqual(short aScalar)`
`boolean`	`isGreaterOrEqualToNumber(Number aNumber)`
`boolean`	`isGreaterOrEqualToScalar(SealedScalar<?> aScalar)`
`boolean`	`isGreaterThanNumber(Number aNumber)`
`boolean`	`isGreaterThanScalar(SealedScalar<?> aScalar)`
`boolean`	`isHighSurrogate()`
`boolean`	`isIdentifierIgnorable()` Determine if this `char`-width or `int`-width character ignorable character in a Java identifier or a Unicode identifier
`boolean`	`isIdeographic()`
`boolean`	`isImaginary()` Answer `true` if this value represents the magnitude of a vector into the set of imaginary numbers.
`boolean`	`isISOControl()` Determine if this `char`-width or `int`-width character is an ISO control character within Unicode
`boolean`	`isJavaIdentifierPart()` Determine if this `char`-width or `int`-width character is a part of a Java identifier as other than the first character
`boolean`	`isJavaIdentifierStart()` Determine if this `char`-width or `int`-width character is permissible as the first character in a Java identifier
`boolean`	`isLess(boolean aScalar)`
`boolean`	`isLess(byte aScalar)`
`boolean`	`isLess(char aScalar)`
`boolean`	`isLess(double aScalar)`
`boolean`	`isLess(float aScalar)`
`boolean`	`isLess(int aScalar)`
`boolean`	`isLess(long aScalar)`
`boolean`	`isLess(short aScalar)`
`boolean`	`isLessOrEqual(boolean aScalar)`
`boolean`	`isLessOrEqual(byte aScalar)`
`boolean`	`isLessOrEqual(char aScalar)`
`boolean`	`isLessOrEqual(double aScalar)`
`boolean`	`isLessOrEqual(float aScalar)`
`boolean`	`isLessOrEqual(int aScalar)`
`boolean`	`isLessOrEqual(long aScalar)`
`boolean`	`isLessOrEqual(short aScalar)`
`boolean`	`isLessOrEqualToNumber(Number aNumber)`
`boolean`	`isLessOrEqualToScalar(SealedScalar<?> aScalar)`
`boolean`	`isLessThanNumber(Number aNumber)`
`boolean`	`isLessThanScalar(SealedScalar<?> aScalar)`
`boolean`	`isLetter()` Determine if this `char`-width or `int`-width character is a letter within Unicode
`boolean`	`isLetterOrDigit()` Determine if this `char`-width or `int`-width character is a letter or digit within Unicode
`boolean`	`isLowerCase()` Determine if this `char`-width or `int`-width character is a lower case character within Unicode
`boolean`	`isLowSurrogate()`
`boolean`	`isMirrored()` Determine if this `char`-width or `int`-width character is "mirrored" within Unicode
`boolean`	`isMutable()`
`boolean`	`isNegativeFinite()`
`boolean`	`isNotEqual(boolean aScalar)`
`boolean`	`isNotEqual(byte aScalar)`
`boolean`	`isNotEqual(char aScalar)`
`boolean`	`isNotEqual(double aScalar)`
`boolean`	`isNotEqual(float aScalar)`
`boolean`	`isNotEqual(int aScalar)`
`boolean`	`isNotEqual(long aScalar)`
`boolean`	`isNotEqual(short aScalar)`
`boolean`	`isNotEqualToNumber(Number aNumber)`
`boolean`	`isNotEqualToScalar(SealedScalar<?> aScalar)`
`boolean`	`isOrdered()` Answer `true` if the elements of this structure necessarily share a partial or total order between each other within the context of this structure.
`boolean`	`isPositiveFinite()`
`boolean`	`isReducible()` Answer `true` if this structure, in principle, can be reduced via element removal.
`boolean`	`isSupplementaryCodePoint()`
`boolean`	`isSurrogate()`
`boolean`	`isTitleCase()` Determine if this `char`-width or `int`-width character is a title case character within Unicode
`boolean`	`isTrue()`
`boolean`	`isUnicode()` Determine if this `char`-width or `int`-width character is defined within Unicode
`boolean`	`isUnicodeIdentifierPart()` Determine if this `char`-width or `int`-width character is a part of a Unicode identifier as other than the first character
`boolean`	`isUnicodeIdentifierStart()` Determine if this `char`-width or `int`-width character is permissible as the first character in a Unicode identifier
`boolean`	`isUnique()`
`boolean`	`isUpperCase()` Determine if this `char`-width or `int`-width character is an upper case character within Unicode
`boolean`	`isValid()`
`boolean`	`isValidCodePoint()`
`boolean`	`isWhitespace()` Determine if this `char`-width or `int`-width character is whitespace within Unicode
`static long`	`longGCD(long p0, long p1)`
`static long`	`longMaskAt(int aBitPosition)`
`static long`	`longModularInverse(long p0, long p1)`
`static long`	`longModularQuotient(long aDividend, long aDivisor, long aModulus)`
`static long`	`longNotMaskAt(int aBitPosition)`
`long`	`longSize()` Returns the number of elements in this algebraic structure as a `long` scalar.
`static long`	`longValue(boolean[] aBooleanArray)`
`SCALAR`	`milliseconds()` Set the value of this object to the current millisecond-precision system `time`
`SCALAR`	`mod(boolean aValue)` Set the value of this scalar to its current value modulo of the specified value
`SCALAR`	`mod(byte aValue)` Set the value of this scalar to its current value modulo of the specified value
`SCALAR`	`mod(char aValue)` Set the value of this scalar to its current value modulo of the specified value
`SCALAR`	`mod(double aValue)` Set the value of this scalar to its current value modulo of the specified value
`SCALAR`	`mod(float aValue)` Set the value of this scalar to its current value modulo of the specified value
`SCALAR`	`mod(int aValue)` Set the value of this scalar to its current value modulo of the specified value
`SCALAR`	`mod(long aValue)` Set the value of this scalar to its current value modulo of the specified value
`SCALAR`	`mod(short aValue)` Set the value of this scalar to its current value modulo of the specified value
`SCALAR`	`modOfNumber(Number aNumber)` Set the value of this scalar to its current value modulo of the specified value
`SCALAR`	`modOfScalar(SealedScalar<?> aValue)` Set the value of this scalar to its current value modulo of the specified value
`SCALAR`	`nanoseconds()` Set the value of this object to the current nanosecond-precision system `time`
`SCALAR`	`naturalLog()` Replace the current value with its base e (Napier's constant) logarithm (log_e(`n`))
`SCALAR`	`naturalLogPlusOne()` Replace the current value, plus 1, with its base e (Napier's constant) logarithm (log_e(`n`+1))
`SCALAR`	`or(boolean aValue)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`or(byte aValue)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`or(char aValue)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`or(int aValue)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`or(long aValue)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`or(short aValue)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`orOfNumber(Number aValue)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`orOfScalar(SealedScalar<?> aValue)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`power(double n)` Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
`SCALAR`	`power(int n)` Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
`SCALAR`	`powerOfNumber(Number aValue)` Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
`SCALAR`	`powerOfScalar(SealedScalar<?> aValue)` Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
`SCALAR`	`product(boolean aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`SCALAR`	`product(byte aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`SCALAR`	`product(char aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`SCALAR`	`product(double aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`SCALAR`	`product(float aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`SCALAR`	`product(int aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`SCALAR`	`product(long aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`SCALAR`	`product(short aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`SCALAR`	`productOfNumber(Number aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`SCALAR`	`productOfScalar(SealedScalar<?> aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`SCALAR`	`promoteTo(NumericPrecision prec)` If this object's implementation is less `precise` than the specified numeric precision, then convert this implementation to the closest available match for the proposed precision.
`SCALAR`	`quotient(boolean aValue)` Set the value of this scalar to the mathematical quotient between its current value and the specified value
`SCALAR`	`quotient(byte aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`SCALAR`	`quotient(char aValue)` Set the value of this scalar to the mathematical quotient between its current value and the specified value
`SCALAR`	`quotient(double aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`SCALAR`	`quotient(float aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`SCALAR`	`quotient(int aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`SCALAR`	`quotient(long aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`SCALAR`	`quotient(short aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`SCALAR`	`quotientOfNumber(Number aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`SCALAR`	`quotientOfScalar(SealedScalar<?> aValue)` Set the value of this scalar to the mathematical quotient between its current value and the specified value
`SCALAR`	`radians()` Replace the current value, assumed to be an angle in degrees, to its equivalent angle in radians
`SCALAR`	`random()` Replace the current value with an evenly-distributed `random` value between zero (inclusive) and unity (exclusive for floating point, inclusive for integrals)
`static byte`	`setByteBitAt(int anIndex, byte myValue)`
`static char`	`setCharBitAt(int anIndex, char myValue)`
`static double`	`setDoubleBitAt(int anIndex, double myValue)`
`SCALAR`	`setE()` Replace the current value with e, or Napier's constant
`<E extends Enum<E>> SCALAR`	`setEnumeration(E aValue)` Match the value of this object with the identity of the specified `enumeration` instance, then answer this object (facilitates chaining)
`SCALAR`	`setFalse()` Set this property to its equivalent of `true` and answer this object (facilitates chaining)
`static float`	`setFloatBitAt(int anIndex, float myValue)`
`static int`	`setIntBitAt(int anIndex, int myValue)`
`static long`	`setLongBitAt(int anIndex, long myValue)`
`SCALAR`	`setNegativeInfinity()` Replace the current value with a representation of negative infinity, if available, otherwise replace with the implementation's `minimum` value
`SCALAR`	`setNumber(Number aValue)` Set this object to the specified system-supported `Number` and answer this object (facilitates chaining)
`SCALAR`	`setPi()` Replace the current value with Pi
`SCALAR`	`setPositiveInfinity()` Replace the current value with a representation of positive infinity, if available, otherwise replace with the implementation's `maximum` value
`SCALAR`	`setScalar(SealedScalar<?> aValue)` Set this object to the specified scalar
`static short`	`setShortBitAt(int anIndex, short myValue)`
`SCALAR`	`setTrue()` Set this property to its equivalent of `true` and answer this object (facilitates chaining)
`SCALAR`	`setUnity()` Replace the current value with the multiplicative identity appropriate for the implementation (one)
`static BigDecimal`	`setUnlimitedDecimalBitAt(int anIndex, BigDecimal myValue)`
`static BigInteger`	`setUnlimitedIntegerBitAt(int anIndex, BigInteger myValue)`
`SCALAR`	`setZero()` Replace the current value with the additive identity appropriate for the implementation (zero)
`SCALAR`	`shiftRightExtendZero(int count)` Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions without sign extension.
`static short`	`shortMaskAt(int aBitPosition)`
`static short`	`shortNotMaskAt(int aBitPosition)`
`static short`	`shortValue(boolean[] aBooleanArray)`
`int`	`signum()`
`SCALAR`	`sine()` Replace the current value, assumed to be an angle in radians, to its `sine`
`int`	`size()` Returns the number of elements in this algebraic structure.
`SCALAR`	`squareRoot()` Replace the current value with the square root of itself
`SCALAR`	`sum(boolean aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`SCALAR`	`sum(byte aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`SCALAR`	`sum(char aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`SCALAR`	`sum(double aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`SCALAR`	`sum(float aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`SCALAR`	`sum(int aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`SCALAR`	`sum(long aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`SCALAR`	`sum(short aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`SCALAR`	`sumOfNumber(Number aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`SCALAR`	`sumOfScalar(SealedScalar<?> aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`SCALAR`	`tangent()` Replace the current value, assumed to be an angle in radians, to its `tangent`
`Boolean`	`toBoolean()`
`static boolean[]`	`toBooleanArray(BigDecimal aTuple)`
`static boolean[]`	`toBooleanArray(BigInteger aTuple)`
`static boolean[]`	`toBooleanArray(boolean aTuple)`
`static boolean[]`	`toBooleanArray(byte aTuple)`
`static boolean[]`	`toBooleanArray(char aTuple)`
`static boolean[]`	`toBooleanArray(CharSequence aTuple)`
`static boolean[]`	`toBooleanArray(double aTuple)`
`static boolean[]`	`toBooleanArray(float aTuple)`
`static boolean[]`	`toBooleanArray(int aTuple)`
`static boolean[]`	`toBooleanArray(long aTuple)`
`static boolean[]`	`toBooleanArray(short aTuple)`
`static byte[]`	`toByteArray(boolean[] aBooleanArray)`
`Character`	`toCharacter()`
`int`	`toCodePoint()` Represent the value of this object as a code point
`<E extends Enum<E>> E`	`toEnumeration(Class<E> anEnumerationClass)` Represent the value of this object as an appropriate member of the class of the specified `enumeration`
`Scalar<?>`	`toScalar()` If this scalar is already a `scalar` then simply call its `Replicator.copy()` function, otherwise produce a new scalar with scalar precision
`static BigInteger`	`toUnlimitedInteger(boolean[] aBooleanArray)`
`static BigInteger`	`unlimitedIntegerMaskAt(int aBitPosition)`
`static BigInteger`	`unlimitedIntegerNotMaskAt(int aBitPosition)`
`SCALAR`	`up()` Round away from zero
`SCALAR`	`xor(boolean aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`xor(byte aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`xor(char aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`xor(int aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`xor(long aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`xor(short aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`xorOfNumber(Number aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`SCALAR`	`xorOfScalar(SealedScalar<?> aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector

Methods inherited from class java.lang.Number
byteValue, doubleValue, floatValue, intValue, longValue, shortValue

Methods inherited from class java.lang.Object
clone, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface net.sf.jaccumulator.scalars.ScalarInductor
inducePostDecrement, inducePostIncrement, induceScalarValue

Methods inherited from interface net.sf.jaccumulator.scalars.SealedScalar
toNumber

Methods inherited from interface net.sf.jaccumulator.scalars.SealedScalarDomain
induceScalarMaximum, induceScalarMinimum

Methods inherited from interface net.sf.jaccumulator.SealedAlgebraicStructure
getStructureStrategy

Methods inherited from interface net.sf.jaccumulator.SealedKernel
getConcurrency, hashCode, toString

Methods inherited from interface net.sf.jaccumulator.scalars.NumericProperties
isInfinity, isInvalid, isMaximum, isMinimum, isModulo, isNegative, isNegativeInfinity, isPositive, isPositiveInfinity, isReal, isUnity, isZero

Methods inherited from interface net.sf.jaccumulator.scalars.ScalarReplicator
copyUsing, copyUsing, copyUsing, copyUsing, copyUsing, copyUsing, copyUsing, copyUsing, copyUsingScalar

Methods inherited from interface net.sf.jaccumulator.Replicator
copy

Methods inherited from interface net.sf.jaccumulator.scalars.MutableScalar
cube, decrement, increment, inverse, negate, not, round, setMaximum, setMinimum, shiftLeft, shiftRight, square

Methods inherited from interface net.sf.jaccumulator.MutableAlgebraicStructure
clear, clearContents

Methods inherited from interface net.sf.jaccumulator.booleans.SealedBooleanValue
booleanValue

Methods inherited from interface net.sf.jaccumulator.booleans.MutableBooleanValue
booleanPostDecrement, booleanPostIncrement, setScalar

Methods inherited from interface net.sf.jaccumulator.bytes.SealedByteValue
byteValue

Methods inherited from interface net.sf.jaccumulator.bytes.MutableByteValue
bytePostDecrement, bytePostIncrement, setScalar

Methods inherited from interface net.sf.jaccumulator.characters.SealedCharacterValue
charValue

Methods inherited from interface net.sf.jaccumulator.characters.MutableCharacterValue
charPostDecrement, charPostIncrement, setScalar

Methods inherited from interface net.sf.jaccumulator.doubles.SealedDoubleValue
doubleValue

Methods inherited from interface net.sf.jaccumulator.doubles.MutableDoubleValue
doublePostDecrement, doublePostIncrement, setScalar

Methods inherited from interface net.sf.jaccumulator.floats.SealedFloatValue
floatValue

Methods inherited from interface net.sf.jaccumulator.floats.MutableFloatValue
floatPostDecrement, floatPostIncrement, setScalar

Methods inherited from interface net.sf.jaccumulator.integers.SealedIntegerValue
intValue

Methods inherited from interface net.sf.jaccumulator.integers.MutableIntegerValue
intPostDecrement, intPostIncrement, setScalar

Methods inherited from interface net.sf.jaccumulator.longs.SealedLongValue
longValue

Methods inherited from interface net.sf.jaccumulator.longs.MutableLongValue
longPostDecrement, longPostIncrement, setScalar

Methods inherited from interface net.sf.jaccumulator.shorts.SealedShortValue
shortValue

Methods inherited from interface net.sf.jaccumulator.shorts.MutableShortValue
setScalar, shortPostDecrement, shortPostIncrement

- Field Detail
  - NaN
```
public static final Double NaN
```
  - ONEI
```
public static final Integer ONEI
```
  - ZERO_DOUBLE_LONG_BITS
```
public static final long ZERO_DOUBLE_LONG_BITS
```
  - ZERO_FLOAT_INT_BITS
```
public static final int ZERO_FLOAT_INT_BITS
```
  - ZEROI
```
public static final Integer ZEROI
```
- Constructor Detail
  - AbstractScalar
```
public AbstractScalar()
```
  - AbstractScalar
```
public AbstractScalar(Domain aDomain,
              NumericPrecision aPrecision)
```
- Method Detail
  - absoluteValue
```
public SCALAR absoluteValue()
                                            throws UnsupportedOperationException,
                                                   ArithmeticException,
                                                   IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the absolute value of itself
    
    Specified by:
    
    absoluteValue in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - and
```
public SCALAR and(boolean aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    and in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - and
```
public SCALAR and(byte aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    and in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - and
```
public SCALAR and(char aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    and in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - and
```
public SCALAR and(int aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    and in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - and
```
public SCALAR and(long aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    and in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - and
```
public SCALAR and(short aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    and in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - andOfNumber
```
public SCALAR andOfNumber(Number aValue)
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    andOfNumber in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - andOfScalar
```
public SCALAR andOfScalar(SealedScalar<?> aValue)
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    andOfScalar in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - angleWith
```
public SCALAR angleWith(double aValue)
                                        throws UnsupportedOperationException,
                                               IllegalArgumentException,
                                               ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the angle formed by the rectangular coordinates given by the current value, x, and the specified value, y. In other words returns the angle theta from the conversion of rectangular coordinates (x,y) to polar coordinates (r,theta).
    
    Specified by:
    
    angleWith in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a y coordinate value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    Math.atan2(double, double)
  - angleWithNumber
```
public final SCALAR angleWithNumber(Number y)
                                                    throws UnsupportedOperationException,
                                                           IllegalArgumentException,
                                                           ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the angle formed by the rectangular coordinates given by the current value, x, and the specified value, y. In other words returns the angle theta from the conversion of rectangular coordinates (x,y) to polar coordinates (r,theta).
    
    Specified by:
    
    angleWithNumber in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    y - a y coordinate value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    Math.atan2(double, double)
  - angleWithScalar
```
public final SCALAR angleWithScalar(SealedScalar<?> aValue)
                                                    throws UnsupportedOperationException,
                                                           IllegalArgumentException,
                                                           ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the angle formed by the rectangular coordinates given by the current value, x, and the specified value, y. In other words returns the angle theta from the conversion of rectangular coordinates (x,y) to polar coordinates (r,theta).
    
    Specified by:
    
    angleWithScalar in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a y coordinate value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    Math.atan2(double, double)
  - arcCosine
```
public SCALAR arcCosine()
                                        throws UnsupportedOperationException,
                                               IllegalArgumentException,
                                               ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with its arc cosine
    
    Specified by:
    
    arcCosine in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - arcSine
```
public SCALAR arcSine()
                                      throws UnsupportedOperationException,
                                             IllegalArgumentException,
                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with its arc sine
    
    Specified by:
    
    arcSine in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - arcTangent
```
public SCALAR arcTangent()
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with its arc tangent
    
    Specified by:
    
    arcTangent in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - assertDomain
```
public SCALAR assertDomain(Domain aDomain)
```
    Description copied from interface: MutableAlgebraicStructure
    
    Attempt to convert the implementation domain of this structure to the closest available match for the proposed domain. Note that the domain of this implementation may not change as a result of calling this function if an available internal conversion is not available.
    
    Specified by:
    
    assertDomain in interface MutableAlgebraicStructure<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aDomain - the proposed domain
    
    Returns:
    this object (facilitates operation chaining)
    See Also:
    StructureProperties.isConfigurable()
  - assertPrecision
```
public SCALAR assertPrecision(NumericPrecision prec)
```
    Description copied from interface: MutableScalarDomain
    
    Convert the numeric precision of this implementation to the closest available match for the proposed precision. Note that the precision of this implementation may not change as a result of calling this function if this structure is not configurable.
    
    Specified by:
    
    assertPrecision in interface MutableScalarDomain<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    prec - the proposed precision
    
    Returns:
    this object (facilitates operation chaining)
  - base10Log
```
public SCALAR base10Log()
                                        throws UnsupportedOperationException,
                                               IllegalArgumentException,
                                               ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with its base 10 logarithm
    
    Specified by:
    
    base10Log in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - ceiling
```
public final SCALAR ceiling()
                                            throws UnsupportedOperationException,
                                                   IllegalArgumentException,
                                                   ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the smallest (closest to negative infinity) value that is greater than or equal to the current value and is equal to a mathematical integer
    
    Specified by:
    
    ceiling in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - compareToNumber
```
public int compareToNumber(Number aValue)
```
    Description copied from interface: SealedScalar
    
    Compares this object with the specified object for order
    
    Specified by:
    
    compareToNumber in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an object to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified object.
    See Also:
    Comparable.compareTo(Object)
  - compareToScalar
```
public int compareToScalar(boolean aValue)
```
    Description copied from interface: SealedScalar
    
    Compares this object with the specified scalar for order
    
    Specified by:
    
    compareToScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a scalar to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified scalar.
    See Also:
    Comparable.compareTo(Object)
  - compareToScalar
```
public int compareToScalar(byte aValue)
```
    Description copied from interface: SealedScalar
    
    Compares this object with the specified scalar for order
    
    Specified by:
    
    compareToScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a scalar to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified scalar.
    See Also:
    Comparable.compareTo(Object)
  - compareToScalar
```
public int compareToScalar(char aValue)
```
    Description copied from interface: SealedScalar
    
    Compares this object with the specified scalar for order
    
    Specified by:
    
    compareToScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a scalar to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified scalar.
    See Also:
    Comparable.compareTo(Object)
  - compareToScalar
```
public int compareToScalar(double aValue)
```
    Description copied from interface: SealedScalar
    
    Compares this object with the specified scalar for order
    
    Specified by:
    
    compareToScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a scalar to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified scalar.
    See Also:
    Comparable.compareTo(Object)
  - compareToScalar
```
public int compareToScalar(float aValue)
```
    Description copied from interface: SealedScalar
    
    Compares this object with the specified scalar for order
    
    Specified by:
    
    compareToScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a scalar to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified scalar.
    See Also:
    Comparable.compareTo(Object)
  - compareToScalar
```
public int compareToScalar(int aValue)
```
    Description copied from interface: SealedScalar
    
    Compares this object with the specified scalar for order
    
    Specified by:
    
    compareToScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a scalar to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified scalar.
    See Also:
    Comparable.compareTo(Object)
  - compareToScalar
```
public int compareToScalar(long aValue)
```
    Description copied from interface: SealedScalar
    
    Compares this object with the specified scalar for order
    
    Specified by:
    
    compareToScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a scalar to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified scalar.
    See Also:
    Comparable.compareTo(Object)
  - compareToScalar
```
public int compareToScalar(SealedScalar<?> aValue)
```
    Description copied from interface: SealedScalar
    
    Compares this object with the specified object for order
    
    Specified by:
    
    compareToScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an object to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified object.
    See Also:
    Comparable.compareTo(Object)
  - compareToScalar
```
public int compareToScalar(short aValue)
```
    Description copied from interface: SealedScalar
    
    Compares this object with the specified scalar for order
    
    Specified by:
    
    compareToScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a scalar to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified scalar.
    See Also:
    Comparable.compareTo(Object)
  - compareToZero
```
public int compareToZero()
```
    Description copied from interface: SealedScalar
    
    Compares this object with zero for order
    
    Specified by:
    
    compareToZero in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than zero
    See Also:
    Comparable.compareTo(Object)
  - cosine
```
public SCALAR cosine()
                                     throws UnsupportedOperationException,
                                            IllegalArgumentException,
                                            ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value, assumed to be an angle in radians, to its cosine
    
    Specified by:
    
    cosine in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - cubeRoot
```
public SCALAR cubeRoot()
                                       throws UnsupportedOperationException,
                                              IllegalArgumentException,
                                              ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the cube root of itself
    
    Specified by:
    
    cubeRoot in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - degrees
```
public SCALAR degrees()
                                      throws UnsupportedOperationException,
                                             IllegalArgumentException,
                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value, assumed to be an angle in radians, to its equivalent angle in degrees
    
    Specified by:
    
    degrees in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
public SCALAR difference(boolean aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
public SCALAR difference(byte aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
public SCALAR difference(char aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
public SCALAR difference(double aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
public SCALAR difference(float aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
public SCALAR difference(int aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
public SCALAR difference(long aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
public SCALAR difference(short aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - differenceOfNumber
```
public SCALAR differenceOfNumber(Number aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    differenceOfNumber in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - differenceOfScalar
```
public SCALAR differenceOfScalar(SealedScalar<?> aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    differenceOfScalar in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - down
```
public final SCALAR down()
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Round the current value towards zero (truncate)
    
    Specified by:
    
    down in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - equals
```
public boolean equals(Object anObject)
```
    Specified by:
    
    equals in interface SealedKernel
    
    Overrides:
    
    equals in class Object
  - exponential
```
public SCALAR exponential()
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with e (Napier's constant) raised to the current value (eⁿ)
    
    Specified by:
    
    exponential in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    e (Wikipedia)
  - exponentialLessOne
```
public SCALAR exponentialLessOne()
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with e (Napier's constant) raised to the current value, less 1 (eⁿ-1)
    
    Specified by:
    
    exponentialLessOne in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    e (Wikipedia)
  - floor
```
public final SCALAR floor()
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the largest (closest to positive infinity) value that is less than or equal to the current value and is equal to a mathematical integer
    
    Specified by:
    
    floor in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - gcd
```
public SCALAR gcd(byte aValue)
                                  throws UnsupportedOperationException,
                                         ArithmeticException,
                                         IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the greatest common factor between this value and the specific one
    
    Specified by:
    
    gcd in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - gcd
```
public SCALAR gcd(char aValue)
                                  throws UnsupportedOperationException,
                                         ArithmeticException,
                                         IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the greatest common factor between this value and the specific one
    
    Specified by:
    
    gcd in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - gcd
```
public SCALAR gcd(int aValue)
                                  throws UnsupportedOperationException,
                                         ArithmeticException,
                                         IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the greatest common factor between this value and the specific one
    
    Specified by:
    
    gcd in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - gcd
```
public SCALAR gcd(long aValue)
                                  throws UnsupportedOperationException,
                                         ArithmeticException,
                                         IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the greatest common factor between this value and the specific one
    
    Specified by:
    
    gcd in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - gcd
```
public SCALAR gcd(short aValue)
                                  throws UnsupportedOperationException,
                                         ArithmeticException,
                                         IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the greatest common factor between this value and the specific one
    
    Specified by:
    
    gcd in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - gcdOfNumber
```
public SCALAR gcdOfNumber(Number aValue)
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the greatest common factor between this value and the specific one
    
    Specified by:
    
    gcdOfNumber in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - gcdOfScalar
```
public final SCALAR gcdOfScalar(Scalar<?> aScalar)
                                                throws UnsupportedOperationException,
                                                       ArithmeticException,
                                                       IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the greatest common factor between this value and the specific one
    
    Specified by:
    
    gcdOfScalar in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - getDomain
```
public Domain getDomain()
```
    Specified by:
    
    getDomain in interface SealedAlgebraicStructure
    
    Returns:
    the general semantic interpretation strategy of the configuration of elements in this structure
  - getPrecision
```
public NumericPrecision getPrecision()
```
    Specified by:
    
    getPrecision in interface SealedScalarDomain
    
    Returns:
    the relative size of the implementation's boolean bit tuple
  - halfDown
```
public final SCALAR halfDown()
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Round towards "nearest neighbor" unless both neighbors are equidistant, in which case round down
    
    Specified by:
    
    halfDown in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - halfEven
```
public final SCALAR halfEven()
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Round towards "nearest neighbor" unless both neighbors are equidistant, in which case round to the even neighbor
    
    Specified by:
    
    halfEven in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - halfUp
```
public final SCALAR halfUp()
                                           throws UnsupportedOperationException,
                                                  IllegalArgumentException,
                                                  ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Round towards "nearest neighbor" unless both neighbors are equidistant, in which case round up
    
    Specified by:
    
    halfUp in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - hyperbolicCosine
```
public SCALAR hyperbolicCosine()
                                               throws UnsupportedOperationException,
                                                      IllegalArgumentException,
                                                      ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value, assumed to be an angle in radians, to its hyperbolic cosine
    
    Specified by:
    
    hyperbolicCosine in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - hyperbolicSine
```
public SCALAR hyperbolicSine()
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value, assumed to be an angle in radians, to its hyperbolic sine
    
    Specified by:
    
    hyperbolicSine in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - hyperbolicTangent
```
public SCALAR hyperbolicTangent()
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value, assumed to be an angle in radians, to its hyperbolic tangent
    
    Specified by:
    
    hyperbolicTangent in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - hypotenuseWith
```
public final SCALAR hypotenuseWith(double aValue)
                                                   throws UnsupportedOperationException,
                                                          IllegalArgumentException,
                                                          ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the hypotenuse formed by the square root of the sum of the square of the current value, x, and the square of the specified value, y, without intermediate overflow or underflow
    
    Specified by:
    
    hypotenuseWith in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a y value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    Math.hypot(double, double)
  - hypotenuseWithNumber
```
public final SCALAR hypotenuseWithNumber(Number aValue)
                                                         throws UnsupportedOperationException,
                                                                IllegalArgumentException,
                                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the hypotenuse formed by the square root of the sum of the square of the current value, x, and the square of the specified value, y, without intermediate overflow or underflow
    
    Specified by:
    
    hypotenuseWithNumber in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a y value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    Math.hypot(double, double)
  - hypotenuseWithScalar
```
public final SCALAR hypotenuseWithScalar(SealedScalar<?> aValue)
                                                         throws UnsupportedOperationException,
                                                                IllegalArgumentException,
                                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the hypotenuse formed by the square root of the sum of the square of the current value, x, and the square of the specified value, y, without intermediate overflow or underflow
    
    Specified by:
    
    hypotenuseWithScalar in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a y value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    Math.hypot(double, double)
  - induceScalarSize
```
public <S extends Scalar<?>> S induceScalarSize(S aTarget)
                                  throws NullPointerException,
                                         NoSuchElementException,
                                         UnsupportedOperationException,
                                         IllegalStateException
```
    Description copied from interface: SealedScalarBag
    
    Update the target scalar with the element count in this structure
    
    Specified by:
    
    induceScalarSize in interface SealedScalarBag
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - the target to update
    
    Returns:
    the target scalar (facilitates operation chaining)
    
    Throws:
    
    NullPointerException - a null value was provided when none was expected
    
    NoSuchElementException - an expected parameter was not found in the parameter source
    
    UnsupportedOperationException - this target cannot be changed
    
    IllegalStateException - this target cannot be changed at this time
  - invalidate
```
public SCALAR invalidate()
                                         throws UnsupportedOperationException,
                                                ArithmeticException,
                                                IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value an invalid value such INVALID if possible, otherwise replace it with zero
    
    Specified by:
    
    invalidate in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - isAlphabetic
```
public boolean isAlphabetic()
```
    Specified by:
    
    isAlphabetic in interface CharacterProperties
    
    Returns:
    true if the int value of this object is a proper alphabetical value in Unicode
    See Also:
    Character.isAlphabetic(int)
  - isBmpCodePoint
```
public boolean isBmpCodePoint()
```
    Specified by:
    
    isBmpCodePoint in interface CharacterProperties
    
    Returns:
    true if the int value of this object is a BMP (Basic Multi-lingual Plane) code point in Unicode
    See Also:
    Character.isBmpCodePoint(int)
  - isConfigurable
```
public boolean isConfigurable()
```
    Description copied from interface: StructureProperties
    
    Answer true if the implementation of this object can be changed.
    
    A configurable object has a structure that can be expanded, or reduced, or has replaceable components. Configurable structures are necessarily mutable; in fact, "configurability" can be used as a strict definition of mutability. This predicate however overrides #isMutable in the respect that, for some types of objects such as Variants, mutability can be changed by switching from a non-mutable implementation to a mutable one (e.g., via assertPrecision).
    
    Specified by:
    
    isConfigurable in interface StructureProperties
    
    Returns:
    true if the implementation of this object can be changed
  - isCountable
```
public boolean isCountable()
```
    Description copied from interface: StructureProperties
    
    Answer true if this structure contains a countable number of elements. A countable set is a set with the same cardinality as some subset of the set of natural numbers. A set that is not countable contains an infinite number of elements.
    
    Specified by:
    
    isCountable in interface StructureProperties
    
    Returns:
    true if this structure contains a countable number of elements, otherwise false if it contains an infinite number of elements
    See Also:
    Countable set (Wikipedia)
  - isDigit
```
public boolean isDigit()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a digit within Unicode
    
    Specified by:
    
    isDigit in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a digit in Unicode
    See Also:
    Character.isDigit(char), Character.isDigit(int)
  - isElastic
```
public boolean isElastic()
```
    Description copied from interface: StructureProperties
    
    Answer true if this structure, in principle, can be reduced via element removal or expanded via element addition. Empty collections are, in principle, reducible, but read-only collections are neither reducible or expandable.
    
    Specified by:
    
    isElastic in interface StructureProperties
    
    Returns:
    true if this structure can be either reduced or expanded
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: StructureProperties
    
    Answer true if this structure contains no elements. For strings this would indicate an empty string (no characters in an empty array). For scalars this would indicate an empty set, or a zero bit count, which would be the case of null values. Note that, although the null constant technically contains zero elements, its string value evaluates to "null", which from a String perspective is not empty.
    
    Specified by:
    
    isEmpty in interface StructureProperties
    
    Returns:
    true if this structure contains no elements
  - isEqual
```
public boolean isEqual(boolean aScalar)
```
    Specified by:
    
    isEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isEqual
```
public boolean isEqual(byte aScalar)
```
    Specified by:
    
    isEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isEqual
```
public boolean isEqual(char aScalar)
```
    Specified by:
    
    isEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isEqual
```
public boolean isEqual(double aScalar)
```
    Specified by:
    
    isEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isEqual
```
public boolean isEqual(float aScalar)
```
    Specified by:
    
    isEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isEqual
```
public boolean isEqual(int aScalar)
```
    Specified by:
    
    isEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isEqual
```
public boolean isEqual(long aScalar)
```
    Specified by:
    
    isEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isEqual
```
public boolean isEqual(short aScalar)
```
    Specified by:
    
    isEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isEqualToNumber
```
public boolean isEqualToNumber(Number aNumber)
```
    Specified by:
    
    isEqualToNumber in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isEqualToScalar
```
public boolean isEqualToScalar(SealedScalar<?> aScalar)
```
    Specified by:
    
    isEqualToScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isExpandable
```
public boolean isExpandable()
```
    Specified by:
    
    isExpandable in interface StructureProperties
    
    Returns:
    true if this structure can be expanded via element insertion
  - isFalse
```
public final boolean isFalse()
```
    Specified by:
    
    isFalse in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object represents a false value if boolean, or the additive identity otherwise
  - isFinite
```
public boolean isFinite()
```
    Specified by:
    
    isFinite in interface NumericProperties
    
    Returns:
    true if this value represents a valid and finite value
  - isGreater
```
public boolean isGreater(boolean aScalar)
```
    Specified by:
    
    isGreater in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreater
```
public boolean isGreater(byte aScalar)
```
    Specified by:
    
    isGreater in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreater
```
public boolean isGreater(char aScalar)
```
    Specified by:
    
    isGreater in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreater
```
public boolean isGreater(double aScalar)
```
    Specified by:
    
    isGreater in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreater
```
public boolean isGreater(float aScalar)
```
    Specified by:
    
    isGreater in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreater
```
public boolean isGreater(int aScalar)
```
    Specified by:
    
    isGreater in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreater
```
public boolean isGreater(long aScalar)
```
    Specified by:
    
    isGreater in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreater
```
public boolean isGreater(short aScalar)
```
    Specified by:
    
    isGreater in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreaterOrEqual
```
public boolean isGreaterOrEqual(boolean aScalar)
```
    Specified by:
    
    isGreaterOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreaterOrEqual
```
public boolean isGreaterOrEqual(byte aScalar)
```
    Specified by:
    
    isGreaterOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreaterOrEqual
```
public boolean isGreaterOrEqual(char aScalar)
```
    Specified by:
    
    isGreaterOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreaterOrEqual
```
public boolean isGreaterOrEqual(double aScalar)
```
    Specified by:
    
    isGreaterOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreaterOrEqual
```
public boolean isGreaterOrEqual(float aScalar)
```
    Specified by:
    
    isGreaterOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreaterOrEqual
```
public boolean isGreaterOrEqual(int aScalar)
```
    Specified by:
    
    isGreaterOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreaterOrEqual
```
public boolean isGreaterOrEqual(long aScalar)
```
    Specified by:
    
    isGreaterOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreaterOrEqual
```
public boolean isGreaterOrEqual(short aScalar)
```
    Specified by:
    
    isGreaterOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreaterOrEqualToNumber
```
public boolean isGreaterOrEqualToNumber(Number aNumber)
```
    Specified by:
    
    isGreaterOrEqualToNumber in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreaterOrEqualToScalar
```
public boolean isGreaterOrEqualToScalar(SealedScalar<?> aScalar)
```
    Specified by:
    
    isGreaterOrEqualToScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreaterThanNumber
```
public boolean isGreaterThanNumber(Number aNumber)
```
    Specified by:
    
    isGreaterThanNumber in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isGreaterThanScalar
```
public boolean isGreaterThanScalar(SealedScalar<?> aScalar)
```
    Specified by:
    
    isGreaterThanScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isHighSurrogate
```
public boolean isHighSurrogate()
```
    Specified by:
    
    isHighSurrogate in interface CharacterProperties
    
    Returns:
    true if the char value of this object is a high surrogate in UTF-16 Unicode encoding
    See Also:
    Character.isHighSurrogate(char)
  - isIdentifierIgnorable
```
public boolean isIdentifierIgnorable()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character ignorable character in a Java identifier or a Unicode identifier
    
    Specified by:
    
    isIdentifierIgnorable in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, ignorable character in a Java identifier or a Unicode identifier as other than the first character
    See Also:
    Character.isIdentifierIgnorable(char), Character.isIdentifierIgnorable(int)
  - isIdeographic
```
public boolean isIdeographic()
```
    Specified by:
    
    isIdeographic in interface CharacterProperties
    
    Returns:
    true if the int value of this object is a Unicode ideographic symbol
    See Also:
    Character.isIdeographic(int)
  - isImaginary
```
public boolean isImaginary()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the magnitude of a vector into the set of imaginary numbers. This is not the same as testing whether this object's implementation resembles the specification for the IMAGINARY domain, since that is too specific to implementation machinery. This more general test also includes imaginary modulo values in its specification.
    
    Specified by:
    
    isImaginary in interface NumericProperties
    
    Returns:
    true if this value represents the magnitude of a vector into the set of imaginary numbers
  - isISOControl
```
public boolean isISOControl()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is an ISO control character within Unicode
    
    Specified by:
    
    isISOControl in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is an ISO control character in Unicode
    See Also:
    Character.isISOControl(char), Character.isISOControl(int)
  - isJavaIdentifierPart
```
public boolean isJavaIdentifierPart()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a part of a Java identifier as other than the first character
    
    Specified by:
    
    isJavaIdentifierPart in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a part of a Java identifier as other than the first character
    See Also:
    Character.isJavaIdentifierPart(char), Character.isJavaIdentifierPart(int)
  - isJavaIdentifierStart
```
public boolean isJavaIdentifierStart()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is permissible as the first character in a Java identifier
    
    Specified by:
    
    isJavaIdentifierStart in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is permissible as the first character in a Java identifier
    See Also:
    Character.isJavaIdentifierStart(char), Character.isJavaIdentifierStart(int)
  - isLess
```
public boolean isLess(boolean aScalar)
```
    Specified by:
    
    isLess in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLess
```
public boolean isLess(byte aScalar)
```
    Specified by:
    
    isLess in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLess
```
public boolean isLess(char aScalar)
```
    Specified by:
    
    isLess in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLess
```
public boolean isLess(double aScalar)
```
    Specified by:
    
    isLess in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLess
```
public boolean isLess(float aScalar)
```
    Specified by:
    
    isLess in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLess
```
public boolean isLess(int aScalar)
```
    Specified by:
    
    isLess in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLess
```
public boolean isLess(long aScalar)
```
    Specified by:
    
    isLess in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLess
```
public boolean isLess(short aScalar)
```
    Specified by:
    
    isLess in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLessOrEqual
```
public boolean isLessOrEqual(boolean aScalar)
```
    Specified by:
    
    isLessOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLessOrEqual
```
public boolean isLessOrEqual(byte aScalar)
```
    Specified by:
    
    isLessOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLessOrEqual
```
public boolean isLessOrEqual(char aScalar)
```
    Specified by:
    
    isLessOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLessOrEqual
```
public boolean isLessOrEqual(double aScalar)
```
    Specified by:
    
    isLessOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLessOrEqual
```
public boolean isLessOrEqual(float aScalar)
```
    Specified by:
    
    isLessOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLessOrEqual
```
public boolean isLessOrEqual(int aScalar)
```
    Specified by:
    
    isLessOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLessOrEqual
```
public boolean isLessOrEqual(long aScalar)
```
    Specified by:
    
    isLessOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLessOrEqual
```
public boolean isLessOrEqual(short aScalar)
```
    Specified by:
    
    isLessOrEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLessOrEqualToNumber
```
public boolean isLessOrEqualToNumber(Number aNumber)
```
    Specified by:
    
    isLessOrEqualToNumber in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLessOrEqualToScalar
```
public boolean isLessOrEqualToScalar(SealedScalar<?> aScalar)
```
    Specified by:
    
    isLessOrEqualToScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLessThanNumber
```
public boolean isLessThanNumber(Number aNumber)
```
    Specified by:
    
    isLessThanNumber in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLessThanScalar
```
public boolean isLessThanScalar(SealedScalar<?> aScalar)
```
    Specified by:
    
    isLessThanScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isLetter
```
public boolean isLetter()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a letter within Unicode
    
    Specified by:
    
    isLetter in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a letter in Unicode
    See Also:
    Character.isLetter(char), Character.isLetter(int)
  - isLetterOrDigit
```
public boolean isLetterOrDigit()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a letter or digit within Unicode
    
    Specified by:
    
    isLetterOrDigit in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a letter or digit in Unicode
    See Also:
    Character.isLetterOrDigit(char), Character.isLetterOrDigit(int)
  - isLowerCase
```
public boolean isLowerCase()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a lower case character within Unicode
    
    Specified by:
    
    isLowerCase in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a lower case character in Unicode
    See Also:
    Character.isLowerCase(char), Character.isLowerCase(int)
  - isLowSurrogate
```
public boolean isLowSurrogate()
```
    Specified by:
    
    isLowSurrogate in interface CharacterProperties
    
    Returns:
    true if the char value of this object is a low surrogate in UTF-16 Unicode encoding
    See Also:
    Character.isLowSurrogate(char)
  - isMirrored
```
public boolean isMirrored()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is "mirrored" within Unicode
    
    Specified by:
    
    isMirrored in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is "mirrored" in Unicode
    See Also:
    Character.isMirrored(char), Character.isMirrored(int)
  - isMutable
```
public boolean isMutable()
```
    Specified by:
    
    isMutable in interface Mutable
    
    Returns:
    true if modification of the implementation is allowed and that none of the modification functions will, in principle, throw UnsupportedOperationExceptions
  - isNegativeFinite
```
public boolean isNegativeFinite()
```
    Specified by:
    
    isNegativeFinite in interface NumericProperties
    
    Returns:
    true if this value represents a valid, finite and negative value
  - isNotEqual
```
public boolean isNotEqual(boolean aScalar)
```
    Specified by:
    
    isNotEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isNotEqual
```
public boolean isNotEqual(byte aScalar)
```
    Specified by:
    
    isNotEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isNotEqual
```
public boolean isNotEqual(char aScalar)
```
    Specified by:
    
    isNotEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isNotEqual
```
public boolean isNotEqual(double aScalar)
```
    Specified by:
    
    isNotEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isNotEqual
```
public boolean isNotEqual(float aScalar)
```
    Specified by:
    
    isNotEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isNotEqual
```
public boolean isNotEqual(int aScalar)
```
    Specified by:
    
    isNotEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isNotEqual
```
public boolean isNotEqual(long aScalar)
```
    Specified by:
    
    isNotEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isNotEqual
```
public boolean isNotEqual(short aScalar)
```
    Specified by:
    
    isNotEqual in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isNotEqualToNumber
```
public boolean isNotEqualToNumber(Number aNumber)
```
    Specified by:
    
    isNotEqualToNumber in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isNotEqualToScalar
```
public boolean isNotEqualToScalar(SealedScalar<?> aScalar)
```
    Specified by:
    
    isNotEqualToScalar in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
  - isOrdered
```
public boolean isOrdered()
```
    Description copied from interface: StructureProperties
    
    Answer true if the elements of this structure necessarily share a partial or total order between each other within the context of this structure. Ordering does not necessarily imply a simple sequencing between randomly selected elements, but rather a necessary sorting order between elements independent of the sets they are related by. A SortedSet is ordered, not merely because its elements are de facto sorted, but because the SortedSet defines a universe in which only sortable elements can exist and it defines a sorting function which places those elements in their sorted order at the time of iteration. An ordered set has elements with values that are reflexive, antisymmetric, and transitive relative to each other. Necessarily empty sets are not considered ordered.
    
    Specified by:
    
    isOrdered in interface StructureProperties
    
    Returns:
    true if the structure has either a partial or total order over its elements
    See Also:
    order theory (Wikipedia)
  - isPositiveFinite
```
public boolean isPositiveFinite()
```
    Specified by:
    
    isPositiveFinite in interface NumericProperties
    
    Returns:
    true if this value represents a valid, finite and negative value
  - isReducible
```
public boolean isReducible()
```
    Description copied from interface: StructureProperties
    
    Answer true if this structure, in principle, can be reduced via element removal. Empty collections are, in principle, reducible, but read-only collections are not.
    
    Specified by:
    
    isReducible in interface StructureProperties
    
    Returns:
    true if this structure, in principle, can be reduced via element removal
  - isSupplementaryCodePoint
```
public boolean isSupplementaryCodePoint()
```
    Specified by:
    
    isSupplementaryCodePoint in interface CharacterProperties
    
    Returns:
    true if the int value of this object is a supplementary code point in Unicode
    See Also:
    Character.isSupplementaryCodePoint(int)
  - isSurrogate
```
public boolean isSurrogate()
```
    Specified by:
    
    isSurrogate in interface CharacterProperties
    
    Returns:
    true if the char value of this object is a surrogate value (high or low) in Unicode
    See Also:
    Character.isSurrogate(char)
  - isTitleCase
```
public boolean isTitleCase()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a title case character within Unicode
    
    Specified by:
    
    isTitleCase in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a title case character in Unicode
    See Also:
    Character.isTitleCase(char), Character.isTitleCase(int)
  - isTrue
```
public final boolean isTrue()
```
    Specified by:
    
    isTrue in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object represents a true value if boolean, or the multiplicative identity otherwise
  - isUnicode
```
public boolean isUnicode()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is defined within Unicode
    
    Specified by:
    
    isUnicode in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is defined in Unicode
    See Also:
    Character.isDefined(char), Character.isDefined(int)
  - isUnicodeIdentifierPart
```
public boolean isUnicodeIdentifierPart()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a part of a Unicode identifier as other than the first character
    
    Specified by:
    
    isUnicodeIdentifierPart in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a part of a Unicode identifier as other than the first character
    See Also:
    Character.isUnicodeIdentifierPart(char), Character.isUnicodeIdentifierPart(int)
  - isUnicodeIdentifierStart
```
public boolean isUnicodeIdentifierStart()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is permissible as the first character in a Unicode identifier
    
    Specified by:
    
    isUnicodeIdentifierStart in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is permissible as the first character in a Unicode identifier
    See Also:
    Character.isUnicodeIdentifierStart(char), Character.isUnicodeIdentifierStart(int)
  - isUnique
```
public boolean isUnique()
```
    Specified by:
    
    isUnique in interface StructureProperties
    
    Returns:
    true if the elements in this structure are, by definition of the structure's algebra, unique (e.g., sets)
  - isUpperCase
```
public boolean isUpperCase()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is an upper case character within Unicode
    
    Specified by:
    
    isUpperCase in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is an upper case character in Unicode
    See Also:
    Character.isUpperCase(char), Character.isUpperCase(int)
  - isValid
```
public final boolean isValid()
```
    Specified by:
    
    isValid in interface NumericProperties
    
    Returns:
    true if this value represents a valid number (not INVALID)
    See Also:
    INVALID at Wikipedia
  - isValidCodePoint
```
public boolean isValidCodePoint()
```
    Specified by:
    
    isValidCodePoint in interface CharacterProperties
    
    Returns:
    true if the int value of this object is a valid code point in Unicode
    See Also:
    Character.isValidCodePoint(int)
  - isWhitespace
```
public boolean isWhitespace()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is whitespace within Unicode
    
    Specified by:
    
    isWhitespace in interface CharacterProperties
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is whitespace in Unicode
    See Also:
    Character.isWhitespace(char), Character.isWhitespace(int)
  - longSize
```
public long longSize()
```
    Description copied from interface: SealedAlgebraicStructure
    
    Returns the number of elements in this algebraic structure as a long scalar. If the structure contains more than Long.MAX_VALUE elements, returns Long.MAX_VALUE.
    
    Specified by:
    
    longSize in interface SealedAlgebraicStructure
    
    Returns:
    the number of elements in this algebraic structure as a long scalar
    See Also:
    Collection.size(), SealedAlgebraicStructure.size()
  - milliseconds
```
public SCALAR milliseconds()
                                           throws UnsupportedOperationException
```
    Description copied from interface: MutableScalar
    
    Set the value of this object to the current millisecond-precision system time
    
    Specified by:
    
    milliseconds in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
  - mod
```
public SCALAR mod(boolean aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to its current value modulo of the specified value
    
    Specified by:
    
    mod in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
public SCALAR mod(byte aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to its current value modulo of the specified value
    
    Specified by:
    
    mod in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
public SCALAR mod(char aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to its current value modulo of the specified value
    
    Specified by:
    
    mod in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
public SCALAR mod(double aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to its current value modulo of the specified value
    
    Specified by:
    
    mod in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
public SCALAR mod(float aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to its current value modulo of the specified value
    
    Specified by:
    
    mod in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
public SCALAR mod(int aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to its current value modulo of the specified value
    
    Specified by:
    
    mod in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
public SCALAR mod(long aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to its current value modulo of the specified value
    
    Specified by:
    
    mod in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
public SCALAR mod(short aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to its current value modulo of the specified value
    
    Specified by:
    
    mod in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - modOfNumber
```
public SCALAR modOfNumber(Number aNumber)
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to its current value modulo of the specified value
    
    Specified by:
    
    modOfNumber in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aNumber - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - modOfScalar
```
public SCALAR modOfScalar(SealedScalar<?> aValue)
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to its current value modulo of the specified value
    
    Specified by:
    
    modOfScalar in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - nanoseconds
```
public SCALAR nanoseconds()
                                          throws UnsupportedOperationException
```
    Description copied from interface: MutableScalar
    
    Set the value of this object to the current nanosecond-precision system time
    
    Specified by:
    
    nanoseconds in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
  - naturalLog
```
public SCALAR naturalLog()
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with its base e (Napier's constant) logarithm (log_e(n))
    
    Specified by:
    
    naturalLog in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    e (Wikipedia)
  - naturalLogPlusOne
```
public SCALAR naturalLogPlusOne()
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value, plus 1, with its base e (Napier's constant) logarithm (log_e(n+1))
    
    Specified by:
    
    naturalLogPlusOne in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    e (Wikipedia)
  - or
```
public SCALAR or(boolean aValue)
                                 throws UnsupportedOperationException,
                                        IllegalArgumentException,
                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    or in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - or
```
public SCALAR or(byte aValue)
                                 throws UnsupportedOperationException,
                                        IllegalArgumentException,
                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    or in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - or
```
public SCALAR or(char aValue)
                                 throws UnsupportedOperationException,
                                        IllegalArgumentException,
                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    or in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - or
```
public SCALAR or(int aValue)
                                 throws UnsupportedOperationException,
                                        IllegalArgumentException,
                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    or in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - or
```
public SCALAR or(long aValue)
                                 throws UnsupportedOperationException,
                                        IllegalArgumentException,
                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    or in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - or
```
public SCALAR or(short aValue)
                                 throws UnsupportedOperationException,
                                        IllegalArgumentException,
                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    or in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - orOfNumber
```
public SCALAR orOfNumber(Number aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    orOfNumber in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - orOfScalar
```
public final SCALAR orOfScalar(SealedScalar<?> aValue)
                                               throws UnsupportedOperationException,
                                                      IllegalArgumentException,
                                                      ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    orOfScalar in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - power
```
public SCALAR power(double n)
                                    throws UnsupportedOperationException,
                                           IllegalArgumentException,
                                           ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
    
    Specified by:
    
    power in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    n - an exponent
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - power
```
public SCALAR power(int n)
                                    throws UnsupportedOperationException,
                                           IllegalArgumentException,
                                           ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
    
    Specified by:
    
    power in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    n - an exponent
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - powerOfNumber
```
public final SCALAR powerOfNumber(Number aValue)
                                                  throws UnsupportedOperationException,
                                                         IllegalArgumentException,
                                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
    
    Specified by:
    
    powerOfNumber in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an exponent
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - powerOfScalar
```
public SCALAR powerOfScalar(SealedScalar<?> aValue)
                                            throws UnsupportedOperationException,
                                                   IllegalArgumentException,
                                                   ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
    
    Specified by:
    
    powerOfScalar in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an exponent
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
public SCALAR product(boolean aValue)
                                      throws UnsupportedOperationException,
                                             IllegalArgumentException,
                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
public SCALAR product(byte aValue)
                                      throws UnsupportedOperationException,
                                             IllegalArgumentException,
                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
public SCALAR product(char aValue)
                                      throws UnsupportedOperationException,
                                             IllegalArgumentException,
                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
public SCALAR product(double aValue)
                                      throws UnsupportedOperationException,
                                             IllegalArgumentException,
                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
public SCALAR product(float aValue)
                                      throws UnsupportedOperationException,
                                             IllegalArgumentException,
                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
public SCALAR product(int aValue)
                                      throws UnsupportedOperationException,
                                             IllegalArgumentException,
                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
public SCALAR product(long aValue)
                                      throws UnsupportedOperationException,
                                             IllegalArgumentException,
                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
public SCALAR product(short aValue)
                                      throws UnsupportedOperationException,
                                             IllegalArgumentException,
                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - productOfNumber
```
public SCALAR productOfNumber(Number aValue)
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    productOfNumber in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - productOfScalar
```
public SCALAR productOfScalar(SealedScalar<?> aValue)
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    productOfScalar in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - promoteTo
```
public SCALAR promoteTo(NumericPrecision prec)
```
    Description copied from interface: MutableScalarDomain
    
    If this object's implementation is less precise than the specified numeric precision, then convert this implementation to the closest available match for the proposed precision. Note that the precision of this implementation may not change as a result of calling this function if the proposed precision is less precise than the this object's current precision level or if this structure is not {@link StructureProperties#isConfigurable() configurable).
    
    Specified by:
    
    promoteTo in interface MutableScalarDomain<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    prec - the proposed precision
    
    Returns:
    this object (facilitates operation chaining)
    See Also:
    StructureProperties.isConfigurable()
  - quotient
```
public SCALAR quotient(boolean aValue)
                                       throws UnsupportedOperationException,
                                              IllegalArgumentException,
                                              ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient between its current value and the specified value
    
    Specified by:
    
    quotient in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
public SCALAR quotient(byte aValue)
                                       throws UnsupportedOperationException,
                                              IllegalArgumentException,
                                              ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Specified by:
    
    quotient in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
public SCALAR quotient(char aValue)
                                       throws UnsupportedOperationException,
                                              IllegalArgumentException,
                                              ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient between its current value and the specified value
    
    Specified by:
    
    quotient in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
public SCALAR quotient(double aValue)
                                       throws UnsupportedOperationException,
                                              IllegalArgumentException,
                                              ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Specified by:
    
    quotient in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
public SCALAR quotient(float aValue)
                                       throws UnsupportedOperationException,
                                              IllegalArgumentException,
                                              ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Specified by:
    
    quotient in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
public SCALAR quotient(int aValue)
                                       throws UnsupportedOperationException,
                                              IllegalArgumentException,
                                              ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Specified by:
    
    quotient in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
public SCALAR quotient(long aValue)
                                       throws UnsupportedOperationException,
                                              IllegalArgumentException,
                                              ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Specified by:
    
    quotient in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
public SCALAR quotient(short aValue)
                                       throws UnsupportedOperationException,
                                              IllegalArgumentException,
                                              ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Specified by:
    
    quotient in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotientOfNumber
```
public SCALAR quotientOfNumber(Number aValue)
                                               throws UnsupportedOperationException,
                                                      IllegalArgumentException,
                                                      ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Specified by:
    
    quotientOfNumber in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotientOfScalar
```
public SCALAR quotientOfScalar(SealedScalar<?> aValue)
                                               throws UnsupportedOperationException,
                                                      IllegalArgumentException,
                                                      ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient between its current value and the specified value
    
    Specified by:
    
    quotientOfScalar in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - radians
```
public SCALAR radians()
                                      throws UnsupportedOperationException,
                                             IllegalArgumentException,
                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value, assumed to be an angle in degrees, to its equivalent angle in radians
    
    Specified by:
    
    radians in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - random
```
public SCALAR random()
                                     throws UnsupportedOperationException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with an evenly-distributed random value between zero (inclusive) and unity (exclusive for floating point, inclusive for integrals)
    
    Specified by:
    
    random in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
  - setE
```
public SCALAR setE()
                                   throws UnsupportedOperationException,
                                          IllegalArgumentException,
                                          ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with e, or Napier's constant
    
    Specified by:
    
    setE in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    e (Wikipedia)
  - setEnumeration
```
public <E extends Enum<E>> SCALAR setEnumeration(E aValue)
                                             throws UnsupportedOperationException,
                                                    ArithmeticException,
                                                    IllegalArgumentException,
                                                    NullPointerException
```
    Description copied from interface: MutableScalar
    
    Match the value of this object with the identity of the specified enumeration instance, then answer this object (facilitates chaining)
    
    Specified by:
    
    setEnumeration in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a system-supported enumeration
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setFalse
```
public SCALAR setFalse()
                                       throws UnsupportedOperationException,
                                              ArithmeticException
```
    Description copied from interface: MutableBooleanValue
    
    Set this property to its equivalent of true and answer this object (facilitates chaining)
    
    Specified by:
    
    setFalse in interface MutableBooleanValue<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new value was incompatible with with algebraic interpretation of this object
  - setNegativeInfinity
```
public SCALAR setNegativeInfinity()
                                                  throws UnsupportedOperationException,
                                                         ArithmeticException,
                                                         IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with a representation of negative infinity, if available, otherwise replace with the implementation's minimum value
    
    Specified by:
    
    setNegativeInfinity in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - setNumber
```
public SCALAR setNumber(Number aValue)
                                        throws UnsupportedOperationException,
                                               IllegalArgumentException,
                                               ArithmeticException,
                                               NullPointerException
```
    Description copied from interface: MutableScalar
    
    Set this object to the specified system-supported Number and answer this object (facilitates chaining)
    
    Specified by:
    
    setNumber in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a system-supported Number
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setPi
```
public SCALAR setPi()
                                    throws UnsupportedOperationException,
                                           IllegalArgumentException,
                                           ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with Pi
    
    Specified by:
    
    setPi in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - setPositiveInfinity
```
public SCALAR setPositiveInfinity()
                                                  throws UnsupportedOperationException,
                                                         ArithmeticException,
                                                         IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with a representation of positive infinity, if available, otherwise replace with the implementation's maximum value
    
    Specified by:
    
    setPositiveInfinity in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - setScalar
```
public SCALAR setScalar(SealedScalar<?> aValue)
                                        throws UnsupportedOperationException,
                                               IllegalArgumentException,
                                               ArithmeticException,
                                               NullPointerException
```
    Description copied from interface: MutableScalar
    
    Set this object to the specified scalar
    
    Specified by:
    
    setScalar in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - a scalar
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setTrue
```
public SCALAR setTrue()
                                      throws UnsupportedOperationException,
                                             ArithmeticException
```
    Description copied from interface: MutableBooleanValue
    
    Set this property to its equivalent of true and answer this object (facilitates chaining)
    
    Specified by:
    
    setTrue in interface MutableBooleanValue<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new value was incompatible with with algebraic interpretation of this object
  - setUnity
```
public SCALAR setUnity()
                                       throws UnsupportedOperationException,
                                              IllegalArgumentException,
                                              ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the multiplicative identity appropriate for the implementation (one)
    
    Specified by:
    
    setUnity in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - setZero
```
public SCALAR setZero()
                                      throws UnsupportedOperationException,
                                             IllegalArgumentException,
                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the additive identity appropriate for the implementation (zero)
    
    Specified by:
    
    setZero in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - shiftRightExtendZero
```
public SCALAR shiftRightExtendZero(int count)
                                                   throws UnsupportedOperationException,
                                                          IllegalArgumentException,
                                                          ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions without sign extension. In a bit sequence this functions resorts to the familiar "right shift" process, with zero extension (e.g., the Java >>> operator). In other sequences, the specified number of values will be removed from the beginning of the sequence, decreasing the ordinal position of all remaining elements by the specified count.
    
    Specified by:
    
    shiftRightExtendZero in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    count - the number of values to be removed from the beginning of this sequence
    
    Returns:
    this structure (facilitates chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed or if this structure is not an algebraic tuple
    
    IllegalArgumentException - if the specified value was incommensurate with this structure's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this structure
  - signum
```
public int signum()
```
    Specified by:
    
    signum in interface NumericProperties
    
    Returns:
    zero if this number is zero, -1 if this number is negative or +1 if it is positive
  - sine
```
public SCALAR sine()
                                   throws UnsupportedOperationException,
                                          IllegalArgumentException,
                                          ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value, assumed to be an angle in radians, to its sine
    
    Specified by:
    
    sine in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - size
```
public int size()
```
    Description copied from interface: SealedAlgebraicStructure
    
    Returns the number of elements in this algebraic structure. If the structure contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.
    
    Specified by:
    
    size in interface SealedAlgebraicStructure
    
    Returns:
    the number of elements in this algebraic structure
    See Also:
    Collection.size()
  - squareRoot
```
public SCALAR squareRoot()
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the square root of itself
    
    Specified by:
    
    squareRoot in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
public SCALAR sum(boolean aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
public SCALAR sum(byte aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
public SCALAR sum(char aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
public SCALAR sum(double aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
public SCALAR sum(float aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
public SCALAR sum(int aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
public SCALAR sum(long aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
public SCALAR sum(short aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sumOfNumber
```
public SCALAR sumOfNumber(Number aValue)
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sumOfNumber in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sumOfScalar
```
public SCALAR sumOfScalar(SealedScalar<?> aValue)
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sumOfScalar in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - tangent
```
public SCALAR tangent()
                                      throws UnsupportedOperationException,
                                             IllegalArgumentException,
                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value, assumed to be an angle in radians, to its tangent
    
    Specified by:
    
    tangent in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - toBoolean
```
public Boolean toBoolean()
```
    Specified by:
    
    toBoolean in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object as a best-match, system-supported Boolean object
  - toCharacter
```
public Character toCharacter()
```
    Specified by:
    
    toCharacter in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object as a best-match, system-supported Boolean object
  - toCodePoint
```
public int toCodePoint()
```
    Description copied from interface: SealedScalar
    
    Represent the value of this object as a code point
    
    Specified by:
    
    toCodePoint in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    the value of this object represented as a single code point
  - toEnumeration
```
public <E extends Enum<E>> E toEnumeration(Class<E> anEnumerationClass)
                             throws ArithmeticException,
                                    IllegalArgumentException,
                                    NullPointerException
```
    Description copied from interface: SealedScalar
    
    Represent the value of this object as an appropriate member of the class of the specified enumeration
    
    Specified by:
    
    toEnumeration in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    anEnumerationClass - the class of enumeration to convert to
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    NullPointerException - a null value was provided though this object does not accept null values
  - toScalar
```
public Scalar<?> toScalar()
```
    Description copied from interface: ScalarReplicator
    
    If this scalar is already a scalar then simply call its Replicator.copy() function, otherwise produce a new scalar with scalar precision
    
    Specified by:
    
    toScalar in interface ScalarReplicator<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    a new scalar scalar
  - up
```
public final SCALAR up()
                                       throws UnsupportedOperationException,
                                              IllegalArgumentException,
                                              ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Round away from zero
    
    Specified by:
    
    up in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
public SCALAR xor(boolean aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xor in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
public SCALAR xor(byte aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xor in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
public SCALAR xor(char aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xor in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
public SCALAR xor(int aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xor in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
public SCALAR xor(long aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xor in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
public SCALAR xor(short aValue)
                                  throws UnsupportedOperationException,
                                         IllegalArgumentException,
                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xor in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xorOfNumber
```
public SCALAR xorOfNumber(Number aValue)
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xorOfNumber in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xorOfScalar
```
public final SCALAR xorOfScalar(SealedScalar<?> aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xorOfScalar in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - boundsCheck
```
public static final void boundsCheck(int anIndex,
               int anOrdinalBound)
                              throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - byteMaskAt
```
public static final byte byteMaskAt(int aBitPosition)
```
  - byteNotMaskAt
```
public static final byte byteNotMaskAt(int aBitPosition)
```
  - byteValue
```
public static final byte byteValue(boolean[] aBooleanArray)
```
  - charMaskAt
```
public static final char charMaskAt(int aBitPosition)
```
  - charNotMaskAt
```
public static final char charNotMaskAt(int aBitPosition)
```
  - charValue
```
public static final char charValue(boolean[] aBooleanArray)
```
  - clearByteBitAt
```
public static final byte clearByteBitAt(int anIndex,
                  byte myValue)
                                 throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - clearCharBitAt
```
public static final char clearCharBitAt(int anIndex,
                  char myValue)
                                 throws UnsupportedOperationException,
                                        IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - clearDoubleBitAt
```
public static final double clearDoubleBitAt(int anIndex,
                      double myValue)
                                     throws UnsupportedOperationException,
                                            IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - clearFloatBitAt
```
public static final float clearFloatBitAt(int anIndex,
                    float myValue)
                                   throws UnsupportedOperationException,
                                          IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - clearIntBitAt
```
public static final int clearIntBitAt(int anIndex,
                int myValue)
                               throws UnsupportedOperationException,
                                      IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - clearLongBitAt
```
public static final long clearLongBitAt(int anIndex,
                  long myValue)
                                 throws UnsupportedOperationException,
                                        IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - clearShortBitAt
```
public static final short clearShortBitAt(int anIndex,
                    short myValue)
                                   throws UnsupportedOperationException,
                                          IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - clearUnlimitedDecimalBitAt
```
public static final BigDecimal clearUnlimitedDecimalBitAt(int anIndex,
                                    BigDecimal myValue)
                                                   throws UnsupportedOperationException,
                                                          IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - clearUnlimitedIntegerBitAt
```
public static final BigInteger clearUnlimitedIntegerBitAt(int anIndex,
                                    BigInteger myValue)
                                                   throws UnsupportedOperationException,
                                                          IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - compareTo
```
public static final int compareTo(BigDecimal p0,
            BigDecimal p1)
```
  - compareTo
```
public static final int compareTo(BigInteger p0,
            BigInteger p1)
```
  - compareTo
```
public static final int compareTo(boolean p0,
            boolean p1)
```
  - compareTo
```
public static final int compareTo(byte p0,
            byte p1)
```
  - compareTo
```
public static final int compareTo(char p0,
            char p1)
```
  - compareTo
```
public static final int compareTo(CharSequence p0,
            CharSequence p1)
```
  - compareTo
```
public static final int compareTo(double p0,
            double p1)
```
  - compareTo
```
public static final int compareTo(float p0,
            float p1)
```
  - compareTo
```
public static final int compareTo(int p0,
            int p1)
```
  - compareTo
```
public static final int compareTo(long p0,
            long p1)
```
  - compareTo
```
public static final int compareTo(short p0,
            short p1)
```
  - divideByZero
```
public static final void divideByZero()
```
  - getBooleanBitAt
```
public static final boolean getBooleanBitAt(int anIndex,
                      boolean myValue)
                                     throws UnsupportedOperationException,
                                            IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - getByteBitAt
```
public static final boolean getByteBitAt(int anIndex,
                   byte myValue)
                                  throws UnsupportedOperationException,
                                         IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - getCharBitAt
```
public static final boolean getCharBitAt(int anIndex,
                   char myValue)
                                  throws UnsupportedOperationException,
                                         IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - getDoubleBitAt
```
public static final boolean getDoubleBitAt(int anIndex,
                     double myValue)
                                    throws UnsupportedOperationException,
                                           IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - getFloatBitAt
```
public static final boolean getFloatBitAt(int anIndex,
                    float myValue)
                                   throws UnsupportedOperationException,
                                          IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - getIntBitAt
```
public static final boolean getIntBitAt(int anIndex,
                  int myValue)
                                 throws UnsupportedOperationException,
                                        IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - getLongBitAt
```
public static final boolean getLongBitAt(int anIndex,
                   long myValue)
                                  throws UnsupportedOperationException,
                                         IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - getShortBitAt
```
public static final boolean getShortBitAt(int anIndex,
                    short myValue)
                                   throws UnsupportedOperationException,
                                          IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - getUnlimitedDecimalBitAt
```
public static final boolean getUnlimitedDecimalBitAt(int anIndex,
                               BigDecimal myValue)
                                              throws UnsupportedOperationException,
                                                     IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - getUnlimitedIntegerBitAt
```
public static final boolean getUnlimitedIntegerBitAt(int anIndex,
                               BigInteger myValue)
                                              throws UnsupportedOperationException,
                                                     IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - hashCode
```
public static final int hashCode(boolean aValue)
```
  - hashCode
```
public static final int hashCode(byte aValue)
```
  - hashCode
```
public static final int hashCode(char aValue)
```
  - hashCode
```
public static final int hashCode(double aValue)
```
  - hashCode
```
public static final int hashCode(float aValue)
```
  - hashCode
```
public static final int hashCode(int aValue)
```
  - hashCode
```
public static final int hashCode(long aValue)
```
  - hashCode
```
public static final int hashCode(short aValue)
```
  - indexOutOfBoundsAt
```
public static final void indexOutOfBoundsAt(int anIndex)
                                     throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - intGCD
```
public static final int intGCD(int p0,
         int p1)
                        throws UnsupportedOperationException,
                               ArithmeticException,
                               IllegalArgumentException
```
    Throws:
    
    UnsupportedOperationException
    
    ArithmeticException
    
    IllegalArgumentException
  - intMaskAt
```
public static final int intMaskAt(int aBitPosition)
```
  - intModularInverse
```
public static final int intModularInverse(int p0,
                    int p1)
```
  - intModularQuotient
```
public static final int intModularQuotient(int aDividend,
                     int aDivisor,
                     int aModulus)
```
  - intNotMaskAt
```
public static final int intNotMaskAt(int aBitPosition)
```
  - intValue
```
public static final int intValue(boolean[] aBooleanArray)
```
  - longGCD
```
public static final long longGCD(long p0,
           long p1)
                          throws UnsupportedOperationException,
                                 ArithmeticException,
                                 IllegalArgumentException
```
    Throws:
    
    UnsupportedOperationException
    
    ArithmeticException
    
    IllegalArgumentException
  - longMaskAt
```
public static final long longMaskAt(int aBitPosition)
```
  - longModularInverse
```
public static final long longModularInverse(long p0,
                      long p1)
```
  - longModularQuotient
```
public static final long longModularQuotient(long aDividend,
                       long aDivisor,
                       long aModulus)
```
  - longNotMaskAt
```
public static final long longNotMaskAt(int aBitPosition)
```
  - longValue
```
public static final long longValue(boolean[] aBooleanArray)
```
  - setByteBitAt
```
public static final byte setByteBitAt(int anIndex,
                byte myValue)
                               throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - setCharBitAt
```
public static final char setCharBitAt(int anIndex,
                char myValue)
                               throws UnsupportedOperationException,
                                      IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - setDoubleBitAt
```
public static final double setDoubleBitAt(int anIndex,
                    double myValue)
                                   throws UnsupportedOperationException,
                                          IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - setFloatBitAt
```
public static final float setFloatBitAt(int anIndex,
                  float myValue)
                                 throws UnsupportedOperationException,
                                        IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - setIntBitAt
```
public static final int setIntBitAt(int anIndex,
              int myValue)
                             throws UnsupportedOperationException,
                                    IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - setLongBitAt
```
public static final long setLongBitAt(int anIndex,
                long myValue)
                               throws UnsupportedOperationException,
                                      IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - setShortBitAt
```
public static final short setShortBitAt(int anIndex,
                  short myValue)
                                 throws UnsupportedOperationException,
                                        IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - setUnlimitedDecimalBitAt
```
public static final BigDecimal setUnlimitedDecimalBitAt(int anIndex,
                                  BigDecimal myValue)
                                                 throws UnsupportedOperationException,
                                                        IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - setUnlimitedIntegerBitAt
```
public static final BigInteger setUnlimitedIntegerBitAt(int anIndex,
                                  BigInteger myValue)
                                                 throws UnsupportedOperationException,
                                                        IndexOutOfBoundsException
```
    Throws:
    
    UnsupportedOperationException
    
    IndexOutOfBoundsException
  - shortMaskAt
```
public static final short shortMaskAt(int aBitPosition)
```
  - shortNotMaskAt
```
public static final short shortNotMaskAt(int aBitPosition)
```
  - shortValue
```
public static final short shortValue(boolean[] aBooleanArray)
```
  - toBooleanArray
```
public static final boolean[] toBooleanArray(BigDecimal aTuple)
```
  - toBooleanArray
```
public static final boolean[] toBooleanArray(BigInteger aTuple)
```
  - toBooleanArray
```
public static final boolean[] toBooleanArray(boolean aTuple)
```
  - toBooleanArray
```
public static final boolean[] toBooleanArray(byte aTuple)
```
  - toBooleanArray
```
public static final boolean[] toBooleanArray(char aTuple)
```
  - toBooleanArray
```
public static final boolean[] toBooleanArray(CharSequence aTuple)
```
  - toBooleanArray
```
public static final boolean[] toBooleanArray(double aTuple)
```
  - toBooleanArray
```
public static final boolean[] toBooleanArray(float aTuple)
```
  - toBooleanArray
```
public static final boolean[] toBooleanArray(int aTuple)
```
  - toBooleanArray
```
public static final boolean[] toBooleanArray(long aTuple)
```
  - toBooleanArray
```
public static final boolean[] toBooleanArray(short aTuple)
```
  - toByteArray
```
public static final byte[] toByteArray(boolean[] aBooleanArray)
```
  - toUnlimitedInteger
```
public static final BigInteger toUnlimitedInteger(boolean[] aBooleanArray)
```
  - unlimitedIntegerMaskAt
```
public static final BigInteger unlimitedIntegerMaskAt(int aBitPosition)
```
  - unlimitedIntegerNotMaskAt
```
public static final BigInteger unlimitedIntegerNotMaskAt(int aBitPosition)
```

Class AbstractScalar<SCALAR extends Scalar<SCALAR>>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

Methods inherited from interface net.sf.jaccumulator.scalars.ScalarInductor

Methods inherited from interface net.sf.jaccumulator.scalars.SealedScalar

Methods inherited from interface net.sf.jaccumulator.scalars.SealedScalarDomain

Methods inherited from interface net.sf.jaccumulator.SealedAlgebraicStructure

Methods inherited from interface net.sf.jaccumulator.SealedKernel

Methods inherited from interface net.sf.jaccumulator.scalars.NumericProperties

Methods inherited from interface net.sf.jaccumulator.scalars.ScalarReplicator

Methods inherited from interface net.sf.jaccumulator.Replicator

Methods inherited from interface net.sf.jaccumulator.scalars.MutableScalar

Methods inherited from interface net.sf.jaccumulator.MutableAlgebraicStructure

Methods inherited from interface net.sf.jaccumulator.booleans.SealedBooleanValue

Methods inherited from interface net.sf.jaccumulator.booleans.MutableBooleanValue

Methods inherited from interface net.sf.jaccumulator.bytes.SealedByteValue

Methods inherited from interface net.sf.jaccumulator.bytes.MutableByteValue

Methods inherited from interface net.sf.jaccumulator.characters.SealedCharacterValue

Methods inherited from interface net.sf.jaccumulator.characters.MutableCharacterValue

Methods inherited from interface net.sf.jaccumulator.doubles.SealedDoubleValue

Methods inherited from interface net.sf.jaccumulator.doubles.MutableDoubleValue

Methods inherited from interface net.sf.jaccumulator.floats.SealedFloatValue

Methods inherited from interface net.sf.jaccumulator.floats.MutableFloatValue

Methods inherited from interface net.sf.jaccumulator.integers.SealedIntegerValue

Methods inherited from interface net.sf.jaccumulator.integers.MutableIntegerValue

Methods inherited from interface net.sf.jaccumulator.longs.SealedLongValue

Methods inherited from interface net.sf.jaccumulator.longs.MutableLongValue

Methods inherited from interface net.sf.jaccumulator.shorts.SealedShortValue

Methods inherited from interface net.sf.jaccumulator.shorts.MutableShortValue

Field Detail

NaN

ONEI

ZERO_DOUBLE_LONG_BITS

ZERO_FLOAT_INT_BITS

ZEROI

Constructor Detail

AbstractScalar

AbstractScalar

Method Detail

absoluteValue

and

and

and

and

and

and

andOfNumber

andOfScalar

angleWith

angleWithNumber

angleWithScalar

arcCosine

arcSine

arcTangent

assertDomain

assertPrecision

base10Log

ceiling

compareToNumber

compareToScalar

compareToScalar

compareToScalar

compareToScalar

compareToScalar

compareToScalar

compareToScalar

compareToScalar

compareToScalar

compareToZero

cosine

cubeRoot

degrees

difference

difference

difference

difference

difference