AbstractConstant (Java Accumulators and Variants)

java.lang.Object
- java.lang.Number
- - net.sf.jaccumulator.scalars.AbstractScalar<REAL>
  - - net.sf.jaccumulator.reals.AbstractReal<PRIMITIVE>
    - - net.sf.jaccumulator.primitives.AbstractPrimitive<PRIMITIVE>
      - net.sf.jaccumulator.primitives.AbstractNumericPrimitive<PRIMITIVE>
        
        net.sf.jaccumulator.primitives.AbstractConstant<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:

Constant
```
public abstract class AbstractConstant<PRIMITIVE extends Primitive<PRIMITIVE>>
extends AbstractNumericPrimitive<PRIMITIVE>
```
A sealed primitive whose modification functions are shunted and which will produce UnsupportedOperationExceptions upon access

Since:

JCXell 1.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
`AbstractConstant()`
`AbstractConstant(Domain aDomain, NumericPrecision aPrecision)`
`AbstractConstant(NumericPrecision aPrecision)`

Method Summary

Methods
Modifier and Type	Method and Description
`PRIMITIVE`	`append(boolean aValue)`
`PRIMITIVE`	`append(char c)`
`PRIMITIVE`	`append(char[] content)`
`PRIMITIVE`	`append(char[] content, int contentIndex, int contentLength)`
`PRIMITIVE`	`append(CharSequence s)`
`PRIMITIVE`	`append(CharSequence s, int start, int end)`
`PRIMITIVE`	`append(double aValue)`
`PRIMITIVE`	`append(float aValue)`
`PRIMITIVE`	`append(int aValue)`
`PRIMITIVE`	`append(long aValue)`
`PRIMITIVE`	`append(Object aValue)`
`PRIMITIVE`	`append(StringBuffer sb)`
`PRIMITIVE`	`appendCodePoint(int codePoint)`
`boolean`	`booleanPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`boolean`	`booleanPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`byte`	`bytePostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`byte`	`bytePostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`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
`void`	`clear()` Same as `Collection.clear()`.
`PRIMITIVE`	`copy()` Produce a replica of this object
`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`	`delete(int start, int end)`
`PRIMITIVE`	`deleteCharAt(int anIndex)`
`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
`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
`ConcurrencyStrategy`	`getConcurrency()`
`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
`<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
`PRIMITIVE`	`insert(int anIndex, boolean aValue)`
`PRIMITIVE`	`insert(int anIndex, char aValue)`
`PRIMITIVE`	`insert(int anIndex, char[] content)`
`PRIMITIVE`	`insert(int targetIndex, char[] content, int contentIndex, int contentLength)`
`PRIMITIVE`	`insert(int anIndex, CharSequence content)`
`PRIMITIVE`	`insert(int targetIndex, CharSequence content, int contentIndex)`
`PRIMITIVE`	`insert(int targetIndex, CharSequence content, int contentStartIndex, int contentEndIndexPlusOne)`
`PRIMITIVE`	`insert(int anIndex, double aValue)`
`PRIMITIVE`	`insert(int anIndex, float aValue)`
`PRIMITIVE`	`insert(int anIndex, int aValue)`
`PRIMITIVE`	`insert(int anIndex, long aValue)`
`PRIMITIVE`	`insert(int anIndex, Object aValue)`
`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
`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`	`isDigit()` Determine if this `char`-width or `int`-width character is a digit within Unicode
`boolean`	`isElastic()` Scalar representations are hardware-driven and not scalable.
`boolean`	`isExpandable()` Scalar representations are hardware-driven and not scalable.
`boolean`	`isIdentifierIgnorable()` Determine if this `char`-width or `int`-width character ignorable character in a Java identifier or a Unicode identifier
`boolean`	`isISOControl()` Determine if this `char`-width or `int`-width character is an ISO control character within Unicode
`boolean`	`isJavaIdentifierPart()` Determine if this `char`-width or `int`-width character is a part of a Java identifier as other than the first character
`boolean`	`isJavaIdentifierStart()` Determine if this `char`-width or `int`-width character is permissible as the first character in a Java identifier
`boolean`	`isLetter()` Determine if this `char`-width or `int`-width character is a letter within Unicode
`boolean`	`isLetterOrDigit()` Determine if this `char`-width or `int`-width character is a letter or digit within Unicode
`boolean`	`isLowerCase()` Determine if this `char`-width or `int`-width character is a lower case character within Unicode
`boolean`	`isMirrored()` Determine if this `char`-width or `int`-width character is "mirrored" within Unicode
`boolean`	`isModulo()` Answer `true` if this value represents the magnitude of a vector into a modulo set, or finite ring.
`boolean`	`isReal()` Answer `true` if this value represents the magnitude of a vector into the set of real numbers.
`boolean`	`isReducible()` Scalar representations are hardware-driven and not scalable.
`boolean`	`isText()`
`boolean`	`isTitleCase()` Determine if this `char`-width or `int`-width character is a title case character within Unicode
`boolean`	`isUnicode()` Determine if this `char`-width or `int`-width character is defined within Unicode
`boolean`	`isUnicodeIdentifierPart()` Determine if this `char`-width or `int`-width character is a part of a Unicode identifier as other than the first character
`boolean`	`isUnicodeIdentifierStart()` Determine if this `char`-width or `int`-width character is permissible as the first character in a Unicode identifier
`boolean`	`isUpperCase()` Determine if this `char`-width or `int`-width character is an upper case character within Unicode
`boolean`	`isWhitespace()` Determine if this `char`-width or `int`-width character is whitespace within Unicode
`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
`PRIMITIVE`	`lowerCase()` For text-based objects, convert all characters in the text to lower case.
`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`	`replace(CharSequence target, CharSequence replacement)`
`PRIMITIVE`	`replace(int start, int end, String str)`
`PRIMITIVE`	`replaceAll(String regex, String replacement)`
`PRIMITIVE`	`replaceCharacter(char oldChar, char newChar)`
`PRIMITIVE`	`replaceFirst(String regex, String replacement)`
`PRIMITIVE`	`reverse()`
`PRIMITIVE`	`round(RoundingStrategy aRoundingStrategy)` Round the current value using the specified rounding `strategy`
`PRIMITIVE`	`setCharAt(int index, char ch)`
`<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`	`setLength(int newLength)`
`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`	`setPositiveInfinity()` Replace the current value with a representation of positive infinity, if available, otherwise replace with the implementation's `maximum` value
`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`	`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`	`setText(CharSequence content)` Set this property to the specified `text` 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.
`PRIMITIVE`	`shiftRightExtendZero(int count)` Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions without sign extension.
`short`	`shortPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`short`	`shortPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`PRIMITIVE`	`square()` Replace the current value with the square of itself
`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
`PRIMITIVE`	`titleCase()` For text-based objects, convert all characters in the text to `title` case.
`int`	`toCodePoint()` Represent the value of this object as a code point
`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`	`upperCase()` For text-based objects, convert all characters in the text to upper case.

