AbstractDoublePrimitive (Java Accumulators and Variants)

java.lang.Object
- java.lang.Number
- - net.sf.jaccumulator.scalars.AbstractScalar<REAL>
  - - net.sf.jaccumulator.reals.AbstractReal<PRIMITIVE>
    - - net.sf.jaccumulator.primitives.AbstractPrimitive<PRIMITIVE>
      - net.sf.jaccumulator.primitives.AbstractNumericPrimitive<PRIMITIVE>
        
        net.sf.jaccumulator.doubles.AbstractDoublePrimitive<PRIMITIVE>

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

All Implemented Interfaces:

Serializable, Appendable, CharSequence, Comparable<SealedPrimitive<?>>, AlgebraicStructure<PRIMITIVE>, BooleanValue<PRIMITIVE>, MutableBooleanValue<PRIMITIVE>, SealedBooleanValue, ByteValue<PRIMITIVE>, MutableByteValue<PRIMITIVE>, SealedByteValue, CharacterValue<PRIMITIVE>, MutableCharacterValue<PRIMITIVE>, SealedCharacterValue, DoubleValue<PRIMITIVE>, MutableDoubleValue<PRIMITIVE>, SealedDoubleValue, FloatValue<PRIMITIVE>, MutableFloatValue<PRIMITIVE>, SealedFloatValue, IntegerValue<PRIMITIVE>, MutableIntegerValue<PRIMITIVE>, SealedIntegerValue, LongValue<PRIMITIVE>, MutableLongValue<PRIMITIVE>, SealedLongValue, Mutable, MutableAlgebraicStructure<PRIMITIVE>, MutableKernel<PRIMITIVE>, MutablePrimitive<PRIMITIVE>, Primitive<PRIMITIVE>, PrimitiveInductor<PRIMITIVE>, PrimitiveReplicator<PRIMITIVE>, SealedPrimitive<PRIMITIVE>, MutableReal<PRIMITIVE>, MutableRealDomain<PRIMITIVE>, Real<PRIMITIVE>, RealDomain<PRIMITIVE>, RealInductor<PRIMITIVE>, RealReplicator<PRIMITIVE>, SealedReal<PRIMITIVE>, SealedRealBag, SealedRealDomain, Replicator<PRIMITIVE>, CharacterProperties, MutableScalar<PRIMITIVE>, MutableScalarDomain<PRIMITIVE>, NumericProperties, Scalar<PRIMITIVE>, ScalarDomain<PRIMITIVE>, ScalarInductor<PRIMITIVE>, ScalarReplicator<PRIMITIVE>, SealedScalar<PRIMITIVE>, SealedScalarBag, SealedScalarDomain, SealedAlgebraicStructure, SealedKernel, MutableShortValue<PRIMITIVE>, SealedShortValue, ShortValue<PRIMITIVE>, StructureProperties, MutableText<PRIMITIVE>, MutableTextValue<PRIMITIVE>, SealedText<PRIMITIVE>, SealedTextValue, Text<PRIMITIVE>, TextInductor, TextProperties, TextReplicator<PRIMITIVE>, TextValue<PRIMITIVE>, MutableUnlimitedDecimalValue<PRIMITIVE>, MutableUnlimitedIntegerValue<PRIMITIVE>, SealedUnlimitedDecimalValue, SealedUnlimitedIntegerValue, UnlimitedDecimalValue<PRIMITIVE>, UnlimitedIntegerValue<PRIMITIVE>

Direct Known Subclasses:

DoublePrimitive
```
public abstract class AbstractDoublePrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
extends AbstractNumericPrimitive<PRIMITIVE>
```
Abstract double precision primitive implementation

Since:

JAccumulator 4.0

Author:

Nicole Tedesco (Nicole@NicoleTedesco.com)

See Also:
Serialized Form

Field Summary
- Fields inherited from class net.sf.jaccumulator.scalars.AbstractScalar
  NaN, ONEI, ZERO_DOUBLE_LONG_BITS, ZERO_FLOAT_INT_BITS, ZEROI

Constructor Summary

Constructors
Constructor and Description

AbstractDoublePrimitive()

AbstractDoublePrimitive(Domain aDomain)

Constructors
Constructor and Description
`AbstractDoublePrimitive()`
`AbstractDoublePrimitive(Domain aDomain)`

Method Summary

