AbstractBooleanPrimitive (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.booleans.AbstractBooleanPrimitive<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:

BooleanArrayCursor, BooleanPrimitive
```
public abstract class AbstractBooleanPrimitive<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
extends AbstractNumericPrimitive<PRIMITIVE>
```
Abstract boolean 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

AbstractBooleanPrimitive()

Constructors
Constructor and Description
`AbstractBooleanPrimitive()`

Method Summary

Methods
Modifier and Type	Method and Description
`PRIMITIVE`	`absoluteValue()` Replace the current value with the absolute value of itself
`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
`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(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(double 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`	`decrement()` Replace the current value with the current value minus unity (one)
`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(double 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
`double`	`doublePostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`double`	`doublePostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`double`	`doubleValue()`
`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()`
`StructureStrategy`	`getStructureStrategy()`
`int`	`hashCode()`
`PRIMITIVE`	`increment()` Replace the current value with the current value plus unity (one)
`<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`	`isDigit()` Determine if this `char`-width or `int`-width character is a digit within Unicode
`boolean`	`isFinite()`
`boolean`	`isIdentifierIgnorable()` Determine if this `char`-width or `int`-width character ignorable character in a Java identifier or a Unicode identifier
`boolean`	`isInfinity()`
`boolean`	`isInvalid()`
`boolean`	`isISOControl()` Determine if this `char`-width or `int`-width character is an ISO control character within Unicode
`boolean`	`isJavaIdentifierPart()` Determine if this `char`-width or `int`-width character is a part of a Java identifier as other than the first character
`boolean`	`isJavaIdentifierStart()` Determine if this `char`-width or `int`-width character is permissible as the first character in a Java identifier
`boolean`	`isLetter()` Determine if this `char`-width or `int`-width character is a letter within Unicode
`boolean`	`isLetterOrDigit()` Determine if this `char`-width or `int`-width character is a letter or digit within Unicode
`boolean`	`isLowerCase()` Determine if this `char`-width or `int`-width character is a lower case character within Unicode
`boolean`	`isMaximum()`
`boolean`	`isMinimum()`
`boolean`	`isMirrored()` Determine if this `char`-width or `int`-width character is "mirrored" within Unicode
`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`	`isOrdered()` Answer `true` if the elements of this structure necessarily share a partial or total order between each other within the context of this structure.
`boolean`	`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`	`isTitleCase()` Determine if this `char`-width or `int`-width character is a title case character within Unicode
`boolean`	`isUnicode()` Determine if this `char`-width or `int`-width character is defined within Unicode
`boolean`	`isUnicodeIdentifierPart()` Determine if this `char`-width or `int`-width character is a part of a Unicode identifier as other than the first character
`boolean`	`isUnicodeIdentifierStart()` Determine if this `char`-width or `int`-width character is permissible as the first character in a Unicode identifier
`boolean`	`isUnique()`
`boolean`	`isUnity()` Answer `true` if this value represents the multiplicative identity in its arithmetic domain.
`boolean`	`isUpperCase()` Determine if this `char`-width or `int`-width character is an upper case character within Unicode
`boolean`	`isWhitespace()` Determine if this `char`-width or `int`-width character is whitespace within Unicode
`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`	`lowerCase()` For text-based objects, convert all characters in the text to lower case.
`PRIMITIVE`	`mod(boolean aValue)` Set the value of this scalar to its current value modulo of the specified value
`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`	`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(double 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(boolean aValue)` Set the value of this scalar to the mathematical quotient between 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`	`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(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(double aValue)` Set this property to the specified `double` 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.
`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(double 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
`PRIMITIVE`	`titleCase()` For text-based objects, convert all characters in the text to `title` case.
`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`	`upperCase()` For text-based objects, convert all characters in the text to upper case.
`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, 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, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, replace, replace, replaceAll, replaceCharacter, replaceFirst, reverse, setBoolean, setCharacter, setCharAt, setLength, setNumber, setText, subSequence, substring, substring, textPostDecrement, textPostIncrement, toPrimitive, toPrimitive, trim

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
and, 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, or, orOfNumber, orOfReal, powerOfReal, productOfNumber, productOfReal, quotient, quotient, quotientOfNumber, quotientOfReal, sumOfNumber, sumOfReal, toReal, unlimitedIntegerModularInverse, xor, xorOfNumber, xorOfReal

Methods inherited from class net.sf.jaccumulator.scalars.AbstractScalar
and, 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, 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, isElastic, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqualToScalar, isExpandable, isFalse, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqualToScalar, isGreaterThanScalar, isHighSurrogate, isIdeographic, isImaginary, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqualToScalar, isLessThanScalar, isLowSurrogate, isMutable, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqualToScalar, isReducible, isSupplementaryCodePoint, isSurrogate, isTrue, isValid, isValidCodePoint, longGCD, longMaskAt, longModularInverse, longModularQuotient, longNotMaskAt, longSize, longValue, milliseconds, mod, mod, mod, mod, mod, mod, mod, modOfScalar, nanoseconds, naturalLog, naturalLogPlusOne, or, orOfScalar, power, power, powerOfNumber, powerOfScalar, productOfScalar, promoteTo, quotient, quotient, quotient, quotient, quotient, quotient, quotient, quotientOfScalar, radians, random, setByteBitAt, setCharBitAt, setDoubleBitAt, setE, setEnumeration, setFalse, setFloatBitAt, setIntBitAt, setLongBitAt, setNegativeInfinity, setPi, setPositiveInfinity, setShortBitAt, setTrue, setUnlimitedDecimalBitAt, setUnlimitedIntegerBitAt, shiftRightExtendZero, shortMaskAt, shortNotMaskAt, shortValue, sine, size, squareRoot, sumOfScalar, tangent, toBoolean, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toByteArray, toCharacter, toCodePoint, toEnumeration, toScalar, toUnlimitedInteger, unlimitedIntegerMaskAt, unlimitedIntegerNotMaskAt, up, xor, xorOfScalar

Methods inherited from class java.lang.Object
clone, finalize, getClass, 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

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

Methods inherited from interface net.sf.jaccumulator.scalars.CharacterProperties
isAlphabetic, isBmpCodePoint, isHighSurrogate, isIdeographic, isLowSurrogate, isSupplementaryCodePoint, isSurrogate, isValidCodePoint

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

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, isReducible

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
and, andOfReal, angleWithReal, differenceOfReal, gcd, gcdOfReal, hypotenuseWithReal, mod, mod, modOfReal, or, orOfReal, powerOfReal, productOfReal, quotient, quotient, quotientOfReal, sumOfReal, xor, xorOfReal

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

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

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
  - AbstractBooleanPrimitive
```
public AbstractBooleanPrimitive()
```
- 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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    absoluteValue in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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(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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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
  - 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 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 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 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 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 PRIMITIVE copyUsing(double 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 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 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 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 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 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 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 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
  - decrement
```
public final PRIMITIVE decrement()
                                                                      throws UnsupportedOperationException,
                                                                             IllegalArgumentException,
                                                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the current value minus unity (one)
    
    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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractReal<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractReal<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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(double aValue)
                                                                       throws UnsupportedOperationException,
                                                                              IllegalArgumentException,
                                                                              ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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
  - doublePostDecrement
```
public final double doublePostDecrement()
                                 throws UnsupportedOperationException,
                                        ArithmeticException,
                                        IllegalArgumentException
```
    Description copied from interface: MutableDoubleValue
    
    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
  - doublePostIncrement
```
public final double doublePostIncrement()
                                 throws UnsupportedOperationException,
                                        ArithmeticException,
                                        IllegalArgumentException
```
    Description copied from interface: MutableDoubleValue
    
    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
  - doubleValue
```
public final double doubleValue()
```
    Specified by:
    
    doubleValue in interface SealedDoubleValue
    
    Specified by:
    
    doubleValue in class Number
    
    Returns:
    the property value as a system double
  - 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
  - getStructureStrategy
```
public final StructureStrategy getStructureStrategy()
```
    Specified by:
    
    getStructureStrategy in interface SealedAlgebraicStructure
    
    Overrides:
    
    getStructureStrategy in class AbstractNumericPrimitive<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    a lemma defining the general implementation approach for this structure
  - hashCode
```
public final int hashCode()
```
    Specified by:
    
    hashCode in interface SealedKernel
    
    Overrides:
    
    hashCode in class Object
  - increment
```
public final PRIMITIVE increment()
                                                                      throws UnsupportedOperationException,
                                                                             ArithmeticException,
                                                                             IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the current value plus unity (one)
    
    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
  - 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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    invalidate in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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
  - isDigit
```
public final boolean isDigit()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a digit within Unicode
    
    Specified by:
    
    isDigit in interface CharacterProperties
    
    Overrides:
    
    isDigit in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a digit in Unicode
    See Also:
    Character.isDigit(char), Character.isDigit(int)
  - isFinite
```
public final boolean isFinite()
```
    Specified by:
    
    isFinite in interface NumericProperties
    
    Overrides:
    
    isFinite in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if this value represents a valid and finite value
  - isIdentifierIgnorable
```
public final boolean isIdentifierIgnorable()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character ignorable character in a Java identifier or a Unicode identifier
    
    Specified by:
    
    isIdentifierIgnorable in interface CharacterProperties
    
    Overrides:
    
    isIdentifierIgnorable in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, ignorable character in a Java identifier or a Unicode identifier as other than the first character
    See Also:
    Character.isIdentifierIgnorable(char), Character.isIdentifierIgnorable(int)
  - 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
  - isISOControl
```
public final boolean isISOControl()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is an ISO control character within Unicode
    
    Specified by:
    
    isISOControl in interface CharacterProperties
    
    Overrides:
    
    isISOControl in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is an ISO control character in Unicode
    See Also:
    Character.isISOControl(char), Character.isISOControl(int)
  - isJavaIdentifierPart
```
public final boolean isJavaIdentifierPart()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a part of a Java identifier as other than the first character
    
    Specified by:
    
    isJavaIdentifierPart in interface CharacterProperties
    
    Overrides:
    
    isJavaIdentifierPart in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a part of a Java identifier as other than the first character
    See Also:
    Character.isJavaIdentifierPart(char), Character.isJavaIdentifierPart(int)
  - isJavaIdentifierStart
```
public final boolean isJavaIdentifierStart()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is permissible as the first character in a Java identifier
    
    Specified by:
    
    isJavaIdentifierStart in interface CharacterProperties
    
    Overrides:
    
    isJavaIdentifierStart in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is permissible as the first character in a Java identifier
    See Also:
    Character.isJavaIdentifierStart(char), Character.isJavaIdentifierStart(int)
  - isLetter
```
public final boolean isLetter()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a letter within Unicode
    
    Specified by:
    
    isLetter in interface CharacterProperties
    
    Overrides:
    
    isLetter in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a letter in Unicode
    See Also:
    Character.isLetter(char), Character.isLetter(int)
  - isLetterOrDigit
```
public final boolean isLetterOrDigit()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a letter or digit within Unicode
    
    Specified by:
    
    isLetterOrDigit in interface CharacterProperties
    
    Overrides:
    
    isLetterOrDigit in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a letter or digit in Unicode
    See Also:
    Character.isLetterOrDigit(char), Character.isLetterOrDigit(int)
  - isLowerCase
```
public final boolean isLowerCase()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a lower case character within Unicode
    
    Specified by:
    
    isLowerCase in interface CharacterProperties
    
    Overrides:
    
    isLowerCase in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a lower case character in Unicode
    See Also:
    Character.isLowerCase(char), Character.isLowerCase(int)
  - 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
  - isMirrored
```
public final boolean isMirrored()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is "mirrored" within Unicode
    
    Specified by:
    
    isMirrored in interface CharacterProperties
    
    Overrides:
    
    isMirrored in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is "mirrored" in Unicode
    See Also:
    Character.isMirrored(char), Character.isMirrored(int)
  - 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 AbstractBooleanPrimitive<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
  - isOrdered
```
public final boolean isOrdered()
```
    Description copied from interface: StructureProperties
    
    Answer true if the elements of this structure necessarily share a partial or total order between each other within the context of this structure. Ordering does not necessarily imply a simple sequencing between randomly selected elements, but rather a necessary sorting order between elements independent of the sets they are related by. A SortedSet is ordered, not merely because its elements are de facto sorted, but because the SortedSet defines a universe in which only sortable elements can exist and it defines a sorting function which places those elements in their sorted order at the time of iteration. An ordered set has elements with values that are reflexive, antisymmetric, and transitive relative to each other. Necessarily empty sets are not considered ordered.
    
    Specified by:
    
    isOrdered in interface StructureProperties
    
    Overrides:
    
    isOrdered in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the structure has either a partial or total order over its elements
    See Also:
    order theory (Wikipedia)
  - 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 AbstractBooleanPrimitive<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
  - isTitleCase
```
public final boolean isTitleCase()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a title case character within Unicode
    
    Specified by:
    
    isTitleCase in interface CharacterProperties
    
    Overrides:
    
    isTitleCase in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a title case character in Unicode
    See Also:
    Character.isTitleCase(char), Character.isTitleCase(int)
  - isUnicode
```
public final boolean isUnicode()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is defined within Unicode
    
    Specified by:
    
    isUnicode in interface CharacterProperties
    
    Overrides:
    
    isUnicode in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is defined in Unicode
    See Also:
    Character.isDefined(char), Character.isDefined(int)
  - isUnicodeIdentifierPart
```
public final boolean isUnicodeIdentifierPart()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a part of a Unicode identifier as other than the first character
    
    Specified by:
    
    isUnicodeIdentifierPart in interface CharacterProperties
    
    Overrides:
    
    isUnicodeIdentifierPart in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a part of a Unicode identifier as other than the first character
    See Also:
    Character.isUnicodeIdentifierPart(char), Character.isUnicodeIdentifierPart(int)
  - isUnicodeIdentifierStart
```
public final boolean isUnicodeIdentifierStart()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is permissible as the first character in a Unicode identifier
    
    Specified by:
    
    isUnicodeIdentifierStart in interface CharacterProperties
    
    Overrides:
    
    isUnicodeIdentifierStart in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is permissible as the first character in a Unicode identifier
    See Also:
    Character.isUnicodeIdentifierStart(char), Character.isUnicodeIdentifierStart(int)
  - isUnique
```
public final boolean isUnique()
```
    Specified by:
    
    isUnique in interface StructureProperties
    
    Overrides:
    
    isUnique in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the elements in this structure are, by definition of the structure's algebra, unique (e.g., sets)
  - 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
  - isUpperCase
```
public final boolean isUpperCase()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is an upper case character within Unicode
    
    Specified by:
    
    isUpperCase in interface CharacterProperties
    
    Overrides:
    
    isUpperCase in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is an upper case character in Unicode
    See Also:
    Character.isUpperCase(char), Character.isUpperCase(int)
  - isWhitespace
```
public final boolean isWhitespace()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is whitespace within Unicode
    
    Specified by:
    
    isWhitespace in interface CharacterProperties
    
    Overrides:
    
    isWhitespace in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is whitespace in Unicode
    See Also:
    Character.isWhitespace(char), Character.isWhitespace(int)
  - 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
  - lowerCase
```
public final PRIMITIVE lowerCase()
```
    Description copied from interface: MutableTextValue
    
    For text-based objects, convert all characters in the text to lower case. For numeric objects, convert their character (BMP) or integer value (Unicode) to lower case, depending on the object's precision level
    
    Specified by:
    
    lowerCase in interface MutableTextValue<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    lowerCase in class AbstractNumericPrimitive<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
  - mod
```
public final PRIMITIVE mod(boolean aValue)
                                                                throws UnsupportedOperationException,
                                                                       IllegalArgumentException,
                                                                       ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to its current value modulo of the specified value
    
    Specified by:
    
    mod in interface MutableScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    mod in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - 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)
  - 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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractReal<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractReal<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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(double aValue)
                                                                    throws UnsupportedOperationException,
                                                                           IllegalArgumentException,
                                                                           ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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(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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    quotient in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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
  - 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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    setPrimitive in class AbstractNumericPrimitive<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    setReal in class AbstractNumericPrimitive<PRIMITIVE extends AbstractBooleanPrimitive<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(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(double aValue)
                                                                      throws UnsupportedOperationException,
                                                                             IllegalArgumentException,
                                                                             ArithmeticException
```
    Description copied from interface: MutableDoubleValue
    
    Set this property to the specified double value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a double 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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    setScalar in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    setUnity in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    setZero in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 final 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 final 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
  - 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 AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractReal<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractReal<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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(double aValue)
                                                                throws UnsupportedOperationException,
                                                                       IllegalArgumentException,
                                                                       ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableScalar<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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
  - titleCase
```
public final PRIMITIVE titleCase()
```
    Description copied from interface: MutableTextValue
    
    For text-based objects, convert all characters in the text to title case. For numeric objects, convert their character (BMP) or integer value (Unicode) to title case, depending on the object's precision level
    
    Specified by:
    
    titleCase in interface MutableTextValue<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    titleCase in class AbstractNumericPrimitive<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
  - 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
  - upperCase
```
public final PRIMITIVE upperCase()
```
    Description copied from interface: MutableTextValue
    
    For text-based objects, convert all characters in the text to upper case. For numeric objects, convert their character (BMP) or integer value (Unicode) to upper case, depending on the object's precision level
    
    Specified by:
    
    upperCase in interface MutableTextValue<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    upperCase in class AbstractNumericPrimitive<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
  - 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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends AbstractBooleanPrimitive<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 AbstractBooleanPrimitive<PRIMITIVE extends AbstractBooleanPrimitive<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.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.booleans.SealedBooleanValue

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.scalars.MutableScalarDomain

Methods inherited from interface net.sf.jaccumulator.MutableAlgebraicStructure

Methods inherited from interface net.sf.jaccumulator.Mutable

Constructor Detail

AbstractBooleanPrimitive

Method Detail

absoluteValue

and

and

and

and

and

booleanPostDecrement

booleanPostIncrement

bytePostDecrement

bytePostIncrement

byteValue

charPostDecrement

charPostIncrement

charValue

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsingPrimitive

copyUsingReal

copyUsingScalar

cube

decrement

difference

difference

difference

difference

difference

difference

difference

difference

difference

difference

doublePostDecrement

doublePostIncrement

doubleValue

floatPostDecrement

floatPostIncrement

floatValue

getStructureStrategy

hashCode

increment