Methods inherited from class net.sf.jaccumulator.primitives.AbstractNumericPrimitive
append, append, charAt, clearContents, clearText, codePointAt, codePointBefore, codePointCount, compareTo, compareToPrimitive, copyUsingText, equals, getStructureStrategy, indexOfText, indexOfText, inducePrimitiveValue, induceTextValue, isEmpty, isEqualToPrimitive, isEqualToText, isGreaterOrEqualToPrimitive, isGreaterOrEqualToText, isGreaterThanPrimitive, isGreaterThanText, isLessOrEqualToPrimitive, isLessOrEqualToText, isLessThanPrimitive, isLessThanText, isNotEqualToPrimitive, isNotEqualToText, length, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, setBoolean, setCharacter, setNumber, setPrimitive, setReal, subSequence, substring, substring, toPrimitive, toPrimitive

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

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

Methods inherited from class net.sf.jaccumulator.scalars.AbstractScalar
absoluteValue, 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, invalidate, isAlphabetic, isBmpCodePoint, isCountable, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqualToScalar, isFalse, isFinite, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqualToScalar, isGreaterThanScalar, isHighSurrogate, isIdeographic, isImaginary, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqualToScalar, isLessThanScalar, isLowSurrogate, isMutable, isNegativeFinite, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqualToScalar, isOrdered, isPositiveFinite, isSupplementaryCodePoint, isSurrogate, isTrue, isUnique, isValid, isValidCodePoint, 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, shortMaskAt, shortNotMaskAt, shortValue, signum, sine, size, 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, toEnumeration, toScalar, toUnlimitedInteger, unlimitedIntegerMaskAt, unlimitedIntegerNotMaskAt, up, xor, xor, xor, xor, xor, xor, xorOfScalar

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

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

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.scalars.NumericProperties
isFinite, isImaginary, isInfinity, isInvalid, isMaximum, isMinimum, isNegative, isNegativeFinite, isNegativeInfinity, isPositive, isPositiveFinite, isPositiveInfinity, isUnity, isValid, isZero, signum

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.reals.RealReplicator
copyUsing, copyUsing, copyUsingReal, toReal

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