Methods
Modifier and Type	Method and Description
`PRIMITIVE`	`absoluteValue()` Replace the current value with the absolute value of itself
`PRIMITIVE`	`and(BigInteger aValue)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`boolean`	`booleanPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`boolean`	`booleanPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`boolean`	`booleanValue()`
`byte`	`bytePostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`byte`	`bytePostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`byte`	`byteValue()`
`char`	`charPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`char`	`charPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`char`	`charValue()`
`PRIMITIVE`	`copyUsing(BigDecimal aValue)` Using this real as a factory, produce a new real of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsing(BigInteger aValue)` Using this real as a factory, produce a new real of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsing(boolean aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(byte aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(char aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(float aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(int aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(long aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(short aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsingPrimitive(SealedPrimitive<?> aValue)` Using this primitive as a factory, produce a new primitive of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsingReal(SealedReal<?> aValue)` Using this real as a factory, produce a new real of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsingScalar(SealedScalar<?> aValue)` Using this scalar as a factory, produce a new scalar of the same type but initialized with the value specified
`PRIMITIVE`	`cube()` Replace the current value with the cube of itself
`PRIMITIVE`	`difference(BigDecimal aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`difference(BigInteger aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`difference(boolean aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`difference(byte aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`difference(char aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`difference(float aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`difference(int aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`difference(long aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`difference(short aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`float`	`floatPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`float`	`floatPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`float`	`floatValue()`
`<S extends Scalar<?>> S`	`inducePostDecrement(S aTarget)` Decrement the value of this scalar then induce its original value into the specified target
`<S extends Scalar<?>> S`	`inducePostIncrement(S aTarget)` Increment the value of this scalar then induce its original value into the specified target
`<REAL extends Real<?>> REAL`	`induceRealMaximum(REAL aTarget)` Induce the maximum domain value into the target
`<REAL extends Real<?>> REAL`	`induceRealMinimum(REAL aTarget)` Induce the minimum domain value into the target
`<REAL extends Real<?>> REAL`	`induceRealValue(REAL aTarget)` Induce the current value of this real into the specified target
`<S extends Scalar<?>> S`	`induceScalarMaximum(S aTarget)` Induce the maximum domain value into the target
`<S extends Scalar<?>> S`	`induceScalarMinimum(S aTarget)` Induce the minimum domain value into the target
`<S extends Scalar<?>> S`	`induceScalarValue(S aTarget)` Induce the current value of this scalar into the specified target
`int`	`intPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`int`	`intPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`int`	`intValue()`
`PRIMITIVE`	`invalidate()` Replace the current value an invalid value such `INVALID` if possible, otherwise replace it with zero
`PRIMITIVE`	`inverse()` Replace the current value its multiplicative inverse (`1/x`)
`boolean`	`isInfinity()`
`boolean`	`isInvalid()`
`boolean`	`isMaximum()`
`boolean`	`isMinimum()`
`boolean`	`isModulo()` Answer `true` if this value represents the magnitude of a vector into a modulo set, or finite ring.
`boolean`	`isNegative()`
`boolean`	`isNegativeFinite()`
`boolean`	`isNegativeInfinity()`
`boolean`	`isPositive()`
`boolean`	`isPositiveFinite()`
`boolean`	`isPositiveInfinity()`
`boolean`	`isReal()` Answer `true` if this value represents the magnitude of a vector into the set of real numbers.
`boolean`	`isUnity()` Answer `true` if this value represents the multiplicative identity in its arithmetic domain.
`boolean`	`isZero()` Answer `true` if this value represents the additive identity in its algebraic group.
`long`	`longPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`long`	`longPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`long`	`longValue()`
`PRIMITIVE`	`negate()` Replace the current value with the additive inverse (sign negation) of itself, that is transform it into a number that when added to the original yields zero.
`PRIMITIVE`	`not()` Replace the current integral binary vector with its one's complement.
`PRIMITIVE`	`or(BigInteger aValue)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`PRIMITIVE`	`product(BigDecimal aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`product(BigInteger aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`product(boolean aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`product(byte aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`product(char aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`product(float aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`product(int aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`product(long aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`product(short aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`quotient(BigDecimal aValue)` Set the value of this scalar to the mathematical quotient between its current value and the specified value
`PRIMITIVE`	`quotient(BigInteger aValue)` Set the value of this scalar to the mathematical quotient between its current value and the specified value
`PRIMITIVE`	`quotient(boolean aValue)` Set the value of this scalar to the mathematical quotient between its current value and the specified value
`PRIMITIVE`	`quotient(byte aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`PRIMITIVE`	`quotient(char aValue)` Set the value of this scalar to the mathematical quotient between its current value and the specified value
`PRIMITIVE`	`quotient(float aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`PRIMITIVE`	`quotient(int aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`PRIMITIVE`	`quotient(long aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`PRIMITIVE`	`quotient(short aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`PRIMITIVE`	`round(RoundingStrategy aRoundingStrategy)` Round the current value using the specified rounding `strategy`
`PRIMITIVE`	`setMaximum()` Replace the current value with maximum value available for the implementation's numeric `precision`.
`PRIMITIVE`	`setMinimum()` Replace the current value with minimum value available for the implementation's numeric `precision`.
`PRIMITIVE`	`setNegativeInfinity()` Replace the current value with a representation of negative infinity, if available, otherwise replace with the implementation's `minimum` value
`PRIMITIVE`	`setNumber(Number aValue)` Set this object to the specified system-supported `Number` and answer this object (facilitates chaining)
`PRIMITIVE`	`setPositiveInfinity()` Replace the current value with a representation of positive infinity, if available, otherwise replace with the implementation's `maximum` value
`PRIMITIVE`	`setPrimitive(SealedPrimitive<?> aValue)` Set this property to the specified primitive
`PRIMITIVE`	`setReal(BigDecimal aValue)` Set this property to the specified unlimited `decimal` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setReal(BigInteger aValue)` Set this property to the specified unlimited `integer` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setReal(SealedReal<?> aValue)` Set this property to the specified numeric `primitive` and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(boolean aValue)` Set this property to the specified `boolean` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(byte aValue)` Set this property to the specified `byte` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(char aValue)` Set this property to the specified `char` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(float aValue)` Set this property to the specified `float` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(int aValue)` Set this property to the specified `int` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(long aValue)` Set this property to the specified `long` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(SealedScalar<?> aValue)` Set this object to the specified scalar
`PRIMITIVE`	`setScalar(short aValue)` Set this property to the specified `short` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setUnity()` Replace the current value with the multiplicative identity appropriate for the implementation (one)
`PRIMITIVE`	`setZero()` Replace the current value with the additive identity appropriate for the implementation (zero)
`PRIMITIVE`	`shiftLeft(int count)` Attempt to shift the elements of this tuple to the "left" the specified number of ordinal positions.
`PRIMITIVE`	`shiftRight(int count)` Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions.
`PRIMITIVE`	`shiftRightExtendZero(int count)` Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions without sign extension.
`short`	`shortPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`short`	`shortPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`short`	`shortValue()`
`int`	`signum()`
`PRIMITIVE`	`square()` Replace the current value with the square of itself
`PRIMITIVE`	`sum(BigDecimal aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`PRIMITIVE`	`sum(BigInteger aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`PRIMITIVE`	`sum(boolean aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`PRIMITIVE`	`sum(byte aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`PRIMITIVE`	`sum(char aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`PRIMITIVE`	`sum(float aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`PRIMITIVE`	`sum(int aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`PRIMITIVE`	`sum(long aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`PRIMITIVE`	`sum(short aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`PRIMITIVE`	`swapPrimitives(Primitive<?> aPrimitive)` Swap the value of this primitive for the specified one and set the specified primitive's value to the current value of this primitive
`Number`	`toNumber()`
`String`	`toString()`
`BigDecimal`	`toUnlimitedDecimal()`
`BigInteger`	`toUnlimitedInteger()`
`BigDecimal`	`unlimitedDecimalPostDecrement()` Decrement the real value of this object then return the original value prior to decrementing
`BigDecimal`	`unlimitedDecimalPostIncrement()` Increment the real value of this object then return the original value prior to incrementing
`BigInteger`	`unlimitedIntegerPostDecrement()` Decrement the real value of this object then return the original value prior to decrementing
`BigInteger`	`unlimitedIntegerPostIncrement()` Increment the real value of this object then return the original value prior to incrementing
`PRIMITIVE`	`xor(BigInteger aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`PRIMITIVE`	`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
`PRIMITIVE`	`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

Methods inherited from class net.sf.jaccumulator.primitives.AbstractNumericPrimitive
append, append, append, append, append, append, append, append, append, append, append, append, append, append, appendCodePoint, charAt, clear, clearContents, clearText, codePointAt, codePointBefore, codePointCount, compareTo, compareToPrimitive, copyUsingText, delete, deleteCharAt, equals, getStructureStrategy, indexOfText, indexOfText, inducePostDecrement, inducePostDecrement, inducePostIncrement, inducePostIncrement, inducePrimitiveValue, induceTextValue, insert, insert, insert, insert, insert, insert, insert, insert, insert, insert, insert, insert, isEmpty, isEqualToPrimitive, isEqualToText, isGreaterOrEqualToPrimitive, isGreaterOrEqualToText, isGreaterThanPrimitive, isGreaterThanText, isLessOrEqualToPrimitive, isLessOrEqualToText, isLessThanPrimitive, isLessThanText, isNotEqualToPrimitive, isNotEqualToText, isText, length, lowerCase, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, replace, replace, replaceAll, replaceCharacter, replaceFirst, reverse, setBoolean, setCharacter, setCharAt, setLength, setText, subSequence, substring, substring, textPostDecrement, textPostIncrement, titleCase, toPrimitive, toPrimitive, trim, upperCase

Methods inherited from class net.sf.jaccumulator.primitives.AbstractPrimitive
andOfPrimitive, angleWithPrimitive, compareToText, differenceOfPrimitive, hypotenuseWithPrimitive, inducePrimitiveMaximum, inducePrimitiveMinimum, induceTextSize, modOfPrimitive, orOfPrimitive, powerOfPrimitive, productOfPrimitive, quotientOfPrimitive, sumOfPrimitive, toPrimitive, xorOfPrimitive

Methods inherited from class net.sf.jaccumulator.reals.AbstractReal
andOfNumber, andOfReal, angleWithReal, compareToNumber, compareToReal, compareToReal, compareToReal, differenceOfNumber, differenceOfReal, gcd, gcdOfNumber, gcdOfReal, hypotenuseWithReal, induceRealSize, isEqual, isEqual, isEqualToNumber, isEqualToReal, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqualToNumber, isGreaterOrEqualToReal, isGreaterThanNumber, isGreaterThanReal, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqualToNumber, isLessOrEqualToReal, isLessThanNumber, isLessThanReal, isNotEqual, isNotEqual, isNotEqualToNumber, isNotEqualToReal, mod, mod, modOfNumber, modOfReal, orOfNumber, orOfReal, powerOfReal, productOfNumber, productOfReal, quotientOfNumber, quotientOfReal, sumOfNumber, sumOfReal, toReal, unlimitedIntegerModularInverse, xorOfNumber, xorOfReal

Methods inherited from class net.sf.jaccumulator.scalars.AbstractScalar
andOfScalar, angleWith, angleWithNumber, angleWithScalar, arcCosine, arcSine, arcTangent, assertDomain, assertPrecision, base10Log, boundsCheck, byteMaskAt, byteNotMaskAt, byteValue, ceiling, charMaskAt, charNotMaskAt, charValue, clearByteBitAt, clearCharBitAt, clearDoubleBitAt, clearFloatBitAt, clearIntBitAt, clearLongBitAt, clearShortBitAt, clearUnlimitedDecimalBitAt, clearUnlimitedIntegerBitAt, compareTo, compareTo, compareTo, compareTo, compareTo, compareTo, compareTo, compareTo, compareTo, compareTo, compareTo, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToZero, cosine, cubeRoot, degrees, difference, differenceOfScalar, divideByZero, down, exponential, exponentialLessOne, floor, gcd, gcd, gcd, gcd, gcd, gcdOfScalar, getBooleanBitAt, getByteBitAt, getCharBitAt, getDomain, getDoubleBitAt, getFloatBitAt, getIntBitAt, getLongBitAt, getPrecision, getShortBitAt, getUnlimitedDecimalBitAt, getUnlimitedIntegerBitAt, halfDown, halfEven, halfUp, hashCode, hashCode, hashCode, hashCode, hashCode, hashCode, hashCode, hashCode, hyperbolicCosine, hyperbolicSine, hyperbolicTangent, hypotenuseWith, hypotenuseWithNumber, hypotenuseWithScalar, indexOutOfBoundsAt, induceScalarSize, intGCD, intMaskAt, intModularInverse, intModularQuotient, intNotMaskAt, intValue, isAlphabetic, isBmpCodePoint, isConfigurable, isCountable, isDigit, isElastic, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqualToScalar, isExpandable, isFalse, isFinite, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqualToScalar, isGreaterThanScalar, isHighSurrogate, isIdentifierIgnorable, isIdeographic, isImaginary, isISOControl, isJavaIdentifierPart, isJavaIdentifierStart, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqualToScalar, isLessThanScalar, isLetter, isLetterOrDigit, isLowerCase, isLowSurrogate, isMirrored, isMutable, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqualToScalar, isOrdered, isReducible, isSupplementaryCodePoint, isSurrogate, isTitleCase, isTrue, isUnicode, isUnicodeIdentifierPart, isUnicodeIdentifierStart, isUnique, isUpperCase, isValid, isValidCodePoint, isWhitespace, longGCD, longMaskAt, longModularInverse, longModularQuotient, longNotMaskAt, longSize, longValue, milliseconds, mod, mod, mod, mod, mod, mod, mod, mod, modOfScalar, nanoseconds, naturalLog, naturalLogPlusOne, orOfScalar, power, power, powerOfNumber, powerOfScalar, product, productOfScalar, promoteTo, quotient, quotientOfScalar, radians, random, setByteBitAt, setCharBitAt, setDoubleBitAt, setE, setEnumeration, setFalse, setFloatBitAt, setIntBitAt, setLongBitAt, setPi, setShortBitAt, setTrue, setUnlimitedDecimalBitAt, setUnlimitedIntegerBitAt, shortMaskAt, shortNotMaskAt, shortValue, sine, size, squareRoot, sum, sumOfScalar, tangent, toBoolean, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toByteArray, toCharacter, toCodePoint, toEnumeration, toScalar, toUnlimitedInteger, unlimitedIntegerMaskAt, unlimitedIntegerNotMaskAt, up, xorOfScalar

Methods inherited from class java.lang.Number
doubleValue

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

Methods inherited from interface net.sf.jaccumulator.reals.SealedReal
compareToReal, compareToReal, compareToReal, isEqual, isEqual, isEqualToReal, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqualToReal, isGreaterThanReal, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqualToReal, isLessThanReal, isNotEqual, isNotEqual, isNotEqualToReal

Methods inherited from interface net.sf.jaccumulator.scalars.SealedScalar
compareToNumber, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToZero, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqualToNumber, isEqualToScalar, isFalse, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqualToNumber, isGreaterOrEqualToScalar, isGreaterThanNumber, isGreaterThanScalar, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqualToNumber, isLessOrEqualToScalar, isLessThanNumber, isLessThanScalar, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqualToNumber, isNotEqualToScalar, isTrue, toBoolean, toCharacter, toCodePoint, toEnumeration

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

Methods inherited from interface net.sf.jaccumulator.scalars.NumericProperties
isFinite, isImaginary, isValid

Methods inherited from interface net.sf.jaccumulator.scalars.CharacterProperties
isAlphabetic, isBmpCodePoint, isDigit, isHighSurrogate, isIdentifierIgnorable, isIdeographic, isISOControl, isJavaIdentifierPart, isJavaIdentifierStart, isLetter, isLetterOrDigit, isLowerCase, isLowSurrogate, isMirrored, isSupplementaryCodePoint, isSurrogate, isTitleCase, isUnicode, isUnicodeIdentifierPart, isUnicodeIdentifierStart, isUpperCase, isValidCodePoint, isWhitespace

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

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

Methods inherited from interface net.sf.jaccumulator.reals.SealedRealBag
induceRealSize

Methods inherited from interface net.sf.jaccumulator.scalars.SealedScalarBag
induceScalarSize

Methods inherited from interface net.sf.jaccumulator.SealedAlgebraicStructure
getDomain, longSize, size

Methods inherited from interface net.sf.jaccumulator.StructureProperties
isConfigurable, isCountable, isElastic, isExpandable, isOrdered, isReducible, isUnique

Methods inherited from interface net.sf.jaccumulator.reals.RealReplicator
toReal

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

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

Methods inherited from interface net.sf.jaccumulator.reals.MutableReal
andOfReal, angleWithReal, differenceOfReal, gcd, gcdOfReal, hypotenuseWithReal, mod, mod, modOfReal, orOfReal, powerOfReal, productOfReal, quotientOfReal, sumOfReal, xorOfReal

Methods inherited from interface net.sf.jaccumulator.scalars.MutableScalar
andOfNumber, andOfScalar, angleWith, angleWithNumber, angleWithScalar, arcCosine, arcSine, arcTangent, base10Log, ceiling, cosine, cubeRoot, decrement, degrees, difference, differenceOfNumber, differenceOfScalar, down, exponential, exponentialLessOne, floor, gcd, gcd, gcd, gcd, gcd, gcdOfNumber, gcdOfScalar, halfDown, halfEven, halfUp, hyperbolicCosine, hyperbolicSine, hyperbolicTangent, hypotenuseWith, hypotenuseWithNumber, hypotenuseWithScalar, increment, milliseconds, mod, mod, mod, mod, mod, mod, mod, mod, modOfNumber, modOfScalar, nanoseconds, naturalLog, naturalLogPlusOne, orOfNumber, orOfScalar, power, power, powerOfNumber, powerOfScalar, product, productOfNumber, productOfScalar, quotient, quotientOfNumber, quotientOfScalar, radians, random, setE, setEnumeration, setPi, sine, squareRoot, sum, sumOfNumber, sumOfScalar, tangent, up, xorOfNumber, xorOfScalar

Methods inherited from interface net.sf.jaccumulator.booleans.MutableBooleanValue
setFalse, setTrue

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

Methods inherited from interface net.sf.jaccumulator.scalars.MutableScalarDomain
assertPrecision, promoteTo

Methods inherited from interface net.sf.jaccumulator.MutableAlgebraicStructure
assertDomain

Methods inherited from interface net.sf.jaccumulator.Mutable
isMutable

- Constructor Detail
  - AbstractDoublePrimitive
```
public AbstractDoublePrimitive()
```
  - AbstractDoublePrimitive
```
public AbstractDoublePrimitive(Domain aDomain)
```
- Method Detail
  - absoluteValue
```
public final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    absoluteValue in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE and(BigInteger aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableReal
    
    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 MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - booleanPostDecrement
```
public final boolean booleanPostDecrement()
                                   throws UnsupportedOperationException,
                                          ArithmeticException,
                                          IllegalArgumentException
```
    Description copied from interface: MutableBooleanValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    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
  - booleanPostIncrement
```
public final boolean booleanPostIncrement()
                                   throws UnsupportedOperationException,
                                          ArithmeticException,
                                          IllegalArgumentException
```
    Description copied from interface: MutableBooleanValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    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
  - booleanValue
```
public final boolean booleanValue()
```
    Returns:
    the property value as a system boolean
  - bytePostDecrement
```
public final byte bytePostDecrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableByteValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    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
  - bytePostIncrement
```
public final byte bytePostIncrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableByteValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    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
  - byteValue
```
public final byte byteValue()
```
    Specified by:
    
    byteValue in interface SealedByteValue
    
    Overrides:
    
    byteValue in class Number
    
    Returns:
    the property value as a system byte
  - charPostDecrement
```
public final char charPostDecrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableCharacterValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    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
  - charPostIncrement
```
public final char charPostIncrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableCharacterValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    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
  - charValue
```
public final char charValue()
```
    Returns:
    the property value as a system char
  - copyUsing
```
public final PRIMITIVE copyUsing(BigDecimal aValue)
```
    Description copied from interface: RealReplicator
    
    Using this real as a factory, produce a new real of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this real initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(BigInteger aValue)
```
    Description copied from interface: RealReplicator
    
    Using this real as a factory, produce a new real of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this real initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(boolean aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(byte aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(char aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(float aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(int aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(long aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(short aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsingPrimitive
```
public final PRIMITIVE copyUsingPrimitive(SealedPrimitive<?> aValue)
```
    Description copied from interface: PrimitiveReplicator
    
    Using this primitive as a factory, produce a new primitive of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this primitive initialized using the specified value
  - copyUsingReal
```
public final PRIMITIVE copyUsingReal(SealedReal<?> aValue)
```
    Description copied from interface: RealReplicator
    
    Using this real as a factory, produce a new real of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this real initialized using the specified value
  - copyUsingScalar
```
public final PRIMITIVE copyUsingScalar(SealedScalar<?> aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this scalar as a factory, produce a new scalar of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - cube
```
public final PRIMITIVE cube()
                                                  throws UnsupportedOperationException,
                                                         IllegalArgumentException,
                                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the cube of itself
    
    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 final PRIMITIVE difference(BigDecimal aValue)
                                                        throws UnsupportedOperationException,
                                                               IllegalArgumentException,
                                                               ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE difference(BigInteger aValue)
                                                        throws UnsupportedOperationException,
                                                               IllegalArgumentException,
                                                               ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - floatPostDecrement
```
public final float floatPostDecrement()
                               throws UnsupportedOperationException,
                                      ArithmeticException,
                                      IllegalArgumentException
```
    Description copied from interface: MutableFloatValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    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
  - floatPostIncrement
```
public final float floatPostIncrement()
                               throws UnsupportedOperationException,
                                      ArithmeticException,
                                      IllegalArgumentException
```
    Description copied from interface: MutableFloatValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    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
  - floatValue
```
public final float floatValue()
```
    Specified by:
    
    floatValue in interface SealedFloatValue
    
    Specified by:
    
    floatValue in class Number
    
    Returns:
    the property value as a system float
  - inducePostDecrement
```
public final <S extends Scalar<?>> S inducePostDecrement(S aTarget)
                                           throws NullPointerException,
                                                  NoSuchElementException,
                                                  UnsupportedOperationException,
                                                  IllegalStateException
```
    Description copied from interface: ScalarInductor
    
    Decrement the value of this scalar then induce its original value into the specified target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which the current value of this scalar will be induced, prior to decrementing
    
    Returns:
    the target
    
    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 primitive cannot be changed
    
    IllegalStateException - this target primitive cannot be changed at this time
  - inducePostIncrement
```
public final <S extends Scalar<?>> S inducePostIncrement(S aTarget)
                                           throws NullPointerException,
                                                  NoSuchElementException,
                                                  UnsupportedOperationException,
                                                  IllegalStateException
```
    Description copied from interface: ScalarInductor
    
    Increment the value of this scalar then induce its original value into the specified target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which the current value of this scalar will be induced, prior to incrementing
    
    Returns:
    the target
    
    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 primitive cannot be changed
    
    IllegalStateException - this target primitive cannot be changed at this time
  - induceRealMaximum
```
public final <REAL extends Real<?>> REAL induceRealMaximum(REAL aTarget)
                                          throws NullPointerException,
                                                 NoSuchElementException,
                                                 UnsupportedOperationException,
                                                 IllegalStateException
```
    Description copied from interface: SealedRealDomain
    
    Induce the maximum domain value into the target
    
    Type Parameters:
    REAL - the target type
    Parameters:
    aTarget - a target into which this domain's maximum value will be induced
    
    Returns:
    the target
    
    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 primitive cannot be changed
    
    IllegalStateException - this target primitive cannot be changed at this time
  - induceRealMinimum
```
public final <REAL extends Real<?>> REAL induceRealMinimum(REAL aTarget)
                                          throws NullPointerException,
                                                 NoSuchElementException,
                                                 UnsupportedOperationException,
                                                 IllegalStateException
```
    Description copied from interface: SealedRealDomain
    
    Induce the minimum domain value into the target
    
    Type Parameters:
    REAL - the target type
    Parameters:
    aTarget - a target into which this domain's minimum value will be induced
    
    Returns:
    the target
    
    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 primitive cannot be changed
    
    IllegalStateException - this target primitive cannot be changed at this time
  - induceRealValue
```
public final <REAL extends Real<?>> REAL induceRealValue(REAL aTarget)
                                        throws NullPointerException,
                                               NoSuchElementException,
                                               UnsupportedOperationException,
                                               IllegalStateException
```
    Description copied from interface: RealInductor
    
    Induce the current value of this real into the specified target
    
    Type Parameters:
    REAL - the target type
    Parameters:
    aTarget - a target into which the current value of this real will be induced
    
    Returns:
    the target
    
    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 primitive cannot be changed
    
    IllegalStateException - this target primitive cannot be changed at this time
  - induceScalarMaximum
```
public final <S extends Scalar<?>> S induceScalarMaximum(S aTarget)
```
    Description copied from interface: SealedScalarDomain
    
    Induce the maximum domain value into the target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which this domain's maximum value will be induced
    
    Returns:
    the target
  - induceScalarMinimum
```
public final <S extends Scalar<?>> S induceScalarMinimum(S aTarget)
```
    Description copied from interface: SealedScalarDomain
    
    Induce the minimum domain value into the target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which this domain's minimum value will be induced
    
    Returns:
    the target
  - induceScalarValue
```
public final <S extends Scalar<?>> S induceScalarValue(S aTarget)
```
    Description copied from interface: ScalarInductor
    
    Induce the current value of this scalar into the specified target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which the current value of this scalar will be induced
    
    Returns:
    the target
  - intPostDecrement
```
public final int intPostDecrement()
                           throws UnsupportedOperationException,
                                  ArithmeticException,
                                  IllegalArgumentException
```
    Description copied from interface: MutableIntegerValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    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
  - intPostIncrement
```
public final int intPostIncrement()
                           throws UnsupportedOperationException,
                                  ArithmeticException,
                                  IllegalArgumentException
```
    Description copied from interface: MutableIntegerValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    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
  - intValue
```
public final int intValue()
```
    Specified by:
    
    intValue in interface SealedIntegerValue
    
    Specified by:
    
    intValue in class Number
    
    Returns:
    the property value as a system int
  - invalidate
```
public final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    invalidate in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - inverse
```
public final PRIMITIVE inverse()
                                                     throws UnsupportedOperationException,
                                                            ArithmeticException,
                                                            IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value its multiplicative inverse (1/x)
    
    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
  - isInfinity
```
public final boolean isInfinity()
```
    Returns:
    true if this number represents either positive or negative infinity
  - isInvalid
```
public final boolean isInvalid()
```
    Returns:
    true if this value does not represent a valid number, such as 0/0 (INVALID)
    See Also:
    INVALID at Wikipedia
  - isMaximum
```
public final boolean isMaximum()
```
    Returns:
    true if this value represents the maximum rational value in the totally ordered set it represents
  - isMinimum
```
public final boolean isMinimum()
```
    Returns:
    true if this value represents the minimum rational value in the totally ordered set it represents
  - isModulo
```
public final boolean isModulo()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the magnitude of a vector into a modulo set, or finite ring. This is not the same as testing whether this object's implementation resembles the specification for the MODULO domain, since that is too specific to implementation machinery. Modulo values, for instance can either be real or imaginary.
    
    Returns:
    true if this value represents the magnitude of a vector into a modulo set, or finite ring
  - isNegative
```
public final boolean isNegative()
```
    Returns:
    true if this value represents a negative value
  - isNegativeFinite
```
public final boolean isNegativeFinite()
```
    Specified by:
    
    isNegativeFinite in interface NumericProperties
    
    Overrides:
    
    isNegativeFinite in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if this value represents a valid, finite and negative value
  - isNegativeInfinity
```
public final boolean isNegativeInfinity()
```
    Returns:
    true if this value represents negative infinity
  - isPositive
```
public final boolean isPositive()
```
    Returns:
    true if this value represents a positive value
  - isPositiveFinite
```
public final boolean isPositiveFinite()
```
    Specified by:
    
    isPositiveFinite in interface NumericProperties
    
    Overrides:
    
    isPositiveFinite in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if this value represents a valid, finite and negative value
  - isPositiveInfinity
```
public final boolean isPositiveInfinity()
```
    Returns:
    true if this value represents positive infinity
  - isReal
```
public final boolean isReal()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the magnitude of a vector into the set of real numbers. This is not the same as testing whether this object's implementation resembles the specification for the REAL domain, since that is too specific to implementation machinery. This more general test also includes real modulo values in its specification.
    
    Returns:
    true if this value represents the magnitude of a vector into the set of real numbers
  - isUnity
```
public final boolean isUnity()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the multiplicative identity in its arithmetic domain. For real numbers this is 1, for matrices it would be the identity matrix and for functions this would be a pass-through.
    
    Returns:
    true if this value represents the multiplicative identity in its domain
  - isZero
```
public final boolean isZero()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the additive identity in its algebraic group. For real numbers this is 0, for matrices this would be the zero matrix and for functions this would map every parameter to zero.
    
    Returns:
    true if this value represents the additive identity in its algebraic group
  - longPostDecrement
```
public final long longPostDecrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableLongValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    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
  - longPostIncrement
```
public final long longPostIncrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableLongValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    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
  - longValue
```
public final long longValue()
```
    Specified by:
    
    longValue in interface SealedLongValue
    
    Specified by:
    
    longValue in class Number
    
    Returns:
    the property value as a system long
  - negate
```
public final PRIMITIVE negate()
                                                    throws UnsupportedOperationException,
                                                           ArithmeticException,
                                                           IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the additive inverse (sign negation) of itself, that is transform it into a number that when added to the original yields zero. (Though additive inverses for non-zero boolean and char values do not exist, these implementations will simply fail silently.)
    
    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 (optional)
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification (optional)
  - not
```
public final PRIMITIVE not()
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current integral binary vector with its one's complement. Decimal values, such as double, will be first converted to unlimited integers before their bits are reversed.
    
    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 final PRIMITIVE or(BigInteger aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Description copied from interface: MutableReal
    
    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 MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - product
```
public final PRIMITIVE product(BigDecimal aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE product(BigInteger aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - quotient
```
public final PRIMITIVE quotient(BigDecimal aValue)
                                                      throws UnsupportedOperationException,
                                                             IllegalArgumentException,
                                                             ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set the value of this scalar to the mathematical quotient between its current value and the specified value
    
    Specified by:
    
    quotient in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotient in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE quotient(BigInteger aValue)
                                                      throws UnsupportedOperationException,
                                                             IllegalArgumentException,
                                                             ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set the value of this scalar to the mathematical quotient between its current value and the specified value
    
    Specified by:
    
    quotient in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotient in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotient in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotient in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotient in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotient in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotient in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotient in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotient in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - round
```
public final PRIMITIVE round(RoundingStrategy aRoundingStrategy)
                                                   throws UnsupportedOperationException,
                                                          IllegalArgumentException,
                                                          ArithmeticException,
                                                          NullPointerException
```
    Description copied from interface: MutableScalar
    
    Round the current value using the specified rounding strategy
    
    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
    
    NullPointerException
  - setMaximum
```
public final PRIMITIVE setMaximum()
                                                        throws UnsupportedOperationException,
                                                               ArithmeticException,
                                                               IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with maximum value available for the implementation's numeric precision. Unlimited values will be replaced with the maximum value available for the most precise system scalar appropriate for the implementation, that is unlimited integer primitives will set themselves to the maximum long value and unlimited decimal primitives will set themselves to the maximum double 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
  - setMinimum
```
public final PRIMITIVE setMinimum()
                                                        throws UnsupportedOperationException,
                                                               ArithmeticException,
                                                               IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with minimum value available for the implementation's numeric precision. Unlimited values will be replaced with the minimum value available for the most precise system scalar appropriate for the implementation, that is unlimited integer primitives will set themselves to the minimum long value and unlimited decimal primitives will set themselves to the minimum double 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
  - setNegativeInfinity
```
public final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setNegativeInfinity in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setNumber in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - setPositiveInfinity
```
public final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setPositiveInfinity in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - setPrimitive
```
public final PRIMITIVE setPrimitive(SealedPrimitive<?> aValue)
                                                          throws UnsupportedOperationException,
                                                                 IllegalArgumentException,
                                                                 ArithmeticException,
                                                                 NullPointerException
```
    Description copied from interface: MutablePrimitive
    
    Set this property to the specified primitive
    
    Specified by:
    
    setPrimitive in interface MutablePrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setPrimitive in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a primitive
    
    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
  - setReal
```
public final PRIMITIVE setReal(BigDecimal aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException,
                                                            NullPointerException
```
    Description copied from interface: MutableUnlimitedDecimalValue
    
    Set this property to the specified unlimited decimal value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - an unlimited decimal value
    
    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
  - setReal
```
public final PRIMITIVE setReal(BigInteger aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException,
                                                            NullPointerException
```
    Description copied from interface: MutableUnlimitedIntegerValue
    
    Set this property to the specified unlimited integer value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - an unlimited integer value
    
    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
  - setReal
```
public final PRIMITIVE setReal(SealedReal<?> aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException,
                                                            NullPointerException
```
    Description copied from interface: MutableReal
    
    Set this property to the specified numeric primitive and answer this object (facilitates chaining)
    
    Specified by:
    
    setReal in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setReal in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a numeric primitive
    
    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
  - setScalar
```
public final PRIMITIVE setScalar(boolean aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableBooleanValue
    
    Set this property to the specified boolean value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a boolean value
    
    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
  - setScalar
```
public final PRIMITIVE setScalar(byte aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableByteValue
    
    Set this property to the specified byte value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a byte value
    
    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
  - setScalar
```
public final PRIMITIVE setScalar(char aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableCharacterValue
    
    Set this property to the specified char value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a char value
    
    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
  - setScalar
```
public final PRIMITIVE setScalar(float aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableFloatValue
    
    Set this property to the specified float value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a float value
    
    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
  - setScalar
```
public final PRIMITIVE setScalar(int aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableIntegerValue
    
    Set this property to the specified int value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - an int value
    
    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
  - setScalar
```
public final PRIMITIVE setScalar(long aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableLongValue
    
    Set this property to the specified long value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a long value
    
    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
  - setScalar
```
public final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setScalar in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - setScalar
```
public final PRIMITIVE setScalar(short aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableShortValue
    
    Set this property to the specified short value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a short value
    
    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
  - setUnity
```
public final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setUnity in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setZero in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - shiftLeft
```
public PRIMITIVE shiftLeft(int count)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Attempt to shift the elements of this tuple to the "left" the specified number of ordinal positions. In a bit sequence this functions resorts to the familiar "left shift" process (e.g., Java <<). In other sequences, the specified number of default values will be prepended to the beginning of the sequence, increasing the ordinal position of all existing elements by the specified count.
    
    Parameters:
    count - the number of default values to be prepended to 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
  - shiftRight
```
public PRIMITIVE shiftRight(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. In a bit sequence this functions resorts to the familiar "right shift" process, with sign 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.
    
    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
  - shiftRightExtendZero
```
public PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    shiftRightExtendZero in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - shortPostDecrement
```
public final short shortPostDecrement()
                               throws UnsupportedOperationException,
                                      ArithmeticException,
                                      IllegalArgumentException
```
    Description copied from interface: MutableShortValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    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
  - shortPostIncrement
```
public final short shortPostIncrement()
                               throws UnsupportedOperationException,
                                      ArithmeticException,
                                      IllegalArgumentException
```
    Description copied from interface: MutableShortValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    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
  - shortValue
```
public final short shortValue()
```
    Specified by:
    
    shortValue in interface SealedShortValue
    
    Overrides:
    
    shortValue in class Number
    
    Returns:
    the property value as a system short
  - signum
```
public final int signum()
```
    Specified by:
    
    signum in interface NumericProperties
    
    Overrides:
    
    signum in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    zero if this number is zero, -1 if this number is negative or +1 if it is positive
  - square
```
public final PRIMITIVE square()
                                                    throws UnsupportedOperationException,
                                                           IllegalArgumentException,
                                                           ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the square of itself
    
    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 final PRIMITIVE sum(BigDecimal aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE sum(BigInteger aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - swapPrimitives
```
public final PRIMITIVE swapPrimitives(Primitive<?> aPrimitive)
```
    Description copied from interface: Primitive
    
    Swap the value of this primitive for the specified one and set the specified primitive's value to the current value of this primitive
    
    Parameters:
    aPrimitive - the primitive to swap with
    
    Returns:
    this primitive
  - toNumber
```
public final Number toNumber()
```
    Returns:
    this object as a best-match, system-supported Number object
  - toString
```
public final String toString()
```
    Specified by:
    
    toString in interface CharSequence
    
    Specified by:
    
    toString in interface SealedKernel
    
    Overrides:
    
    toString in class Object
  - toUnlimitedDecimal
```
public final BigDecimal toUnlimitedDecimal()
```
    Returns:
    the property value as an unlimited decimal property value
  - toUnlimitedInteger
```
public final BigInteger toUnlimitedInteger()
```
    Returns:
    the property value as an unlimited integer property value
  - unlimitedDecimalPostDecrement
```
public final BigDecimal unlimitedDecimalPostDecrement()
                                               throws UnsupportedOperationException,
                                                      ArithmeticException,
                                                      IllegalArgumentException
```
    Description copied from interface: MutableUnlimitedDecimalValue
    
    Decrement the real value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this real
    
    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
  - unlimitedDecimalPostIncrement
```
public final BigDecimal unlimitedDecimalPostIncrement()
                                               throws UnsupportedOperationException,
                                                      ArithmeticException,
                                                      IllegalArgumentException
```
    Description copied from interface: MutableUnlimitedDecimalValue
    
    Increment the real value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this real
    
    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
  - unlimitedIntegerPostDecrement
```
public final BigInteger unlimitedIntegerPostDecrement()
                                               throws UnsupportedOperationException,
                                                      ArithmeticException,
                                                      IllegalArgumentException
```
    Description copied from interface: MutableUnlimitedIntegerValue
    
    Decrement the real value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this real
    
    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
  - unlimitedIntegerPostIncrement
```
public final BigInteger unlimitedIntegerPostIncrement()
                                               throws UnsupportedOperationException,
                                                      ArithmeticException,
                                                      IllegalArgumentException
```
    Description copied from interface: MutableUnlimitedIntegerValue
    
    Increment the real value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this real
    
    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
  - xor
```
public final PRIMITIVE xor(BigInteger aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableReal
    
    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 MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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 final PRIMITIVE 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<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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

Class AbstractDoublePrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

Field Summary

Fields inherited from class net.sf.jaccumulator.scalars.AbstractScalar

Constructor Summary

Method Summary

Methods inherited from class net.sf.jaccumulator.primitives.AbstractNumericPrimitive

Methods inherited from class net.sf.jaccumulator.primitives.AbstractPrimitive

Methods inherited from class net.sf.jaccumulator.reals.AbstractReal

Methods inherited from class net.sf.jaccumulator.scalars.AbstractScalar

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

Methods inherited from interface net.sf.jaccumulator.reals.SealedReal

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

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.CharacterProperties

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

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

Methods inherited from interface net.sf.jaccumulator.reals.SealedRealBag

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

Methods inherited from interface net.sf.jaccumulator.SealedAlgebraicStructure

Methods inherited from interface net.sf.jaccumulator.StructureProperties

Methods inherited from interface net.sf.jaccumulator.reals.RealReplicator

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

Methods inherited from interface net.sf.jaccumulator.Replicator

Methods inherited from interface net.sf.jaccumulator.reals.MutableReal

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.MutableAlgebraicStructure

Methods inherited from interface net.sf.jaccumulator.Mutable

Constructor Detail

AbstractDoublePrimitive

AbstractDoublePrimitive

Method Detail

absoluteValue

and

and

and

and

and

and

and

booleanPostDecrement

booleanPostIncrement

booleanValue

bytePostDecrement

bytePostIncrement

byteValue

charPostDecrement

charPostIncrement

charValue

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsingPrimitive

copyUsingReal

copyUsingScalar

cube

difference

difference

difference

difference

difference

difference

difference

difference

difference

floatPostDecrement

floatPostIncrement

floatValue

inducePostDecrement

inducePostIncrement