AbstractTextPrimitive (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.texts.AbstractTextPrimitive<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:

TextPrimitive
```
public abstract class AbstractTextPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
extends AbstractPrimitive<PRIMITIVE>
```
A text 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
`AbstractTextPrimitive()`
`AbstractTextPrimitive(PrimitiveAction<Primitive<?>> aPrimitiveTranslator)`
`AbstractTextPrimitive(PrimitiveAction<Primitive<?>> aPrimitiveTranslator, PrimitiveAction<Primitive<?>> aRealTranslator)`
`AbstractTextPrimitive(PrimitiveAction<Primitive<?>> aPrimitiveTranslator, PrimitiveAction<Primitive<?>> aRealTranslator, PrimitiveAction<Primitive<?>> aScalarTranslator)`

Method Summary

Methods
Modifier and Type	Method and Description
`PRIMITIVE`	`absoluteValue()` Replace the current value with the absolute value of itself
`PRIMITIVE`	`andOfNumber(Number aNumber)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`andOfReal(SealedReal<?> aReal)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`angleWithReal(SealedReal<?> y)` Set this value to the angle formed by the rectangular coordinates given by the current value, x, and the specified value, y.
`boolean`	`booleanPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`boolean`	`booleanPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`boolean`	`booleanValue()`
`byte`	`bytePostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`byte`	`bytePostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`byte`	`byteValue()`
`char`	`charPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`char`	`charPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`char`	`charValue()`
`PRIMITIVE`	`clearContents()` Clear all elements of this structure and answer this object (facilitates chaining}. For text primitives all characters will be removed in an exact analog to `clear()`.
`PRIMITIVE`	`clearText()` Clear all characters from this primitive and re-interpret/re-set
`int`	`compareTo(SealedPrimitive<?> aPrimitive)`
`int`	`compareToNumber(Number aValue)` Compares this object with the specified object for order
`int`	`compareToPrimitive(SealedPrimitive<?> aPrimitive)` Compares this object with the specified object for order
`int`	`compareToReal(SealedReal<?> aReal)` Compares this object with the specified object for order
`PRIMITIVE`	`copyUsing(BigDecimal aValue)` Using this real as a factory, produce a new real of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsing(BigInteger aValue)` Using this real as a factory, produce a new real of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsing(boolean aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(byte aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(char aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(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`	`differenceOfNumber(Number aNumber)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`differenceOfReal(SealedReal<?> aReal)` 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()`
`boolean`	`equals(Object anObject)`
`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()`
`PrimitiveAction<Primitive<?>>`	`getPrimitiveTranslator()`
`PrimitiveAction<Primitive<?>>`	`getRealTranslator()`
`PrimitiveAction<Primitive<?>>`	`getScalarTranslator()`
`StructureStrategy`	`getStructureStrategy()`
`int`	`hashCode()`
`PRIMITIVE`	`increment()` Replace the current value with the current value plus unity (one)
`<P extends Primitive<?>> P`	`inducePostDecrement(P aTarget)` Decrement the value of this Primitive then induce its original value into the specified target
`<R extends Real<?>> R`	`inducePostDecrement(R aTarget)` Decrement the value of this real then induce its original value into the specified target
`<S extends Scalar<?>> S`	`inducePostDecrement(S aTarget)` Decrement the value of this scalar then induce its original value into the specified target
`<P extends Primitive<?>> P`	`inducePostIncrement(P aTarget)` Increment the value of this Primitive then induce its original value into the specified target
`<R extends Real<?>> R`	`inducePostIncrement(R aTarget)` Increment the value of this real 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
`<P extends Primitive<?>> P`	`inducePrimitiveValue(P aTarget)` Induce the current value of this Primitive into the specified target
`<R extends Real<?>> R`	`induceRealMaximum(R aTarget)` Induce the maximum domain value into the target
`<R extends Real<?>> R`	`induceRealMinimum(R aTarget)` Induce the minimum domain value into the target
`<R extends Real<?>> R`	`induceRealValue(R 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`	`isConfigurable()` Answer `true` if the implementation of this object can be changed. A configurable object has a structure that can be `expanded`, or `reduced`, or has replaceable components.
`boolean`	`isElastic()` Answer `true` if this structure, in principle, can be reduced via element removal or expanded via element addition.
`boolean`	`isEqualToNumber(Number aValue)`
`boolean`	`isEqualToPrimitive(SealedPrimitive<?> aPrimitive)`
`boolean`	`isEqualToReal(SealedReal<?> aReal)`
`boolean`	`isEqualToScalar(SealedScalar<?> aScalar)`
`boolean`	`isEqualToText(CharSequence aValue)`
`boolean`	`isExpandable()`
`boolean`	`isGreaterOrEqualToNumber(Number aValue)`
`boolean`	`isGreaterOrEqualToPrimitive(SealedPrimitive<?> aPrimitive)`
`boolean`	`isGreaterOrEqualToReal(SealedReal<?> aReal)`
`boolean`	`isGreaterOrEqualToScalar(SealedScalar<?> aScalar)`
`boolean`	`isGreaterOrEqualToText(CharSequence aValue)`
`boolean`	`isGreaterThanNumber(Number aValue)`
`boolean`	`isGreaterThanPrimitive(SealedPrimitive<?> aPrimitive)`
`boolean`	`isGreaterThanReal(SealedReal<?> aReal)`
`boolean`	`isGreaterThanScalar(SealedScalar<?> aScalar)`
`boolean`	`isGreaterThanText(CharSequence aValue)`
`boolean`	`isInfinity()`
`boolean`	`isInvalid()`
`boolean`	`isLessOrEqualToNumber(Number aValue)`
`boolean`	`isLessOrEqualToPrimitive(SealedPrimitive<?> aPrimitive)`
`boolean`	`isLessOrEqualToReal(SealedReal<?> aReal)`
`boolean`	`isLessOrEqualToScalar(SealedScalar<?> aScalar)`
`boolean`	`isLessOrEqualToText(CharSequence aValue)`
`boolean`	`isLessThanNumber(Number aValue)`
`boolean`	`isLessThanPrimitive(SealedPrimitive<?> aPrimitive)`
`boolean`	`isLessThanReal(SealedReal<?> aReal)`
`boolean`	`isLessThanScalar(SealedScalar<?> aScalar)`
`boolean`	`isLessThanText(CharSequence aValue)`
`boolean`	`isMaximum()`
`boolean`	`isMinimum()`
`boolean`	`isModulo()` Answer `true` if this value represents the magnitude of a vector into a modulo set, or finite ring.
`boolean`	`isNegative()`
`boolean`	`isNegativeFinite()`
`boolean`	`isNegativeInfinity()`
`boolean`	`isNotEqualToNumber(Number aValue)`
`boolean`	`isNotEqualToPrimitive(SealedPrimitive<?> aPrimitive)`
`boolean`	`isNotEqualToReal(SealedReal<?> aReal)`
`boolean`	`isNotEqualToScalar(SealedScalar<?> aScalar)`
`boolean`	`isNotEqualToText(CharSequence aValue)`
`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`	`isReducible()` Answer `true` if this structure, in principle, can be reduced via element removal.
`boolean`	`isText()`
`boolean`	`isUnity()` Answer `true` if this value represents the multiplicative identity in its arithmetic domain.
`boolean`	`isZero()` Answer `true` if this value represents the additive identity in its algebraic group.
`long`	`longPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`long`	`longPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`long`	`longValue()`
`PRIMITIVE`	`modOfNumber(Number aNumber)` Set the value of this scalar to its current value modulo of the specified value
`PRIMITIVE`	`modOfReal(SealedReal<?> aReal)` 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`	`not()` Replace the current integral binary vector with its one's complement.
`PRIMITIVE`	`orOfNumber(Number aNumber)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`orOfReal(SealedReal<?> aReal)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`powerOfReal(SealedReal<?> aReal)` Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
`PRIMITIVE`	`productOfNumber(Number aNumber)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`productOfReal(SealedReal<?> aReal)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`quotientOfNumber(Number aNumber)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`PRIMITIVE`	`quotientOfReal(SealedReal<?> aReal)` 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`	`setBoolean(Boolean aValue)` Set this property to the specified system-supported `Boolean` and answer this object (facilitates chaining)
`PRIMITIVE`	`setCharacter(Character aValue)` Set this property to the specified system-supported `Character` and answer this object (facilitates chaining)
`<E extends Enum<E>> PRIMITIVE`	`setEnumeration(E aValue)` Match the value of this object with the identity of the specified `enumeration` instance, then answer this object (facilitates chaining)
`PRIMITIVE`	`setMaximum()` Replace the current value with maximum value available for the implementation's numeric `precision`.
`PRIMITIVE`	`setMinimum()` Replace the current value with minimum value available for the implementation's numeric `precision`.
`PRIMITIVE`	`setNegativeInfinity()` Replace the current value with a representation of negative infinity, if available, otherwise replace with the implementation's `minimum` value
`PRIMITIVE`	`setNumber(Number aValue)` Set this object to the specified system-supported `Number` and answer this object (facilitates chaining)
`PRIMITIVE`	`setPositiveInfinity()` Replace the current value with a representation of positive infinity, if available, otherwise replace with the implementation's `maximum` value
`PRIMITIVE`	`setPrimitive(SealedPrimitive<?> aValue)` Set this property to the specified primitive
`PRIMITIVE`	`setReal(BigDecimal aValue)` Set this property to the specified unlimited `decimal` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setReal(BigInteger aValue)` Set this property to the specified unlimited `integer` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setReal(SealedReal<?> aReal)` Set this property to the specified numeric `primitive` and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(boolean aValue)` Set this property to the specified `boolean` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(byte aValue)` Set this property to the specified `byte` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(char aValue)` Set this property to the specified `char` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(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(short aValue)` Set this property to the specified `short` value and answer this object (facilitates chaining)
`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()`
`int`	`size()` Returns the number of elements in this algebraic structure.
`PRIMITIVE`	`square()` Replace the current value with the square of itself
`PRIMITIVE`	`sumOfNumber(Number aNumber)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`PRIMITIVE`	`sumOfReal(SealedReal<?> aReal)` 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
`String`	`textPostDecrement()` Decrement the real value of this text then return the original text prior to decrementing
`String`	`textPostIncrement()` Increment the real value of this text then return the original text prior to incrementing
`int`	`toCodePoint()` Represent the value of this object as a code point
`<E extends Enum<E>> E`	`toEnumeration(Class<E> anEnumerationClass)` Represent the value of this object as an appropriate member of the class of the specified `enumeration`
`static String`	`toLowerFirstCamelCase(String aName)`
`Number`	`toNumber()`
`Real<?>`	`toReal()` If this real is already a `real` number real then simply call its `Replicator.copy()` function, otherwise produce a new real number real
`Scalar<?>`	`toScalar()` If this scalar is already a `scalar` then simply call its `Replicator.copy()` function, otherwise produce a new scalar with scalar precision
`BigDecimal`	`toUnlimitedDecimal()`
`BigInteger`	`toUnlimitedInteger()`
`static String`	`toUpperFirst(String aWord)`
`static String`	`toUpperFirstCamelCase(String aName)`
`PRIMITIVE`	`trim()` Remove both leading and trailing `whitespace`
`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`	`xorOfNumber(Number aNumber)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`xorOfReal(SealedReal<?> aReal)` 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.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, compareToReal, compareToReal, difference, difference, gcd, gcdOfNumber, gcdOfReal, hypotenuseWithReal, induceRealSize, isEqual, isEqual, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isLess, isLess, isLessOrEqual, isLessOrEqual, isNotEqual, isNotEqual, mod, mod, or, product, product, quotient, quotient, sum, sum, unlimitedIntegerModularInverse, xor

Methods inherited from class net.sf.jaccumulator.scalars.AbstractScalar
and, and, and, and, and, 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, difference, difference, difference, difference, difference, difference, difference, difference, differenceOfScalar, divideByZero, down, exponential, exponentialLessOne, floor, gcd, gcd, gcd, gcd, gcd, gcdOfScalar, getBooleanBitAt, getByteBitAt, getCharBitAt, getDomain, getDoubleBitAt, getFloatBitAt, getIntBitAt, getLongBitAt, getPrecision, getShortBitAt, getUnlimitedDecimalBitAt, getUnlimitedIntegerBitAt, halfDown, halfEven, halfUp, hashCode, hashCode, hashCode, hashCode, hashCode, hashCode, hashCode, hashCode, hyperbolicCosine, hyperbolicSine, hyperbolicTangent, hypotenuseWith, hypotenuseWithNumber, hypotenuseWithScalar, indexOutOfBoundsAt, induceScalarSize, intGCD, intMaskAt, intModularInverse, intModularQuotient, intNotMaskAt, intValue, isAlphabetic, isBmpCodePoint, isCountable, isDigit, isEmpty, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isFalse, isFinite, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isHighSurrogate, isIdentifierIgnorable, isIdeographic, isImaginary, isISOControl, isJavaIdentifierPart, isJavaIdentifierStart, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLetter, isLetterOrDigit, isLowerCase, isLowSurrogate, isMirrored, isMutable, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isSupplementaryCodePoint, isSurrogate, isTitleCase, isTrue, isUnicode, isUnicodeIdentifierPart, isUnicodeIdentifierStart, isUnique, isUpperCase, isValid, isValidCodePoint, isWhitespace, longGCD, longMaskAt, longModularInverse, longModularQuotient, longNotMaskAt, longSize, longValue, milliseconds, mod, mod, mod, mod, mod, mod, mod, mod, modOfScalar, nanoseconds, naturalLog, naturalLogPlusOne, or, or, or, or, or, or, orOfScalar, power, power, powerOfNumber, powerOfScalar, product, product, product, product, product, product, product, product, productOfScalar, promoteTo, quotient, quotient, quotient, quotient, quotient, quotient, quotient, quotient, quotientOfScalar, radians, random, setByteBitAt, setCharBitAt, setDoubleBitAt, setE, setFalse, setFloatBitAt, setIntBitAt, setLongBitAt, setPi, setScalar, setShortBitAt, setTrue, setUnity, setUnlimitedDecimalBitAt, setUnlimitedIntegerBitAt, setZero, shiftRightExtendZero, shortMaskAt, shortNotMaskAt, shortValue, sine, squareRoot, sum, sum, sum, sum, sum, sum, sum, sum, sumOfScalar, tangent, toBoolean, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toByteArray, toCharacter, toUnlimitedInteger, unlimitedIntegerMaskAt, unlimitedIntegerNotMaskAt, up, xor, xor, xor, xor, xor, xor, xorOfScalar

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

Methods inherited from interface net.sf.jaccumulator.primitives.PrimitiveReplicator
copyUsingText

Methods inherited from interface net.sf.jaccumulator.reals.SealedReal
compareToReal, compareToReal, isEqual, isEqual, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isLess, isLess, isLessOrEqual, isLessOrEqual, isNotEqual, isNotEqual

Methods inherited from interface net.sf.jaccumulator.scalars.SealedScalar
compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToZero, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isFalse, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isTrue, toBoolean, toCharacter

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

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

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

Methods inherited from interface net.sf.jaccumulator.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

Methods inherited from interface net.sf.jaccumulator.StructureProperties
isCountable, isEmpty, isUnique

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

Methods inherited from interface net.sf.jaccumulator.reals.MutableReal
and, difference, difference, gcd, gcdOfReal, hypotenuseWithReal, mod, mod, or, product, product, quotient, quotient, sum, sum, xor

Methods inherited from interface net.sf.jaccumulator.scalars.MutableScalar
and, and, and, and, and, and, andOfScalar, angleWith, angleWithNumber, angleWithScalar, arcCosine, arcSine, arcTangent, base10Log, ceiling, cosine, cubeRoot, degrees, difference, difference, difference, difference, difference, difference, difference, difference, 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, mod, modOfScalar, nanoseconds, naturalLog, naturalLogPlusOne, or, or, or, or, or, or, orOfScalar, power, power, powerOfNumber, powerOfScalar, product, product, product, product, product, product, product, product, productOfScalar, quotient, quotient, quotient, quotient, quotient, quotient, quotient, quotient, quotientOfScalar, radians, random, setE, setPi, setScalar, setUnity, setZero, shiftRightExtendZero, sine, squareRoot, sum, sum, sum, sum, sum, sum, sum, sum, sumOfScalar, tangent, up, xor, xor, xor, xor, xor, xor, xorOfScalar

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.texts.TextInductor
induceTextValue

Methods inherited from interface net.sf.jaccumulator.texts.TextReplicator
copyUsingText

Methods inherited from interface net.sf.jaccumulator.texts.SealedTextValue
codePointAt, codePointBefore, codePointCount, indexOfText, indexOfText, substring, substring

Methods inherited from interface java.lang.CharSequence
charAt, length, subSequence, toString

Methods inherited from interface net.sf.jaccumulator.texts.TextProperties
isEmpty

Methods inherited from interface net.sf.jaccumulator.texts.MutableTextValue
append, append, append, append, append, append, append, append, append, append, append, append, append, append, appendCodePoint, clear, delete, deleteCharAt, insert, insert, insert, insert, insert, insert, insert, insert, insert, insert, insert, insert, lowerCase, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, replace, replace, replaceAll, replaceCharacter, replaceFirst, reverse, setCharAt, setLength, setText, titleCase, upperCase

- Constructor Detail
  - AbstractTextPrimitive
```
public AbstractTextPrimitive()
```
  - AbstractTextPrimitive
```
public AbstractTextPrimitive(PrimitiveAction<Primitive<?>> aPrimitiveTranslator)
```
  - AbstractTextPrimitive
```
public AbstractTextPrimitive(PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
                     PrimitiveAction<Primitive<?>> aRealTranslator)
```
  - AbstractTextPrimitive
```
public AbstractTextPrimitive(PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
                     PrimitiveAction<Primitive<?>> aRealTranslator,
                     PrimitiveAction<Primitive<?>> aScalarTranslator)
```
- Method Detail
  - absoluteValue
```
public final PRIMITIVE absoluteValue()
                                                           throws UnsupportedOperationException,
                                                                  ArithmeticException,
                                                                  IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the absolute value of itself
    
    Specified by:
    
    absoluteValue in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    absoluteValue in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - andOfNumber
```
public final PRIMITIVE andOfNumber(Number aNumber)
                                                         throws UnsupportedOperationException,
                                                                IllegalArgumentException,
                                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    andOfNumber in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    andOfNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aNumber - 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
  - andOfReal
```
public final PRIMITIVE andOfReal(SealedReal<?> aReal)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    andOfReal in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    andOfReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aReal - 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
  - angleWithReal
```
public final PRIMITIVE angleWithReal(SealedReal<?> y)
                                                           throws UnsupportedOperationException,
                                                                  IllegalArgumentException,
                                                                  ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set this value to the angle formed by the rectangular coordinates given by the current value, x, and the specified value, y. In other words returns the angle theta from the conversion of rectangular coordinates (x,y) to polar coordinates (r,theta).
    
    Specified by:
    
    angleWithReal in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    angleWithReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    y - a y coordinate value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    Math.atan2(double, double)
  - booleanPostDecrement
```
public final boolean booleanPostDecrement()
                                   throws UnsupportedOperationException,
                                          ArithmeticException,
                                          IllegalArgumentException
```
    Description copied from interface: MutableBooleanValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - booleanPostIncrement
```
public final boolean booleanPostIncrement()
                                   throws UnsupportedOperationException,
                                          ArithmeticException,
                                          IllegalArgumentException
```
    Description copied from interface: MutableBooleanValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - booleanValue
```
public final boolean booleanValue()
```
    Returns:
    the property value as a system boolean
  - bytePostDecrement
```
public final byte bytePostDecrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableByteValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - bytePostIncrement
```
public final byte bytePostIncrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableByteValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - byteValue
```
public final byte byteValue()
```
    Specified by:
    
    byteValue in interface SealedByteValue
    
    Overrides:
    
    byteValue in class Number
    
    Returns:
    the property value as a system byte
  - charPostDecrement
```
public final char charPostDecrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableCharacterValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - charPostIncrement
```
public final char charPostIncrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableCharacterValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - charValue
```
public final char charValue()
```
    Returns:
    the property value as a system char
  - clearContents
```
public final PRIMITIVE clearContents()
                                                           throws UnsupportedOperationException
```
    Description copied from interface: MutableAlgebraicStructure
    
    Clear all elements of this structure and answer this object (facilitates chaining}.
    
    For text primitives all characters will be removed in an exact analog to clear(). For bit tuples such as scalar primitives, this will reset all bits zero since those elements cannot be removed. For unlimited primitives all bytes in the representation will be removed, producing zero.
    
    Primarily, this function is provided as an alternative to clear(), which does not return a value. This function, in answering this object, facilitates operation chaining.
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    See Also:
    MutableAlgebraicStructure.clear(), Collection.clear(), MutableTextValue.clearText();
  - clearText
```
public final PRIMITIVE clearText()
                                                       throws UnsupportedOperationException
```
    Description copied from interface: MutableTextValue
    
    Clear all characters from this primitive and re-interpret/re-set
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's text cannot be changed
    See Also:
    MutableTextValue.clear();, Collection.clear(), MutableAlgebraicStructure.clearContents()
  - compareTo
```
public final int compareTo(SealedPrimitive<?> aPrimitive)
```
  - compareToNumber
```
public final int compareToNumber(Number aValue)
```
    Description copied from interface: SealedScalar
    
    Compares this object with the specified object for order
    
    Specified by:
    
    compareToNumber in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    compareToNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - an object to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified object.
    See Also:
    Comparable.compareTo(Object)
  - compareToPrimitive
```
public final int compareToPrimitive(SealedPrimitive<?> aPrimitive)
```
    Description copied from interface: SealedPrimitive
    
    Compares this object with the specified object for order
    
    Parameters:
    aPrimitive - an object to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified object.
    See Also:
    Comparable.compareTo(Object)
  - compareToReal
```
public final int compareToReal(SealedReal<?> aReal)
```
    Description copied from interface: SealedReal
    
    Compares this object with the specified object for order
    
    Specified by:
    
    compareToReal in interface SealedReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    compareToReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aReal - an object to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified object.
    See Also:
    Comparable.compareTo(Object)
  - copyUsing
```
public final PRIMITIVE copyUsing(BigDecimal aValue)
```
    Description copied from interface: RealReplicator
    
    Using this real as a factory, produce a new real of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this real initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(BigInteger aValue)
```
    Description copied from interface: RealReplicator
    
    Using this real as a factory, produce a new real of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this real initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(boolean aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(byte aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(char aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(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 final PRIMITIVE copyUsing(float aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(int aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(long aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(short aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsingPrimitive
```
public final PRIMITIVE copyUsingPrimitive(SealedPrimitive<?> aValue)
```
    Description copied from interface: PrimitiveReplicator
    
    Using this primitive as a factory, produce a new primitive of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this primitive initialized using the specified value
  - copyUsingReal
```
public final PRIMITIVE copyUsingReal(SealedReal<?> aValue)
```
    Description copied from interface: RealReplicator
    
    Using this real as a factory, produce a new real of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this real initialized using the specified value
  - copyUsingScalar
```
public final PRIMITIVE copyUsingScalar(SealedScalar<?> aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this scalar as a factory, produce a new scalar of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - cube
```
public final PRIMITIVE cube()
                                                  throws UnsupportedOperationException,
                                                         IllegalArgumentException,
                                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the cube of itself
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - 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
  - differenceOfNumber
```
public final PRIMITIVE differenceOfNumber(Number aNumber)
                                                                throws UnsupportedOperationException,
                                                                       IllegalArgumentException,
                                                                       ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    differenceOfNumber in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    differenceOfNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aNumber - 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
  - differenceOfReal
```
public final PRIMITIVE differenceOfReal(SealedReal<?> aReal)
                                                              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:
    
    differenceOfReal in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    differenceOfReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aReal - 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
  - equals
```
public final boolean equals(Object anObject)
```
    Specified by:
    
    equals in interface SealedKernel
    
    Overrides:
    
    equals in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - 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
  - getPrimitiveTranslator
```
public final PrimitiveAction<Primitive<?>> getPrimitiveTranslator()
```
  - getRealTranslator
```
public final PrimitiveAction<Primitive<?>> getRealTranslator()
```
  - getScalarTranslator
```
public final PrimitiveAction<Primitive<?>> getScalarTranslator()
```
  - getStructureStrategy
```
public final StructureStrategy getStructureStrategy()
```
    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,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    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
    
    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
  - inducePostDecrement
```
public final <P extends Primitive<?>> P inducePostDecrement(P aTarget)
                                              throws NullPointerException,
                                                     NoSuchElementException,
                                                     UnsupportedOperationException,
                                                     IllegalStateException
```
    Description copied from interface: PrimitiveInductor
    
    Decrement the value of this Primitive then induce its original value into the specified target
    
    Type Parameters:
    P - the target type
    Parameters:
    aTarget - a target into which the current value of this Primitive 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
  - inducePostDecrement
```
public final <R extends Real<?>> R inducePostDecrement(R aTarget)
                                         throws NullPointerException,
                                                NoSuchElementException,
                                                UnsupportedOperationException,
                                                IllegalStateException
```
    Description copied from interface: RealInductor
    
    Decrement the value of this real then induce its original value into the specified target
    
    Type Parameters:
    R - the target type
    Parameters:
    aTarget - a target into which the current value of this real 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
  - 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 <P extends Primitive<?>> P inducePostIncrement(P aTarget)
                                              throws NullPointerException,
                                                     NoSuchElementException,
                                                     UnsupportedOperationException,
                                                     IllegalStateException
```
    Description copied from interface: PrimitiveInductor
    
    Increment the value of this Primitive then induce its original value into the specified target
    
    Type Parameters:
    P - the target type
    Parameters:
    aTarget - a target into which the current value of this Primitive 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
  - inducePostIncrement
```
public final <R extends Real<?>> R inducePostIncrement(R aTarget)
                                         throws NullPointerException,
                                                NoSuchElementException,
                                                UnsupportedOperationException,
                                                IllegalStateException
```
    Description copied from interface: RealInductor
    
    Increment the value of this real then induce its original value into the specified target
    
    Type Parameters:
    R - the target type
    Parameters:
    aTarget - a target into which the current value of this real 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
  - 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
  - inducePrimitiveValue
```
public final <P extends Primitive<?>> P inducePrimitiveValue(P aTarget)
```
    Description copied from interface: PrimitiveInductor
    
    Induce the current value of this Primitive into the specified target
    
    Type Parameters:
    P - the target type
    Parameters:
    aTarget - a target into which the current value of this Primitive will be induced
    
    Returns:
    the target
  - induceRealMaximum
```
public final <R extends Real<?>> R induceRealMaximum(R aTarget)
```
    Description copied from interface: SealedRealDomain
    
    Induce the maximum domain value into the target
    
    Type Parameters:
    R - the target type
    Parameters:
    aTarget - a target into which this domain's maximum value will be induced
    
    Returns:
    the target
  - induceRealMinimum
```
public final <R extends Real<?>> R induceRealMinimum(R aTarget)
```
    Description copied from interface: SealedRealDomain
    
    Induce the minimum domain value into the target
    
    Type Parameters:
    R - the target type
    Parameters:
    aTarget - a target into which this domain's minimum value will be induced
    
    Returns:
    the target
  - induceRealValue
```
public final <R extends Real<?>> R induceRealValue(R aTarget)
```
    Description copied from interface: RealInductor
    
    Induce the current value of this real into the specified target
    
    Type Parameters:
    R - the target type
    Parameters:
    aTarget - a target into which the current value of this real will be induced
    
    Returns:
    the target
  - induceScalarMaximum
```
public final <S extends Scalar<?>> S induceScalarMaximum(S aTarget)
```
    Description copied from interface: SealedScalarDomain
    
    Induce the maximum domain value into the target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which this domain's maximum value will be induced
    
    Returns:
    the target
  - induceScalarMinimum
```
public final <S extends Scalar<?>> S induceScalarMinimum(S aTarget)
```
    Description copied from interface: SealedScalarDomain
    
    Induce the minimum domain value into the target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which this domain's minimum value will be induced
    
    Returns:
    the target
  - induceScalarValue
```
public final <S extends Scalar<?>> S induceScalarValue(S aTarget)
```
    Description copied from interface: ScalarInductor
    
    Induce the current value of this scalar into the specified target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which the current value of this scalar will be induced
    
    Returns:
    the target
  - intPostDecrement
```
public final int intPostDecrement()
                           throws UnsupportedOperationException,
                                  ArithmeticException,
                                  IllegalArgumentException
```
    Description copied from interface: MutableIntegerValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - intPostIncrement
```
public final int intPostIncrement()
                           throws UnsupportedOperationException,
                                  ArithmeticException,
                                  IllegalArgumentException
```
    Description copied from interface: MutableIntegerValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - intValue
```
public final int intValue()
```
    Specified by:
    
    intValue in interface SealedIntegerValue
    
    Specified by:
    
    intValue in class Number
    
    Returns:
    the property value as a system int
  - invalidate
```
public final PRIMITIVE invalidate()
                                                        throws UnsupportedOperationException,
                                                               ArithmeticException,
                                                               IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value an invalid value such INVALID if possible, otherwise replace it with zero
    
    Specified by:
    
    invalidate in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    invalidate in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - inverse
```
public final PRIMITIVE inverse()
                                                     throws UnsupportedOperationException,
                                                            ArithmeticException,
                                                            IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value its multiplicative inverse (1/x)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - isConfigurable
```
public boolean isConfigurable()
```
    Description copied from interface: StructureProperties
    
    Answer true if the implementation of this object can be changed.
    
    A configurable object has a structure that can be expanded, or reduced, or has replaceable components. Configurable structures are necessarily mutable; in fact, "configurability" can be used as a strict definition of mutability. This predicate however overrides #isMutable in the respect that, for some types of objects such as Variants, mutability can be changed by switching from a non-mutable implementation to a mutable one (e.g., via assertPrecision).
    
    Specified by:
    
    isConfigurable in interface StructureProperties
    
    Overrides:
    
    isConfigurable in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the implementation of this object can be changed
  - isElastic
```
public boolean isElastic()
```
    Description copied from interface: StructureProperties
    
    Answer true if this structure, in principle, can be reduced via element removal or expanded via element addition. Empty collections are, in principle, reducible, but read-only collections are neither reducible or expandable.
    
    Specified by:
    
    isElastic in interface StructureProperties
    
    Overrides:
    
    isElastic in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if this structure can be either reduced or expanded
  - isEqualToNumber
```
public final boolean isEqualToNumber(Number aValue)
```
    Specified by:
    
    isEqualToNumber in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isEqualToNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isEqualToPrimitive
```
public final boolean isEqualToPrimitive(SealedPrimitive<?> aPrimitive)
```
  - isEqualToReal
```
public final boolean isEqualToReal(SealedReal<?> aReal)
```
    Specified by:
    
    isEqualToReal in interface SealedReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isEqualToReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isEqualToScalar
```
public final boolean isEqualToScalar(SealedScalar<?> aScalar)
```
    Specified by:
    
    isEqualToScalar in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isEqualToScalar in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isEqualToText
```
public final boolean isEqualToText(CharSequence aValue)
```
  - isExpandable
```
public boolean isExpandable()
```
    Specified by:
    
    isExpandable in interface StructureProperties
    
    Overrides:
    
    isExpandable in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if this structure can be expanded via element insertion
  - isGreaterOrEqualToNumber
```
public final boolean isGreaterOrEqualToNumber(Number aValue)
```
    Specified by:
    
    isGreaterOrEqualToNumber in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isGreaterOrEqualToNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isGreaterOrEqualToPrimitive
```
public final boolean isGreaterOrEqualToPrimitive(SealedPrimitive<?> aPrimitive)
```
  - isGreaterOrEqualToReal
```
public final boolean isGreaterOrEqualToReal(SealedReal<?> aReal)
```
    Specified by:
    
    isGreaterOrEqualToReal in interface SealedReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isGreaterOrEqualToReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isGreaterOrEqualToScalar
```
public final boolean isGreaterOrEqualToScalar(SealedScalar<?> aScalar)
```
    Specified by:
    
    isGreaterOrEqualToScalar in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isGreaterOrEqualToScalar in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isGreaterOrEqualToText
```
public final boolean isGreaterOrEqualToText(CharSequence aValue)
```
  - isGreaterThanNumber
```
public final boolean isGreaterThanNumber(Number aValue)
```
    Specified by:
    
    isGreaterThanNumber in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isGreaterThanNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isGreaterThanPrimitive
```
public final boolean isGreaterThanPrimitive(SealedPrimitive<?> aPrimitive)
```
  - isGreaterThanReal
```
public final boolean isGreaterThanReal(SealedReal<?> aReal)
```
    Specified by:
    
    isGreaterThanReal in interface SealedReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isGreaterThanReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isGreaterThanScalar
```
public final boolean isGreaterThanScalar(SealedScalar<?> aScalar)
```
    Specified by:
    
    isGreaterThanScalar in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isGreaterThanScalar in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isGreaterThanText
```
public final boolean isGreaterThanText(CharSequence aValue)
```
  - 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
  - isLessOrEqualToNumber
```
public final boolean isLessOrEqualToNumber(Number aValue)
```
    Specified by:
    
    isLessOrEqualToNumber in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isLessOrEqualToNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isLessOrEqualToPrimitive
```
public final boolean isLessOrEqualToPrimitive(SealedPrimitive<?> aPrimitive)
```
  - isLessOrEqualToReal
```
public final boolean isLessOrEqualToReal(SealedReal<?> aReal)
```
    Specified by:
    
    isLessOrEqualToReal in interface SealedReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isLessOrEqualToReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isLessOrEqualToScalar
```
public final boolean isLessOrEqualToScalar(SealedScalar<?> aScalar)
```
    Specified by:
    
    isLessOrEqualToScalar in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isLessOrEqualToScalar in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isLessOrEqualToText
```
public final boolean isLessOrEqualToText(CharSequence aValue)
```
  - isLessThanNumber
```
public final boolean isLessThanNumber(Number aValue)
```
    Specified by:
    
    isLessThanNumber in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isLessThanNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isLessThanPrimitive
```
public final boolean isLessThanPrimitive(SealedPrimitive<?> aPrimitive)
```
  - isLessThanReal
```
public final boolean isLessThanReal(SealedReal<?> aReal)
```
    Specified by:
    
    isLessThanReal in interface SealedReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isLessThanReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isLessThanScalar
```
public final boolean isLessThanScalar(SealedScalar<?> aScalar)
```
    Specified by:
    
    isLessThanScalar in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isLessThanScalar in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isLessThanText
```
public final boolean isLessThanText(CharSequence aValue)
```
  - isMaximum
```
public final boolean isMaximum()
```
    Returns:
    true if this value represents the maximum rational value in the totally ordered set it represents
  - isMinimum
```
public final boolean isMinimum()
```
    Returns:
    true if this value represents the minimum rational value in the totally ordered set it represents
  - isModulo
```
public final boolean isModulo()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the magnitude of a vector into a modulo set, or finite ring. This is not the same as testing whether this object's implementation resembles the specification for the MODULO domain, since that is too specific to implementation machinery. Modulo values, for instance can either be real or imaginary.
    
    Returns:
    true if this value represents the magnitude of a vector into a modulo set, or finite ring
  - isNegative
```
public final boolean isNegative()
```
    Returns:
    true if this value represents a negative value
  - isNegativeFinite
```
public final boolean isNegativeFinite()
```
    Specified by:
    
    isNegativeFinite in interface NumericProperties
    
    Overrides:
    
    isNegativeFinite in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if this value represents a valid, finite and negative value
  - isNegativeInfinity
```
public final boolean isNegativeInfinity()
```
    Returns:
    true if this value represents negative infinity
  - isNotEqualToNumber
```
public final boolean isNotEqualToNumber(Number aValue)
```
    Specified by:
    
    isNotEqualToNumber in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isNotEqualToNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isNotEqualToPrimitive
```
public final boolean isNotEqualToPrimitive(SealedPrimitive<?> aPrimitive)
```
  - isNotEqualToReal
```
public final boolean isNotEqualToReal(SealedReal<?> aReal)
```
    Specified by:
    
    isNotEqualToReal in interface SealedReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isNotEqualToReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isNotEqualToScalar
```
public final boolean isNotEqualToScalar(SealedScalar<?> aScalar)
```
    Specified by:
    
    isNotEqualToScalar in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    isNotEqualToScalar in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
  - isNotEqualToText
```
public final boolean isNotEqualToText(CharSequence aValue)
```
  - 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 Primitive<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 boolean isPositiveFinite()
```
    Specified by:
    
    isPositiveFinite in interface NumericProperties
    
    Overrides:
    
    isPositiveFinite in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if this value represents a valid, finite and negative value
  - isPositiveInfinity
```
public final boolean isPositiveInfinity()
```
    Returns:
    true if this value represents positive infinity
  - isReal
```
public final boolean isReal()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the magnitude of a vector into the set of real numbers. This is not the same as testing whether this object's implementation resembles the specification for the REAL domain, since that is too specific to implementation machinery. This more general test also includes real modulo values in its specification.
    
    Returns:
    true if this value represents the magnitude of a vector into the set of real numbers
  - isReducible
```
public final boolean isReducible()
```
    Description copied from interface: StructureProperties
    
    Answer true if this structure, in principle, can be reduced via element removal. Empty collections are, in principle, reducible, but read-only collections are not.
    
    Specified by:
    
    isReducible in interface StructureProperties
    
    Overrides:
    
    isReducible in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if this structure, in principle, can be reduced via element removal
  - isText
```
public final boolean isText()
```
    Returns:
    true if this object utilizes a text-based implementation
  - isUnity
```
public final boolean isUnity()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the multiplicative identity in its arithmetic domain. For real numbers this is 1, for matrices it would be the identity matrix and for functions this would be a pass-through.
    
    Returns:
    true if this value represents the multiplicative identity in its domain
  - isZero
```
public final boolean isZero()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the additive identity in its algebraic group. For real numbers this is 0, for matrices this would be the zero matrix and for functions this would map every parameter to zero.
    
    Returns:
    true if this value represents the additive identity in its algebraic group
  - longPostDecrement
```
public final long longPostDecrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableLongValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - longPostIncrement
```
public final long longPostIncrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableLongValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - longValue
```
public final long longValue()
```
    Specified by:
    
    longValue in interface SealedLongValue
    
    Specified by:
    
    longValue in class Number
    
    Returns:
    the property value as a system long
  - modOfNumber
```
public final PRIMITIVE modOfNumber(Number aNumber)
                                                         throws UnsupportedOperationException,
                                                                IllegalArgumentException,
                                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to its current value modulo of the specified value
    
    Specified by:
    
    modOfNumber in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    modOfNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aNumber - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - modOfReal
```
public final PRIMITIVE modOfReal(SealedReal<?> aReal)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set the value of this scalar to its current value modulo of the specified value
    
    Specified by:
    
    modOfReal in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    modOfReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aReal - 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)
  - not
```
public final PRIMITIVE not()
                                                 throws UnsupportedOperationException,
                                                        ArithmeticException,
                                                        IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current integral binary vector with its one's complement. Decimal values, such as double, will be first converted to unlimited integers before their bits are reversed.
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    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
  - orOfNumber
```
public final PRIMITIVE orOfNumber(Number aNumber)
                                                        throws UnsupportedOperationException,
                                                               IllegalArgumentException,
                                                               ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    orOfNumber in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    orOfNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aNumber - 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
  - orOfReal
```
public final PRIMITIVE orOfReal(SealedReal<?> aReal)
                                                      throws UnsupportedOperationException,
                                                             IllegalArgumentException,
                                                             ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    orOfReal in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    orOfReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aReal - 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
  - powerOfReal
```
public final PRIMITIVE powerOfReal(SealedReal<?> aReal)
                                                         throws UnsupportedOperationException,
                                                                IllegalArgumentException,
                                                                ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
    
    Specified by:
    
    powerOfReal in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    powerOfReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aReal - an exponent
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - productOfNumber
```
public final PRIMITIVE productOfNumber(Number aNumber)
                                                             throws UnsupportedOperationException,
                                                                    IllegalArgumentException,
                                                                    ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    productOfNumber in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    productOfNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aNumber - 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
  - productOfReal
```
public final PRIMITIVE productOfReal(SealedReal<?> aReal)
                                                           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:
    
    productOfReal in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    productOfReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aReal - 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
  - quotientOfNumber
```
public final PRIMITIVE quotientOfNumber(Number aNumber)
                                                              throws UnsupportedOperationException,
                                                                     IllegalArgumentException,
                                                                     ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Specified by:
    
    quotientOfNumber in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotientOfNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aNumber - 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
  - quotientOfReal
```
public final PRIMITIVE quotientOfReal(SealedReal<?> aReal)
                                                            throws UnsupportedOperationException,
                                                                   IllegalArgumentException,
                                                                   ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set the value of this scalar to the mathematical quotient between its current value and the specified value
    
    Specified by:
    
    quotientOfReal in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotientOfReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aReal - 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
```
    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
  - setBoolean
```
public final PRIMITIVE setBoolean(Boolean aValue)
                                                        throws UnsupportedOperationException,
                                                               IllegalArgumentException,
                                                               ArithmeticException,
                                                               NullPointerException
```
    Description copied from interface: MutablePrimitive
    
    Set this property to the specified system-supported Boolean and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a system-supported Boolean
    
    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
  - setCharacter
```
public final PRIMITIVE setCharacter(Character aValue)
                                                          throws UnsupportedOperationException,
                                                                 IllegalArgumentException,
                                                                 ArithmeticException,
                                                                 NullPointerException
```
    Description copied from interface: MutablePrimitive
    
    Set this property to the specified system-supported Character and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a system-supported Character
    
    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
  - setEnumeration
```
public final <E extends Enum<E>> PRIMITIVE setEnumeration(E aValue)
                                                            throws UnsupportedOperationException,
                                                                   ArithmeticException,
                                                                   IllegalArgumentException,
                                                                   NullPointerException
```
    Description copied from interface: MutableScalar
    
    Match the value of this object with the identity of the specified enumeration instance, then answer this object (facilitates chaining)
    
    Specified by:
    
    setEnumeration in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setEnumeration in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a system-supported enumeration
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setMaximum
```
public final PRIMITIVE setMaximum()
                                                        throws UnsupportedOperationException,
                                                               ArithmeticException,
                                                               IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with maximum value available for the implementation's numeric precision. Unlimited values will be replaced with the maximum value available for the most precise system scalar appropriate for the implementation, that is unlimited integer primitives will set themselves to the maximum long value and unlimited decimal primitives will set themselves to the maximum double value.
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - setMinimum
```
public final PRIMITIVE setMinimum()
                                                        throws UnsupportedOperationException,
                                                               ArithmeticException,
                                                               IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with minimum value available for the implementation's numeric precision. Unlimited values will be replaced with the minimum value available for the most precise system scalar appropriate for the implementation, that is unlimited integer primitives will set themselves to the minimum long value and unlimited decimal primitives will set themselves to the minimum double value.
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - setNegativeInfinity
```
public final PRIMITIVE setNegativeInfinity()
                                                                 throws UnsupportedOperationException,
                                                                        ArithmeticException,
                                                                        IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with a representation of negative infinity, if available, otherwise replace with the implementation's minimum value
    
    Specified by:
    
    setNegativeInfinity in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setNegativeInfinity in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - setNumber
```
public PRIMITIVE setNumber(Number aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException,
                                                        NullPointerException
```
    Description copied from interface: MutableScalar
    
    Set this object to the specified system-supported Number and answer this object (facilitates chaining)
    
    Specified by:
    
    setNumber in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a system-supported Number
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setPositiveInfinity
```
public final PRIMITIVE setPositiveInfinity()
                                                                 throws UnsupportedOperationException,
                                                                        ArithmeticException,
                                                                        IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with a representation of positive infinity, if available, otherwise replace with the implementation's maximum value
    
    Specified by:
    
    setPositiveInfinity in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setPositiveInfinity in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - setPrimitive
```
public final PRIMITIVE setPrimitive(SealedPrimitive<?> aValue)
                                                          throws UnsupportedOperationException,
                                                                 IllegalArgumentException,
                                                                 ArithmeticException,
                                                                 NullPointerException
```
    Description copied from interface: MutablePrimitive
    
    Set this property to the specified primitive
    
    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<?> aReal)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set this property to the specified numeric primitive and answer this object (facilitates chaining)
    
    Specified by:
    
    setReal in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aReal - 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
  - setScalar
```
public final PRIMITIVE setScalar(boolean aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableBooleanValue
    
    Set this property to the specified boolean value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a boolean value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
  - setScalar
```
public final PRIMITIVE setScalar(byte aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableByteValue
    
    Set this property to the specified byte value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a byte value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
  - setScalar
```
public final PRIMITIVE setScalar(char aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableCharacterValue
    
    Set this property to the specified char value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a char value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
  - setScalar
```
public final PRIMITIVE setScalar(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(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
  - 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 Primitive<PRIMITIVE>>
    
    Returns:
    zero if this number is zero, -1 if this number is negative or +1 if it is positive
  - size
```
public final int size()
```
    Description copied from interface: SealedAlgebraicStructure
    
    Returns the number of elements in this algebraic structure. If the structure contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.
    
    Specified by:
    
    size in interface SealedAlgebraicStructure
    
    Overrides:
    
    size in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    the number of elements in this algebraic structure
    See Also:
    Collection.size()
  - 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
  - sumOfNumber
```
public final PRIMITIVE sumOfNumber(Number aNumber)
                                                         throws UnsupportedOperationException,
                                                                IllegalArgumentException,
                                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sumOfNumber in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sumOfNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aNumber - 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
  - sumOfReal
```
public final PRIMITIVE sumOfReal(SealedReal<?> aReal)
                                                       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:
    
    sumOfReal in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sumOfReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aReal - 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
  - textPostDecrement
```
public final String textPostDecrement()
                               throws UnsupportedOperationException,
                                      ArithmeticException,
                                      IllegalArgumentException
```
    Description copied from interface: MutableTextValue
    
    Decrement the real value of this text then return the original text prior to decrementing
    
    Returns:
    the original value of this text
    
    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
  - textPostIncrement
```
public final String textPostIncrement()
                               throws UnsupportedOperationException,
                                      ArithmeticException,
                                      IllegalArgumentException
```
    Description copied from interface: MutableTextValue
    
    Increment the real value of this text then return the original text prior to incrementing
    
    Returns:
    the original value of this text
    
    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
  - toCodePoint
```
public final int toCodePoint()
```
    Description copied from interface: SealedScalar
    
    Represent the value of this object as a code point
    
    Specified by:
    
    toCodePoint in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    toCodePoint in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    the value of this object represented as a single code point
  - toEnumeration
```
public final <E extends Enum<E>> E toEnumeration(Class<E> anEnumerationClass)
                                   throws ArithmeticException,
                                          IllegalArgumentException,
                                          NullPointerException
```
    Description copied from interface: SealedScalar
    
    Represent the value of this object as an appropriate member of the class of the specified enumeration
    
    Specified by:
    
    toEnumeration in interface SealedScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    toEnumeration in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    anEnumerationClass - the class of enumeration to convert to
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    NullPointerException - a null value was provided though this object does not accept null values
  - toNumber
```
public final Number toNumber()
```
    Returns:
    this object as a best-match, system-supported Number object
  - toReal
```
public final Real<?> toReal()
```
    Description copied from interface: RealReplicator
    
    If this real is already a real number real then simply call its Replicator.copy() function, otherwise produce a new real number real
    
    Specified by:
    
    toReal in interface RealReplicator<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    toReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    a new real number real
  - toScalar
```
public final Scalar<?> toScalar()
```
    Description copied from interface: ScalarReplicator
    
    If this scalar is already a scalar then simply call its Replicator.copy() function, otherwise produce a new scalar with scalar precision
    
    Specified by:
    
    toScalar in interface ScalarReplicator<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    toScalar in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    a new scalar scalar
  - 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
  - trim
```
public final PRIMITIVE trim()
                                                  throws UnsupportedOperationException,
                                                         IllegalArgumentException,
                                                         ArithmeticException
```
    Description copied from interface: MutableTextValue
    
    Remove both leading and trailing whitespace
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException
    
    IllegalArgumentException
    
    ArithmeticException
  - 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
  - xorOfNumber
```
public final PRIMITIVE xorOfNumber(Number aNumber)
                                                         throws UnsupportedOperationException,
                                                                IllegalArgumentException,
                                                                ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xorOfNumber in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    xorOfNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aNumber - 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
  - xorOfReal
```
public final PRIMITIVE xorOfReal(SealedReal<?> aReal)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableReal
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xorOfReal in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    xorOfReal in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aReal - 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
  - toLowerFirstCamelCase
```
public static final String toLowerFirstCamelCase(String aName)
```
  - toUpperFirst
```
public static final String toUpperFirst(String aWord)
```
  - toUpperFirstCamelCase
```
public static final String toUpperFirstCamelCase(String aName)
```

Class AbstractTextPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class net.sf.jaccumulator.primitives.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.primitives.PrimitiveReplicator

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

Methods inherited from interface net.sf.jaccumulator.texts.TextInductor

Methods inherited from interface net.sf.jaccumulator.texts.TextReplicator

Methods inherited from interface net.sf.jaccumulator.texts.SealedTextValue

Methods inherited from interface java.lang.CharSequence

Methods inherited from interface net.sf.jaccumulator.texts.TextProperties

Methods inherited from interface net.sf.jaccumulator.texts.MutableTextValue

Constructor Detail

AbstractTextPrimitive

AbstractTextPrimitive

AbstractTextPrimitive

AbstractTextPrimitive

Method Detail

absoluteValue

andOfNumber

andOfReal

angleWithReal

booleanPostDecrement

booleanPostIncrement

booleanValue

bytePostDecrement

bytePostIncrement

byteValue

charPostDecrement

charPostIncrement

charValue

clearContents

clearText

compareTo

compareToNumber

compareToPrimitive

compareToReal

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsingPrimitive

copyUsingReal

copyUsingScalar

cube

decrement

differenceOfNumber

differenceOfReal

doublePostDecrement

doublePostIncrement

doubleValue

equals

floatPostDecrement