Methods inherited from interface net.sf.jaccumulator.reals.MutableReal
and, andOfReal, angleWithReal, difference, difference, differenceOfReal, gcd, gcdOfReal, hypotenuseWithReal, mod, mod, modOfReal, or, orOfReal, powerOfReal, product, product, productOfReal, quotient, quotient, quotientOfReal, sum, sum, sumOfReal, xor, xorOfReal

Methods inherited from interface net.sf.jaccumulator.scalars.MutableScalar
absoluteValue, and, and, and, and, and, and, andOfNumber, andOfScalar, angleWith, angleWithNumber, angleWithScalar, arcCosine, arcSine, arcTangent, base10Log, ceiling, cosine, cubeRoot, degrees, difference, difference, difference, difference, difference, difference, difference, difference, differenceOfNumber, differenceOfScalar, down, exponential, exponentialLessOne, floor, gcd, gcd, gcd, gcd, gcd, gcdOfNumber, gcdOfScalar, halfDown, halfEven, halfUp, hyperbolicCosine, hyperbolicSine, hyperbolicTangent, hypotenuseWith, hypotenuseWithNumber, hypotenuseWithScalar, invalidate, milliseconds, mod, mod, mod, mod, mod, mod, mod, mod, modOfNumber, modOfScalar, nanoseconds, naturalLog, naturalLogPlusOne, or, or, or, or, or, or, orOfNumber, orOfScalar, power, power, powerOfNumber, powerOfScalar, product, product, product, product, product, product, product, product, productOfNumber, productOfScalar, quotient, quotient, quotient, quotient, quotient, quotient, quotient, quotient, quotientOfNumber, quotientOfScalar, radians, random, setE, setPi, setScalar, setUnity, setZero, sine, squareRoot, sum, sum, sum, sum, sum, sum, sum, sum, sumOfNumber, sumOfScalar, tangent, up, xor, xor, xor, xor, xor, xor, xorOfNumber, 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

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

Methods inherited from interface net.sf.jaccumulator.unlimiteds.SealedUnlimitedIntegerValue
toUnlimitedInteger

Methods inherited from interface net.sf.jaccumulator.unlimiteds.SealedUnlimitedDecimalValue
toUnlimitedDecimal

Methods inherited from interface java.lang.CharSequence
toString

- Constructor Detail
  - AbstractConstant
```
public AbstractConstant()
```
  - AbstractConstant
```
public AbstractConstant(Domain aDomain,
                NumericPrecision aPrecision)
```
  - AbstractConstant
```
public AbstractConstant(NumericPrecision aPrecision)
```
- Method Detail
  - append
```
public final PRIMITIVE append(boolean aValue)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    append in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    append in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - append
```
public final PRIMITIVE append(char c)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    append in interface Appendable
    
    Specified by:
    
    append in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    append in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - append
```
public final PRIMITIVE append(char[] content)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    append in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    append in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - append
```
public final PRIMITIVE append(char[] content,
               int contentIndex,
               int contentLength)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    append in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    append in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - append
```
public final PRIMITIVE append(CharSequence s)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    append in interface Appendable
    
    Specified by:
    
    append in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    append in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - append
```
public final PRIMITIVE append(CharSequence s,
               int start,
               int end)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    append in interface Appendable
    
    Specified by:
    
    append in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    append in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - append
```
public final PRIMITIVE append(double aValue)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    append in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    append in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - append
```
public final PRIMITIVE append(float aValue)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    append in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    append in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - append
```
public final PRIMITIVE append(int aValue)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    append in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    append in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - append
```
public final PRIMITIVE append(long aValue)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    append in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    append in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - append
```
public final PRIMITIVE append(Object aValue)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    append in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    append in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - append
```
public final PRIMITIVE append(StringBuffer sb)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    append in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    append in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - appendCodePoint
```
public final PRIMITIVE appendCodePoint(int codePoint)
                                                             throws UnsupportedOperationException
```
    Specified by:
    
    appendCodePoint in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    appendCodePoint in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - booleanPostDecrement
```
public final boolean booleanPostDecrement()
                                   throws UnsupportedOperationException,
                                          ArithmeticException,
                                          IllegalArgumentException
```
    Description copied from interface: MutableBooleanValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - booleanPostIncrement
```
public final boolean booleanPostIncrement()
                                   throws UnsupportedOperationException,
                                          ArithmeticException,
                                          IllegalArgumentException
```
    Description copied from interface: MutableBooleanValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - bytePostDecrement
```
public final byte bytePostDecrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableByteValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - bytePostIncrement
```
public final byte bytePostIncrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableByteValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - 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
  - clear
```
public final void clear()
```
    Description copied from interface: MutableAlgebraicStructure
    
    Same as Collection.clear(). So as to maintain compatibility, this function will not return the customary reference back to this structure.
    
    Specified by:
    
    clear in interface MutableAlgebraicStructure<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Specified by:
    
    clear in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    clear in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    See Also:
    MutableAlgebraicStructure.clearContents(), Collection.clear(), MutableTextValue.clearText();
  - copy
```
public final PRIMITIVE copy()
```
    Description copied from interface: Replicator
    
    Produce a replica of this object
    
    Returns:
    a replica of this object
  - 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
  - delete
```
public final PRIMITIVE delete(int start,
               int end)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    delete in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    delete in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - deleteCharAt
```
public final PRIMITIVE deleteCharAt(int anIndex)
                                                          throws UnsupportedOperationException
```
    Specified by:
    
    deleteCharAt in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    deleteCharAt in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - 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
  - 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
  - getConcurrency
```
public final ConcurrencyStrategy getConcurrency()
```
    Returns:
    the supported threading strategy
  - increment
```
public final PRIMITIVE increment()
                                                       throws UnsupportedOperationException,
                                                              ArithmeticException,
                                                              IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the current value plus unity (one)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - inducePostDecrement
```
public final <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
    
    Specified by:
    
    inducePostDecrement in interface PrimitiveInductor<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    inducePostDecrement in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
    
    Specified by:
    
    inducePostDecrement in interface RealInductor<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    inducePostDecrement in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
    
    Specified by:
    
    inducePostIncrement in interface PrimitiveInductor<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    inducePostIncrement in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
    
    Specified by:
    
    inducePostIncrement in interface RealInductor<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    inducePostIncrement in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - induceRealMaximum
```
public <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 <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 <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 <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 <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 <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
  - insert
```
public final PRIMITIVE insert(int anIndex,
               boolean aValue)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    insert in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    insert in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - insert
```
public final PRIMITIVE insert(int anIndex,
               char aValue)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    insert in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    insert in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - insert
```
public final PRIMITIVE insert(int anIndex,
               char[] content)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    insert in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    insert in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - insert
```
public final PRIMITIVE insert(int targetIndex,
               char[] content,
               int contentIndex,
               int contentLength)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    insert in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    insert in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - insert
```
public final PRIMITIVE insert(int anIndex,
               CharSequence content)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    insert in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    insert in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - insert
```
public final PRIMITIVE insert(int targetIndex,
               CharSequence content,
               int contentIndex)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    insert in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    insert in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - insert
```
public final PRIMITIVE insert(int targetIndex,
               CharSequence content,
               int contentStartIndex,
               int contentEndIndexPlusOne)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    insert in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    insert in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - insert
```
public final PRIMITIVE insert(int anIndex,
               double aValue)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    insert in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    insert in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - insert
```
public final PRIMITIVE insert(int anIndex,
               float aValue)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    insert in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    insert in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - insert
```
public final PRIMITIVE insert(int anIndex,
               int aValue)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    insert in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    insert in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - insert
```
public final PRIMITIVE insert(int anIndex,
               long aValue)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    insert in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    insert in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - insert
```
public final PRIMITIVE insert(int anIndex,
               Object aValue)
                                                    throws UnsupportedOperationException
```
    Specified by:
    
    insert in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    insert in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - 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
  - 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 final 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
  - isDigit
```
public final boolean isDigit()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a digit within Unicode
    
    Specified by:
    
    isDigit in interface CharacterProperties
    
    Overrides:
    
    isDigit in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a digit in Unicode
    See Also:
    Character.isDigit(char), Character.isDigit(int)
  - isElastic
```
public final boolean isElastic()
```
    Scalar representations are hardware-driven and not scalable.
    
    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
  - isExpandable
```
public final boolean isExpandable()
```
    Scalar representations are hardware-driven and not scalable.
    
    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
  - isIdentifierIgnorable
```
public final boolean isIdentifierIgnorable()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character ignorable character in a Java identifier or a Unicode identifier
    
    Specified by:
    
    isIdentifierIgnorable in interface CharacterProperties
    
    Overrides:
    
    isIdentifierIgnorable in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, ignorable character in a Java identifier or a Unicode identifier as other than the first character
    See Also:
    Character.isIdentifierIgnorable(char), Character.isIdentifierIgnorable(int)
  - isISOControl
```
public final boolean isISOControl()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is an ISO control character within Unicode
    
    Specified by:
    
    isISOControl in interface CharacterProperties
    
    Overrides:
    
    isISOControl in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is an ISO control character in Unicode
    See Also:
    Character.isISOControl(char), Character.isISOControl(int)
  - isJavaIdentifierPart
```
public final boolean isJavaIdentifierPart()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a part of a Java identifier as other than the first character
    
    Specified by:
    
    isJavaIdentifierPart in interface CharacterProperties
    
    Overrides:
    
    isJavaIdentifierPart in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a part of a Java identifier as other than the first character
    See Also:
    Character.isJavaIdentifierPart(char), Character.isJavaIdentifierPart(int)
  - isJavaIdentifierStart
```
public final boolean isJavaIdentifierStart()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is permissible as the first character in a Java identifier
    
    Specified by:
    
    isJavaIdentifierStart in interface CharacterProperties
    
    Overrides:
    
    isJavaIdentifierStart in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is permissible as the first character in a Java identifier
    See Also:
    Character.isJavaIdentifierStart(char), Character.isJavaIdentifierStart(int)
  - isLetter
```
public final boolean isLetter()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a letter within Unicode
    
    Specified by:
    
    isLetter in interface CharacterProperties
    
    Overrides:
    
    isLetter in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a letter in Unicode
    See Also:
    Character.isLetter(char), Character.isLetter(int)
  - isLetterOrDigit
```
public final boolean isLetterOrDigit()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a letter or digit within Unicode
    
    Specified by:
    
    isLetterOrDigit in interface CharacterProperties
    
    Overrides:
    
    isLetterOrDigit in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a letter or digit in Unicode
    See Also:
    Character.isLetterOrDigit(char), Character.isLetterOrDigit(int)
  - isLowerCase
```
public final boolean isLowerCase()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a lower case character within Unicode
    
    Specified by:
    
    isLowerCase in interface CharacterProperties
    
    Overrides:
    
    isLowerCase in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a lower case character in Unicode
    See Also:
    Character.isLowerCase(char), Character.isLowerCase(int)
  - isMirrored
```
public final boolean isMirrored()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is "mirrored" within Unicode
    
    Specified by:
    
    isMirrored in interface CharacterProperties
    
    Overrides:
    
    isMirrored in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is "mirrored" in Unicode
    See Also:
    Character.isMirrored(char), Character.isMirrored(int)
  - isModulo
```
public final boolean isModulo()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the magnitude of a vector into a modulo set, or finite ring. This is not the same as testing whether this object's implementation resembles the specification for the MODULO domain, since that is too specific to implementation machinery. Modulo values, for instance can either be real or imaginary.
    
    Returns:
    true if this value represents the magnitude of a vector into a modulo set, or finite ring
  - 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()
```
    Scalar representations are hardware-driven and not scalable.
    
    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 boolean isText()
```
    Specified by:
    
    isText in interface TextProperties
    
    Overrides:
    
    isText in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if this object utilizes a text-based implementation
  - isTitleCase
```
public final boolean isTitleCase()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a title case character within Unicode
    
    Specified by:
    
    isTitleCase in interface CharacterProperties
    
    Overrides:
    
    isTitleCase in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a title case character in Unicode
    See Also:
    Character.isTitleCase(char), Character.isTitleCase(int)
  - 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
  - isUnicode
```
public final boolean isUnicode()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is defined within Unicode
    
    Specified by:
    
    isUnicode in interface CharacterProperties
    
    Overrides:
    
    isUnicode in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is defined in Unicode
    See Also:
    Character.isDefined(char), Character.isDefined(int)
  - isUnicodeIdentifierPart
```
public final boolean isUnicodeIdentifierPart()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a part of a Unicode identifier as other than the first character
    
    Specified by:
    
    isUnicodeIdentifierPart in interface CharacterProperties
    
    Overrides:
    
    isUnicodeIdentifierPart in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is a part of a Unicode identifier as other than the first character
    See Also:
    Character.isUnicodeIdentifierPart(char), Character.isUnicodeIdentifierPart(int)
  - isUnicodeIdentifierStart
```
public final boolean isUnicodeIdentifierStart()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is permissible as the first character in a Unicode identifier
    
    Specified by:
    
    isUnicodeIdentifierStart in interface CharacterProperties
    
    Overrides:
    
    isUnicodeIdentifierStart in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is permissible as the first character in a Unicode identifier
    See Also:
    Character.isUnicodeIdentifierStart(char), Character.isUnicodeIdentifierStart(int)
  - isUpperCase
```
public final boolean isUpperCase()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is an upper case character within Unicode
    
    Specified by:
    
    isUpperCase in interface CharacterProperties
    
    Overrides:
    
    isUpperCase in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is an upper case character in Unicode
    See Also:
    Character.isUpperCase(char), Character.isUpperCase(int)
  - isWhitespace
```
public final boolean isWhitespace()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is whitespace within Unicode
    
    Specified by:
    
    isWhitespace in interface CharacterProperties
    
    Overrides:
    
    isWhitespace in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if the scalar value of this object, as appropriate for this objects's precision, is whitespace in Unicode
    See Also:
    Character.isWhitespace(char), Character.isWhitespace(int)
  - 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
  - lowerCase
```
public final PRIMITIVE lowerCase()
```
    Description copied from interface: MutableTextValue
    
    For text-based objects, convert all characters in the text to lower case. For numeric objects, convert their character (BMP) or integer value (Unicode) to lower case, depending on the object's precision level
    
    Specified by:
    
    lowerCase in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    lowerCase in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
  - negate
```
public final PRIMITIVE negate()
                                                    throws UnsupportedOperationException,
                                                           ArithmeticException,
                                                           IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the additive inverse (sign negation) of itself, that is transform it into a number that when added to the original yields zero. (Though additive inverses for non-zero boolean and char values do not exist, these implementations will simply fail silently.)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object (optional)
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification (optional)
  - not
```
public final PRIMITIVE not()
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current integral binary vector with its one's complement. Decimal values, such as double, will be first converted to unlimited integers before their bits are reversed.
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - replace
```
public final PRIMITIVE replace(CharSequence target,
                CharSequence replacement)
```
    Specified by:
    
    replace in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    replace in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
  - replace
```
public final PRIMITIVE replace(int start,
                int end,
                String str)
                                                     throws UnsupportedOperationException
```
    Specified by:
    
    replace in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    replace in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - replaceAll
```
public final PRIMITIVE replaceAll(String regex,
                   String replacement)
```
    Specified by:
    
    replaceAll in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    replaceAll in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
  - replaceCharacter
```
public final PRIMITIVE replaceCharacter(char oldChar,
                         char newChar)
```
    Specified by:
    
    replaceCharacter in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    replaceCharacter in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
  - replaceFirst
```
public final PRIMITIVE replaceFirst(String regex,
                     String replacement)
```
    Specified by:
    
    replaceFirst in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    replaceFirst in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
  - reverse
```
public final PRIMITIVE reverse()
                                                     throws UnsupportedOperationException
```
    Specified by:
    
    reverse in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    reverse in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - round
```
public final PRIMITIVE round(RoundingStrategy aRoundingStrategy)
                                                   throws UnsupportedOperationException,
                                                          IllegalArgumentException,
                                                          ArithmeticException,
                                                          NullPointerException
```
    Description copied from interface: MutableScalar
    
    Round the current value using the specified rounding strategy
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    NullPointerException
  - setCharAt
```
public PRIMITIVE setCharAt(int index,
                  char ch)
                                                 throws UnsupportedOperationException
```
    Specified by:
    
    setCharAt in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setCharAt in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - 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
  - setLength
```
public final PRIMITIVE setLength(int newLength)
                                                       throws UnsupportedOperationException
```
    Specified by:
    
    setLength in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setLength in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Throws:
    
    UnsupportedOperationException
  - 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
  - setPositiveInfinity
```
public final PRIMITIVE setPositiveInfinity()
                                                                 throws UnsupportedOperationException,
                                                                        IllegalArgumentException,
                                                                        ArithmeticException
```
    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
    
    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
  - 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
  - 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
  - setText
```
public final PRIMITIVE setText(CharSequence content)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            NullPointerException
```
    Description copied from interface: MutableTextValue
    
    Set this property to the specified text value and answer this object (facilitates chaining)
    
    Specified by:
    
    setText in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setText in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    content - a text 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
    
    NullPointerException - a null value was provided and this implementation does not accept null values
  - 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
  - shiftRightExtendZero
```
public final PRIMITIVE shiftRightExtendZero(int count)
                                                                  throws UnsupportedOperationException,
                                                                         IllegalArgumentException,
                                                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions without sign extension. In a bit sequence this functions resorts to the familiar "right shift" process, with zero extension (e.g., the Java >>> operator). In other sequences, the specified number of values will be removed from the beginning of the sequence, decreasing the ordinal position of all remaining elements by the specified count.
    
    Specified by:
    
    shiftRightExtendZero in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    shiftRightExtendZero in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    count - the number of values to be removed from the beginning of this sequence
    
    Returns:
    this structure (facilitates chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed or if this structure is not an algebraic tuple
    
    IllegalArgumentException - if the specified value was incommensurate with this structure's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this structure
  - shortPostDecrement
```
public final short shortPostDecrement()
                               throws UnsupportedOperationException,
                                      ArithmeticException,
                                      IllegalArgumentException
```
    Description copied from interface: MutableShortValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - shortPostIncrement
```
public final short shortPostIncrement()
                               throws UnsupportedOperationException,
                                      ArithmeticException,
                                      IllegalArgumentException
```
    Description copied from interface: MutableShortValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - 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
  - 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
    
    Specified by:
    
    textPostDecrement in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    textPostDecrement in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
    
    Specified by:
    
    textPostIncrement in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    textPostIncrement in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    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
  - titleCase
```
public final PRIMITIVE titleCase()
```
    Description copied from interface: MutableTextValue
    
    For text-based objects, convert all characters in the text to title case. For numeric objects, convert their character (BMP) or integer value (Unicode) to title case, depending on the object's precision level
    
    Specified by:
    
    titleCase in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    titleCase in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
  - trim
```
public final PRIMITIVE trim()
```
    Description copied from interface: MutableTextValue
    
    Remove both leading and trailing whitespace
    
    Specified by:
    
    trim in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    trim in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
  - unlimitedDecimalPostDecrement
```
public final BigDecimal unlimitedDecimalPostDecrement()
                                               throws UnsupportedOperationException,
                                                      ArithmeticException,
                                                      IllegalArgumentException
```
    Description copied from interface: MutableUnlimitedDecimalValue
    
    Decrement the real value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this real
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - unlimitedDecimalPostIncrement
```
public final BigDecimal unlimitedDecimalPostIncrement()
                                               throws UnsupportedOperationException,
                                                      ArithmeticException,
                                                      IllegalArgumentException
```
    Description copied from interface: MutableUnlimitedDecimalValue
    
    Increment the real value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this real
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - unlimitedIntegerPostDecrement
```
public final BigInteger unlimitedIntegerPostDecrement()
                                               throws UnsupportedOperationException,
                                                      ArithmeticException,
                                                      IllegalArgumentException
```
    Description copied from interface: MutableUnlimitedIntegerValue
    
    Decrement the real value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this real
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - unlimitedIntegerPostIncrement
```
public final BigInteger unlimitedIntegerPostIncrement()
                                               throws UnsupportedOperationException,
                                                      ArithmeticException,
                                                      IllegalArgumentException
```
    Description copied from interface: MutableUnlimitedIntegerValue
    
    Increment the real value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this real
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - upperCase
```
public final PRIMITIVE upperCase()
```
    Description copied from interface: MutableTextValue
    
    For text-based objects, convert all characters in the text to upper case. For numeric objects, convert their character (BMP) or integer value (Unicode) to upper case, depending on the object's precision level
    
    Specified by:
    
    upperCase in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    upperCase in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)

Class AbstractConstant<PRIMITIVE extends Primitive<PRIMITIVE>>

Field Summary

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

Constructor Summary

Method Summary

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

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

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

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

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

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

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

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

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

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

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

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

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.SealedAlgebraicStructure

Methods inherited from interface net.sf.jaccumulator.StructureProperties

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

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

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

Methods inherited from interface net.sf.jaccumulator.unlimiteds.SealedUnlimitedDecimalValue

Methods inherited from interface java.lang.CharSequence

Constructor Detail

AbstractConstant

AbstractConstant

AbstractConstant

Method Detail

append

append

append

append

append

append

append

append

append

append

append

append

appendCodePoint

booleanPostDecrement

booleanPostIncrement

bytePostDecrement

bytePostIncrement

charPostDecrement

charPostIncrement

clear

copy

cube

decrement

delete

deleteCharAt

doublePostDecrement

doublePostIncrement

floatPostDecrement

floatPostIncrement

getConcurrency

increment

inducePostDecrement

inducePostDecrement

inducePostDecrement