AbstractCharacterPrimitive (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.characters.AbstractCharacterPrimitive<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:

CharacterArrayCursor, CharacterPrimitive
```
public abstract class AbstractCharacterPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
extends AbstractNumericPrimitive<PRIMITIVE>
```
Abstract char precision primitive implementation

Since:

JAccumulator 4.0

Author:

Nicole Tedesco (Nicole@NicoleTedesco.com)

See Also:
Serialized Form

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

Constructor Summary

Constructors
Constructor and Description

AbstractCharacterPrimitive()

Constructors
Constructor and Description
`AbstractCharacterPrimitive()`

Method Summary

Methods
Modifier and Type	Method and Description
`PRIMITIVE`	`absoluteValue()` Replace the current value with the absolute value of itself
`PRIMITIVE`	`and(boolean aValue)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`and(byte aValue)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`and(short aValue)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`boolean`	`booleanPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`boolean`	`booleanPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`boolean`	`booleanValue()`
`byte`	`bytePostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`byte`	`bytePostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`byte`	`byteValue()`
`PRIMITIVE`	`copyUsing(BigDecimal aValue)` Using this real as a factory, produce a new real of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsing(BigInteger aValue)` Using this real as a factory, produce a new real of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsing(boolean aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(byte aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(double aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(float aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(int aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(long aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(short aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsingPrimitive(SealedPrimitive<?> aValue)` Using this primitive as a factory, produce a new primitive of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsingReal(SealedReal<?> aValue)` Using this real as a factory, produce a new real of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsingScalar(SealedScalar<?> aValue)` Using this scalar as a factory, produce a new scalar of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsingText(CharSequence aValue)` Using this primitive as a factory, produce a new primitive of the same type but initialized with the value specified
`PRIMITIVE`	`cube()` Replace the current value with the cube of itself
`PRIMITIVE`	`difference(boolean aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`difference(byte aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`difference(short aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`double`	`doublePostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`double`	`doublePostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`double`	`doubleValue()`
`static char`	`firstChar(CharSequence p0)`
`float`	`floatPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`float`	`floatPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`float`	`floatValue()`
`int`	`hashCode()`
`<S extends Scalar<?>> S`	`inducePostDecrement(S aTarget)` Decrement the value of this scalar then induce its original value into the specified target
`<S extends Scalar<?>> S`	`inducePostIncrement(S aTarget)` Increment the value of this scalar then induce its original value into the specified target
`<REAL extends Real<?>> REAL`	`induceRealMaximum(REAL aTarget)` Induce the maximum domain value into the target
`<REAL extends Real<?>> REAL`	`induceRealMinimum(REAL aTarget)` Induce the minimum domain value into the target
`<REAL extends Real<?>> REAL`	`induceRealValue(REAL aTarget)` Induce the current value of this real into the specified target
`<S extends Scalar<?>> S`	`induceScalarMaximum(S aTarget)` Induce the maximum domain value into the target
`<S extends Scalar<?>> S`	`induceScalarMinimum(S aTarget)` Induce the minimum domain value into the target
`<S extends Scalar<?>> S`	`induceScalarValue(S aTarget)` Induce the current value of this scalar into the specified target
`int`	`intPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`int`	`intPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`int`	`intValue()`
`PRIMITIVE`	`inverse()` Replace the current value its multiplicative inverse (`1/x`)
`boolean`	`isDigit()` Determine if this `char`-width or `int`-width character is a digit within Unicode
`boolean`	`isFinite()`
`boolean`	`isIdentifierIgnorable()` Determine if this `char`-width or `int`-width character ignorable character in a Java identifier or a Unicode identifier
`boolean`	`isInfinity()`
`boolean`	`isInvalid()`
`boolean`	`isISOControl()` Determine if this `char`-width or `int`-width character is an ISO control character within Unicode
`boolean`	`isJavaIdentifierPart()` Determine if this `char`-width or `int`-width character is a part of a Java identifier as other than the first character
`boolean`	`isJavaIdentifierStart()` Determine if this `char`-width or `int`-width character is permissible as the first character in a Java identifier
`boolean`	`isLetter()` Determine if this `char`-width or `int`-width character is a letter within Unicode
`boolean`	`isLetterOrDigit()` Determine if this `char`-width or `int`-width character is a letter or digit within Unicode
`boolean`	`isLowerCase()` Determine if this `char`-width or `int`-width character is a lower case character within Unicode
`boolean`	`isMaximum()`
`boolean`	`isMinimum()`
`boolean`	`isMirrored()` Determine if this `char`-width or `int`-width character is "mirrored" within Unicode
`boolean`	`isModulo()` Answer `true` if this value represents the magnitude of a vector into a modulo set, or finite ring.
`boolean`	`isNegative()`
`boolean`	`isNegativeFinite()`
`boolean`	`isNegativeInfinity()`
`boolean`	`isPositive()`
`boolean`	`isPositiveFinite()`
`boolean`	`isPositiveInfinity()`
`boolean`	`isReal()` Answer `true` if this value represents the magnitude of a vector into the set of real numbers.
`boolean`	`isTitleCase()` Determine if this `char`-width or `int`-width character is a title case character within Unicode
`boolean`	`isUnicode()` Determine if this `char`-width or `int`-width character is defined within Unicode
`boolean`	`isUnicodeIdentifierPart()` Determine if this `char`-width or `int`-width character is a part of a Unicode identifier as other than the first character
`boolean`	`isUnicodeIdentifierStart()` Determine if this `char`-width or `int`-width character is permissible as the first character in a Unicode identifier
`boolean`	`isUnity()` Answer `true` if this value represents the multiplicative identity in its arithmetic domain.
`boolean`	`isUpperCase()` Determine if this `char`-width or `int`-width character is an upper case character within Unicode
`boolean`	`isWhitespace()` Determine if this `char`-width or `int`-width character is whitespace within Unicode
`boolean`	`isZero()` Answer `true` if this value represents the additive identity in its algebraic group.
`long`	`longPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`long`	`longPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`long`	`longValue()`
`PRIMITIVE`	`lowerCase()` For text-based objects, convert all characters in the text to lower case.
`PRIMITIVE`	`negate()` Replace the current value with the additive inverse (sign negation) of itself, that is transform it into a number that when added to the original yields zero.
`PRIMITIVE`	`or(boolean aValue)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`or(byte aValue)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`or(short aValue)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`product(boolean aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`product(byte aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`product(short aValue)` Set the value of this scalar to the mathematical product of its current value and the specified value
`PRIMITIVE`	`quotient(boolean aValue)` Set the value of this scalar to the mathematical quotient between its current value and the specified value
`PRIMITIVE`	`quotient(byte aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`PRIMITIVE`	`quotient(short aValue)` Set the value of this scalar to the mathematical quotient of its current value and the specified value
`PRIMITIVE`	`round(RoundingStrategy aRoundingStrategy)` Round the current value using the specified rounding `strategy`
`PRIMITIVE`	`setMaximum()` Replace the current value with maximum value available for the implementation's numeric `precision`.
`PRIMITIVE`	`setMinimum()` Replace the current value with minimum value available for the implementation's numeric `precision`.
`PRIMITIVE`	`setNumber(Number aValue)` Set this object to the specified system-supported `Number` and answer this object (facilitates chaining)
`PRIMITIVE`	`setPrimitive(SealedPrimitive<?> aValue)` Set this property to the specified primitive
`PRIMITIVE`	`setReal(BigDecimal aValue)` Set this property to the specified unlimited `decimal` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setReal(BigInteger aValue)` Set this property to the specified unlimited `integer` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setReal(SealedReal<?> aValue)` Set this property to the specified numeric `primitive` and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(boolean aValue)` Set this property to the specified `boolean` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(byte aValue)` Set this property to the specified `byte` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(double aValue)` Set this property to the specified `double` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(float aValue)` Set this property to the specified `float` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(int aValue)` Set this property to the specified `int` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(long aValue)` Set this property to the specified `long` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(SealedScalar<?> aValue)` Set this object to the specified scalar
`PRIMITIVE`	`setScalar(short aValue)` Set this property to the specified `short` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setUnity()` Replace the current value with the multiplicative identity appropriate for the implementation (one)
`PRIMITIVE`	`setZero()` Replace the current value with the additive identity appropriate for the implementation (zero)
`short`	`shortPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`short`	`shortPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`short`	`shortValue()`
`PRIMITIVE`	`square()` Replace the current value with the square of itself
`PRIMITIVE`	`sum(boolean aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`PRIMITIVE`	`sum(byte aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`PRIMITIVE`	`sum(short aValue)` Set the value of this scalar to the mathematical sum of its current value and the specified value
`PRIMITIVE`	`swapPrimitives(Primitive<?> aPrimitive)` Swap the value of this primitive for the specified one and set the specified primitive's value to the current value of this primitive
`PRIMITIVE`	`titleCase()` For text-based objects, convert all characters in the text to `title` case.
`Number`	`toNumber()`
`String`	`toString()`
`BigDecimal`	`toUnlimitedDecimal()`
`BigInteger`	`toUnlimitedInteger()`
`BigDecimal`	`unlimitedDecimalPostDecrement()` Decrement the real value of this object then return the original value prior to decrementing
`BigDecimal`	`unlimitedDecimalPostIncrement()` Increment the real value of this object then return the original value prior to incrementing
`BigInteger`	`unlimitedIntegerPostDecrement()` Decrement the real value of this object then return the original value prior to decrementing
`BigInteger`	`unlimitedIntegerPostIncrement()` Increment the real value of this object then return the original value prior to incrementing
`PRIMITIVE`	`upperCase()` For text-based objects, convert all characters in the text to upper case.
`PRIMITIVE`	`xor(boolean aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`xor(byte aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`xor(short aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector

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

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

Methods inherited from class net.sf.jaccumulator.reals.AbstractReal
and, andOfNumber, andOfReal, angleWithReal, compareToNumber, compareToReal, compareToReal, compareToReal, 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
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, 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, isConfigurable, isCountable, isElastic, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqualToScalar, isExpandable, isFalse, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqualToScalar, isGreaterThanScalar, isHighSurrogate, isIdeographic, isImaginary, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqualToScalar, isLessThanScalar, isLowSurrogate, isMutable, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqualToScalar, isOrdered, isReducible, 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, orOfScalar, power, power, powerOfNumber, powerOfScalar, product, product, product, product, product, productOfScalar, promoteTo, quotient, quotient, quotient, quotient, quotient, quotientOfScalar, radians, random, setByteBitAt, setCharBitAt, setDoubleBitAt, setE, setEnumeration, setFalse, setFloatBitAt, setIntBitAt, setLongBitAt, setNegativeInfinity, setPi, setPositiveInfinity, setShortBitAt, setTrue, setUnlimitedDecimalBitAt, setUnlimitedIntegerBitAt, shiftRightExtendZero, shortMaskAt, shortNotMaskAt, shortValue, signum, sine, size, squareRoot, sum, sum, sum, sum, sum, sumOfScalar, tangent, toBoolean, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toByteArray, toCharacter, toCodePoint, toEnumeration, toScalar, toUnlimitedInteger, unlimitedIntegerMaskAt, unlimitedIntegerNotMaskAt, up, xor, xor, xor, xorOfScalar

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.scalars.NumericProperties
isImaginary, isValid, 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.characters.SealedCharacterValue
charValue

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

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

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

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

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.reals.MutableReal
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
and, and, and, andOfNumber, andOfScalar, angleWith, angleWithNumber, angleWithScalar, arcCosine, arcSine, arcTangent, base10Log, ceiling, cosine, cubeRoot, decrement, degrees, 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, increment, invalidate, milliseconds, mod, mod, mod, mod, mod, mod, mod, mod, modOfNumber, modOfScalar, nanoseconds, naturalLog, naturalLogPlusOne, not, or, or, or, orOfNumber, orOfScalar, power, power, powerOfNumber, powerOfScalar, product, product, product, product, product, productOfNumber, productOfScalar, quotient, quotient, quotient, quotient, quotient, quotientOfNumber, quotientOfScalar, radians, random, setE, setEnumeration, setNegativeInfinity, setPi, setPositiveInfinity, shiftLeft, shiftRight, shiftRightExtendZero, sine, squareRoot, sum, sum, sum, sum, sum, sumOfNumber, sumOfScalar, tangent, up, xor, xor, xor, xorOfNumber, xorOfScalar

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

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

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

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

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

- Constructor Detail
  - AbstractCharacterPrimitive
```
public AbstractCharacterPrimitive()
```
- Method Detail
  - absoluteValue
```
public final PRIMITIVE absoluteValue()
                                                           throws UnsupportedOperationException,
                                                                  ArithmeticException,
                                                                  IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the absolute value of itself
    
    Specified by:
    
    absoluteValue in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    absoluteValue in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - and
```
public final PRIMITIVE and(boolean aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    and in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - and
```
public final PRIMITIVE and(byte aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    and in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - and
```
public final PRIMITIVE and(short aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    and in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    and in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - booleanPostDecrement
```
public final boolean booleanPostDecrement()
                                   throws UnsupportedOperationException,
                                          ArithmeticException,
                                          IllegalArgumentException
```
    Description copied from interface: MutableBooleanValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - booleanPostIncrement
```
public final boolean booleanPostIncrement()
                                   throws UnsupportedOperationException,
                                          ArithmeticException,
                                          IllegalArgumentException
```
    Description copied from interface: MutableBooleanValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - booleanValue
```
public final boolean booleanValue()
```
    Returns:
    the property value as a system boolean
  - bytePostDecrement
```
public final byte bytePostDecrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableByteValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - bytePostIncrement
```
public final byte bytePostIncrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableByteValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - byteValue
```
public final byte byteValue()
```
    Specified by:
    
    byteValue in interface SealedByteValue
    
    Overrides:
    
    byteValue in class Number
    
    Returns:
    the property value as a system byte
  - copyUsing
```
public PRIMITIVE copyUsing(BigDecimal aValue)
```
    Description copied from interface: RealReplicator
    
    Using this real as a factory, produce a new real of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this real initialized using the specified value
  - copyUsing
```
public PRIMITIVE copyUsing(BigInteger aValue)
```
    Description copied from interface: RealReplicator
    
    Using this real as a factory, produce a new real of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this real initialized using the specified value
  - copyUsing
```
public PRIMITIVE copyUsing(boolean aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public PRIMITIVE copyUsing(byte aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public PRIMITIVE copyUsing(double aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public PRIMITIVE copyUsing(float aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public PRIMITIVE copyUsing(int aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public PRIMITIVE copyUsing(long aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public PRIMITIVE copyUsing(short aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsingPrimitive
```
public PRIMITIVE copyUsingPrimitive(SealedPrimitive<?> aValue)
```
    Description copied from interface: PrimitiveReplicator
    
    Using this primitive as a factory, produce a new primitive of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this primitive initialized using the specified value
  - copyUsingReal
```
public PRIMITIVE copyUsingReal(SealedReal<?> aValue)
```
    Description copied from interface: RealReplicator
    
    Using this real as a factory, produce a new real of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this real initialized using the specified value
  - copyUsingScalar
```
public PRIMITIVE copyUsingScalar(SealedScalar<?> aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this scalar as a factory, produce a new scalar of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsingText
```
public PRIMITIVE copyUsingText(CharSequence aValue)
```
    Description copied from interface: PrimitiveReplicator
    
    Using this primitive as a factory, produce a new primitive of the same type but initialized with the value specified
    
    Specified by:
    
    copyUsingText in interface PrimitiveReplicator<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Specified by:
    
    copyUsingText in interface TextReplicator<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    copyUsingText in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this primitive initialized using the specified value
  - cube
```
public final PRIMITIVE cube()
                                                  throws UnsupportedOperationException,
                                                         IllegalArgumentException,
                                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the cube of itself
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
public final PRIMITIVE difference(boolean aValue)
                                                        throws UnsupportedOperationException,
                                                               IllegalArgumentException,
                                                               ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
public final PRIMITIVE difference(byte aValue)
                                                        throws UnsupportedOperationException,
                                                               IllegalArgumentException,
                                                               ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
public final PRIMITIVE difference(short aValue)
                                                        throws UnsupportedOperationException,
                                                               IllegalArgumentException,
                                                               ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    difference in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - doublePostDecrement
```
public final double doublePostDecrement()
                                 throws UnsupportedOperationException,
                                        ArithmeticException,
                                        IllegalArgumentException
```
    Description copied from interface: MutableDoubleValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - doublePostIncrement
```
public final double doublePostIncrement()
                                 throws UnsupportedOperationException,
                                        ArithmeticException,
                                        IllegalArgumentException
```
    Description copied from interface: MutableDoubleValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - doubleValue
```
public final double doubleValue()
```
    Specified by:
    
    doubleValue in interface SealedDoubleValue
    
    Specified by:
    
    doubleValue in class Number
    
    Returns:
    the property value as a system double
  - floatPostDecrement
```
public final float floatPostDecrement()
                               throws UnsupportedOperationException,
                                      ArithmeticException,
                                      IllegalArgumentException
```
    Description copied from interface: MutableFloatValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - floatPostIncrement
```
public final float floatPostIncrement()
                               throws UnsupportedOperationException,
                                      ArithmeticException,
                                      IllegalArgumentException
```
    Description copied from interface: MutableFloatValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - floatValue
```
public final float floatValue()
```
    Specified by:
    
    floatValue in interface SealedFloatValue
    
    Specified by:
    
    floatValue in class Number
    
    Returns:
    the property value as a system float
  - hashCode
```
public final int hashCode()
```
    Specified by:
    
    hashCode in interface SealedKernel
    
    Overrides:
    
    hashCode in class Object
  - inducePostDecrement
```
public final <S extends Scalar<?>> S inducePostDecrement(S aTarget)
                                           throws NullPointerException,
                                                  NoSuchElementException,
                                                  UnsupportedOperationException,
                                                  IllegalStateException
```
    Description copied from interface: ScalarInductor
    
    Decrement the value of this scalar then induce its original value into the specified target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which the current value of this scalar will be induced, prior to decrementing
    
    Returns:
    the target
    
    Throws:
    
    NullPointerException - a null value was provided when none was expected
    
    NoSuchElementException - an expected parameter was not found in the parameter source
    
    UnsupportedOperationException - this target primitive cannot be changed
    
    IllegalStateException - this target primitive cannot be changed at this time
  - inducePostIncrement
```
public final <S extends Scalar<?>> S inducePostIncrement(S aTarget)
                                           throws NullPointerException,
                                                  NoSuchElementException,
                                                  UnsupportedOperationException,
                                                  IllegalStateException
```
    Description copied from interface: ScalarInductor
    
    Increment the value of this scalar then induce its original value into the specified target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which the current value of this scalar will be induced, prior to incrementing
    
    Returns:
    the target
    
    Throws:
    
    NullPointerException - a null value was provided when none was expected
    
    NoSuchElementException - an expected parameter was not found in the parameter source
    
    UnsupportedOperationException - this target primitive cannot be changed
    
    IllegalStateException - this target primitive cannot be changed at this time
  - induceRealMaximum
```
public final <REAL extends Real<?>> REAL induceRealMaximum(REAL aTarget)
                                          throws NullPointerException,
                                                 NoSuchElementException,
                                                 UnsupportedOperationException,
                                                 IllegalStateException
```
    Description copied from interface: SealedRealDomain
    
    Induce the maximum domain value into the target
    
    Type Parameters:
    REAL - the target type
    Parameters:
    aTarget - a target into which this domain's maximum value will be induced
    
    Returns:
    the target
    
    Throws:
    
    NullPointerException - a null value was provided when none was expected
    
    NoSuchElementException - an expected parameter was not found in the parameter source
    
    UnsupportedOperationException - this target primitive cannot be changed
    
    IllegalStateException - this target primitive cannot be changed at this time
  - induceRealMinimum
```
public final <REAL extends Real<?>> REAL induceRealMinimum(REAL aTarget)
                                          throws NullPointerException,
                                                 NoSuchElementException,
                                                 UnsupportedOperationException,
                                                 IllegalStateException
```
    Description copied from interface: SealedRealDomain
    
    Induce the minimum domain value into the target
    
    Type Parameters:
    REAL - the target type
    Parameters:
    aTarget - a target into which this domain's minimum value will be induced
    
    Returns:
    the target
    
    Throws:
    
    NullPointerException - a null value was provided when none was expected
    
    NoSuchElementException - an expected parameter was not found in the parameter source
    
    UnsupportedOperationException - this target primitive cannot be changed
    
    IllegalStateException - this target primitive cannot be changed at this time
  - induceRealValue
```
public final <REAL extends Real<?>> REAL induceRealValue(REAL aTarget)
                                        throws NullPointerException,
                                               NoSuchElementException,
                                               UnsupportedOperationException,
                                               IllegalStateException
```
    Description copied from interface: RealInductor
    
    Induce the current value of this real into the specified target
    
    Type Parameters:
    REAL - the target type
    Parameters:
    aTarget - a target into which the current value of this real will be induced
    
    Returns:
    the target
    
    Throws:
    
    NullPointerException - a null value was provided when none was expected
    
    NoSuchElementException - an expected parameter was not found in the parameter source
    
    UnsupportedOperationException - this target primitive cannot be changed
    
    IllegalStateException - this target primitive cannot be changed at this time
  - induceScalarMaximum
```
public final <S extends Scalar<?>> S induceScalarMaximum(S aTarget)
```
    Description copied from interface: SealedScalarDomain
    
    Induce the maximum domain value into the target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which this domain's maximum value will be induced
    
    Returns:
    the target
  - induceScalarMinimum
```
public final <S extends Scalar<?>> S induceScalarMinimum(S aTarget)
```
    Description copied from interface: SealedScalarDomain
    
    Induce the minimum domain value into the target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which this domain's minimum value will be induced
    
    Returns:
    the target
  - induceScalarValue
```
public final <S extends Scalar<?>> S induceScalarValue(S aTarget)
```
    Description copied from interface: ScalarInductor
    
    Induce the current value of this scalar into the specified target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which the current value of this scalar will be induced
    
    Returns:
    the target
  - intPostDecrement
```
public final int intPostDecrement()
                           throws UnsupportedOperationException,
                                  ArithmeticException,
                                  IllegalArgumentException
```
    Description copied from interface: MutableIntegerValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - intPostIncrement
```
public final int intPostIncrement()
                           throws UnsupportedOperationException,
                                  ArithmeticException,
                                  IllegalArgumentException
```
    Description copied from interface: MutableIntegerValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - intValue
```
public final int intValue()
```
    Specified by:
    
    intValue in interface SealedIntegerValue
    
    Specified by:
    
    intValue in class Number
    
    Returns:
    the property value as a system int
  - inverse
```
public final PRIMITIVE inverse()
                                                     throws UnsupportedOperationException,
                                                            ArithmeticException,
                                                            IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value its multiplicative inverse (1/x)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - isDigit
```
public final boolean isDigit()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is a digit within Unicode
    
    Specified by:
    
    isDigit in interface CharacterProperties
    
    Overrides:
    
    isDigit in class AbstractScalar<PRIMITIVE extends 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)
  - isFinite
```
public final boolean isFinite()
```
    Specified by:
    
    isFinite in interface NumericProperties
    
    Overrides:
    
    isFinite in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if this value represents a valid and finite value
  - isIdentifierIgnorable
```
public final boolean isIdentifierIgnorable()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character ignorable character in a Java identifier or a Unicode identifier
    
    Specified by:
    
    isIdentifierIgnorable in interface CharacterProperties
    
    Overrides:
    
    isIdentifierIgnorable in class AbstractScalar<PRIMITIVE extends 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)
  - isInfinity
```
public final boolean isInfinity()
```
    Returns:
    true if this number represents either positive or negative infinity
  - isInvalid
```
public final boolean isInvalid()
```
    Returns:
    true if this value does not represent a valid number, such as 0/0 (INVALID)
    See Also:
    INVALID at Wikipedia
  - isISOControl
```
public final boolean isISOControl()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is an ISO control character within Unicode
    
    Specified by:
    
    isISOControl in interface CharacterProperties
    
    Overrides:
    
    isISOControl in class AbstractScalar<PRIMITIVE extends 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)
  - isMaximum
```
public final boolean isMaximum()
```
    Returns:
    true if this value represents the maximum rational value in the totally ordered set it represents
  - isMinimum
```
public final boolean isMinimum()
```
    Returns:
    true if this value represents the minimum rational value in the totally ordered set it represents
  - isMirrored
```
public final boolean isMirrored()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is "mirrored" within Unicode
    
    Specified by:
    
    isMirrored in interface CharacterProperties
    
    Overrides:
    
    isMirrored in class AbstractScalar<PRIMITIVE extends 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
  - isNegative
```
public final boolean isNegative()
```
    Returns:
    true if this value represents a negative value
  - isNegativeFinite
```
public final boolean isNegativeFinite()
```
    Specified by:
    
    isNegativeFinite in interface NumericProperties
    
    Overrides:
    
    isNegativeFinite in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if this value represents a valid, finite and negative value
  - isNegativeInfinity
```
public final boolean isNegativeInfinity()
```
    Returns:
    true if this value represents negative infinity
  - isPositive
```
public final boolean isPositive()
```
    Returns:
    true if this value represents a positive value
  - isPositiveFinite
```
public final boolean isPositiveFinite()
```
    Specified by:
    
    isPositiveFinite in interface NumericProperties
    
    Overrides:
    
    isPositiveFinite in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if this value represents a valid, finite and negative value
  - isPositiveInfinity
```
public final boolean isPositiveInfinity()
```
    Returns:
    true if this value represents positive infinity
  - isReal
```
public final boolean isReal()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the magnitude of a vector into the set of real numbers. This is not the same as testing whether this object's implementation resembles the specification for the REAL domain, since that is too specific to implementation machinery. This more general test also includes real modulo values in its specification.
    
    Returns:
    true if this value represents the magnitude of a vector into the set of real numbers
  - 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)
  - 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)
  - isUnity
```
public final boolean isUnity()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the multiplicative identity in its arithmetic domain. For real numbers this is 1, for matrices it would be the identity matrix and for functions this would be a pass-through.
    
    Returns:
    true if this value represents the multiplicative identity in its domain
  - isUpperCase
```
public final boolean isUpperCase()
```
    Description copied from interface: CharacterProperties
    
    Determine if this char-width or int-width character is an upper case character within Unicode
    
    Specified by:
    
    isUpperCase in interface CharacterProperties
    
    Overrides:
    
    isUpperCase in class AbstractScalar<PRIMITIVE extends 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)
  - isZero
```
public final boolean isZero()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the additive identity in its algebraic group. For real numbers this is 0, for matrices this would be the zero matrix and for functions this would map every parameter to zero.
    
    Returns:
    true if this value represents the additive identity in its algebraic group
  - longPostDecrement
```
public final long longPostDecrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableLongValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - longPostIncrement
```
public final long longPostIncrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableLongValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - longValue
```
public final long longValue()
```
    Specified by:
    
    longValue in interface SealedLongValue
    
    Specified by:
    
    longValue in class Number
    
    Returns:
    the property value as a system long
  - lowerCase
```
public final PRIMITIVE lowerCase()
```
    Description copied from interface: MutableTextValue
    
    For text-based objects, convert all characters in the text to lower case. For numeric objects, convert their character (BMP) or integer value (Unicode) to lower case, depending on the object's precision level
    
    Specified by:
    
    lowerCase in interface MutableTextValue<PRIMITIVE extends 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)
  - or
```
public final PRIMITIVE or(boolean aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    or in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - or
```
public final PRIMITIVE or(byte aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    or in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - or
```
public final PRIMITIVE or(short aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    or in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    or in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
public final PRIMITIVE product(boolean aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
public final PRIMITIVE product(byte aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
public final PRIMITIVE product(short aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    product in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
public final PRIMITIVE quotient(boolean aValue)
                                                      throws UnsupportedOperationException,
                                                             IllegalArgumentException,
                                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient between its current value and the specified value
    
    Specified by:
    
    quotient in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotient in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
public final PRIMITIVE quotient(byte aValue)
                                                      throws UnsupportedOperationException,
                                                             IllegalArgumentException,
                                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Specified by:
    
    quotient in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotient in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
public final PRIMITIVE quotient(short aValue)
                                                      throws UnsupportedOperationException,
                                                             IllegalArgumentException,
                                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Specified by:
    
    quotient in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    quotient in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - round
```
public final PRIMITIVE round(RoundingStrategy aRoundingStrategy)
                                                   throws UnsupportedOperationException,
                                                          IllegalArgumentException,
                                                          ArithmeticException,
                                                          NullPointerException
```
    Description copied from interface: MutableScalar
    
    Round the current value using the specified rounding strategy
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    NullPointerException
  - setMaximum
```
public final PRIMITIVE setMaximum()
                                                        throws UnsupportedOperationException,
                                                               ArithmeticException,
                                                               IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with maximum value available for the implementation's numeric precision. Unlimited values will be replaced with the maximum value available for the most precise system scalar appropriate for the implementation, that is unlimited integer primitives will set themselves to the maximum long value and unlimited decimal primitives will set themselves to the maximum double value.
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - setMinimum
```
public final PRIMITIVE setMinimum()
                                                        throws UnsupportedOperationException,
                                                               ArithmeticException,
                                                               IllegalArgumentException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with minimum value available for the implementation's numeric precision. Unlimited values will be replaced with the minimum value available for the most precise system scalar appropriate for the implementation, that is unlimited integer primitives will set themselves to the minimum long value and unlimited decimal primitives will set themselves to the minimum double value.
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - setNumber
```
public final PRIMITIVE setNumber(Number aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException,
                                                              NullPointerException
```
    Description copied from interface: MutableScalar
    
    Set this object to the specified system-supported Number and answer this object (facilitates chaining)
    
    Specified by:
    
    setNumber in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setNumber in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a system-supported Number
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setPrimitive
```
public final PRIMITIVE setPrimitive(SealedPrimitive<?> aValue)
                                                          throws UnsupportedOperationException,
                                                                 IllegalArgumentException,
                                                                 ArithmeticException,
                                                                 NullPointerException
```
    Description copied from interface: MutablePrimitive
    
    Set this property to the specified primitive
    
    Specified by:
    
    setPrimitive in interface MutablePrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setPrimitive in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a primitive
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setReal
```
public final PRIMITIVE setReal(BigDecimal aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException,
                                                            NullPointerException
```
    Description copied from interface: MutableUnlimitedDecimalValue
    
    Set this property to the specified unlimited decimal value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - an unlimited decimal value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setReal
```
public final PRIMITIVE setReal(BigInteger aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException,
                                                            NullPointerException
```
    Description copied from interface: MutableUnlimitedIntegerValue
    
    Set this property to the specified unlimited integer value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - an unlimited integer value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setReal
```
public final PRIMITIVE setReal(SealedReal<?> aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException,
                                                            NullPointerException
```
    Description copied from interface: MutableReal
    
    Set this property to the specified numeric primitive and answer this object (facilitates chaining)
    
    Specified by:
    
    setReal in interface MutableReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setReal in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a numeric primitive
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setScalar
```
public final PRIMITIVE setScalar(boolean aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableBooleanValue
    
    Set this property to the specified boolean value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a boolean value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
  - setScalar
```
public final PRIMITIVE setScalar(byte aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableByteValue
    
    Set this property to the specified byte value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a byte value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
  - setScalar
```
public final PRIMITIVE setScalar(double aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableDoubleValue
    
    Set this property to the specified double value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a double value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
  - setScalar
```
public final PRIMITIVE setScalar(float aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableFloatValue
    
    Set this property to the specified float value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a float value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
  - setScalar
```
public final PRIMITIVE setScalar(int aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableIntegerValue
    
    Set this property to the specified int value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - an int value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
  - setScalar
```
public final PRIMITIVE setScalar(long aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableLongValue
    
    Set this property to the specified long value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a long value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
  - setScalar
```
public final PRIMITIVE setScalar(SealedScalar<?> aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException,
                                                              NullPointerException
```
    Description copied from interface: MutableScalar
    
    Set this object to the specified scalar
    
    Specified by:
    
    setScalar in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setScalar in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a scalar
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setScalar
```
public final PRIMITIVE setScalar(short aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableShortValue
    
    Set this property to the specified short value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a short value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
  - setUnity
```
public final PRIMITIVE setUnity()
                                                      throws UnsupportedOperationException,
                                                             IllegalArgumentException,
                                                             ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the multiplicative identity appropriate for the implementation (one)
    
    Specified by:
    
    setUnity in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setUnity in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - setZero
```
public final PRIMITIVE setZero()
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the additive identity appropriate for the implementation (zero)
    
    Specified by:
    
    setZero in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setZero in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - shortPostDecrement
```
public final short shortPostDecrement()
                               throws UnsupportedOperationException,
                                      ArithmeticException,
                                      IllegalArgumentException
```
    Description copied from interface: MutableShortValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - shortPostIncrement
```
public final short shortPostIncrement()
                               throws UnsupportedOperationException,
                                      ArithmeticException,
                                      IllegalArgumentException
```
    Description copied from interface: MutableShortValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - shortValue
```
public final short shortValue()
```
    Specified by:
    
    shortValue in interface SealedShortValue
    
    Overrides:
    
    shortValue in class Number
    
    Returns:
    the property value as a system short
  - square
```
public final PRIMITIVE square()
                                                    throws UnsupportedOperationException,
                                                           IllegalArgumentException,
                                                           ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the square of itself
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
public final PRIMITIVE sum(boolean aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
public final PRIMITIVE sum(byte aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
public final PRIMITIVE sum(short aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    sum in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - swapPrimitives
```
public final PRIMITIVE swapPrimitives(Primitive<?> aPrimitive)
```
    Description copied from interface: Primitive
    
    Swap the value of this primitive for the specified one and set the specified primitive's value to the current value of this primitive
    
    Parameters:
    aPrimitive - the primitive to swap with
    
    Returns:
    this primitive
  - 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)
  - toNumber
```
public final Number toNumber()
```
    Returns:
    this object as a best-match, system-supported Number object
  - toString
```
public final String toString()
```
    Specified by:
    
    toString in interface CharSequence
    
    Specified by:
    
    toString in interface SealedKernel
    
    Overrides:
    
    toString in class Object
  - toUnlimitedDecimal
```
public final BigDecimal toUnlimitedDecimal()
```
    Returns:
    the property value as an unlimited decimal property value
  - toUnlimitedInteger
```
public final BigInteger toUnlimitedInteger()
```
    Returns:
    the property value as an unlimited integer property value
  - unlimitedDecimalPostDecrement
```
public final BigDecimal unlimitedDecimalPostDecrement()
                                               throws UnsupportedOperationException,
                                                      ArithmeticException,
                                                      IllegalArgumentException
```
    Description copied from interface: MutableUnlimitedDecimalValue
    
    Decrement the real value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this real
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - unlimitedDecimalPostIncrement
```
public final BigDecimal unlimitedDecimalPostIncrement()
                                               throws UnsupportedOperationException,
                                                      ArithmeticException,
                                                      IllegalArgumentException
```
    Description copied from interface: MutableUnlimitedDecimalValue
    
    Increment the real value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this real
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - unlimitedIntegerPostDecrement
```
public final BigInteger unlimitedIntegerPostDecrement()
                                               throws UnsupportedOperationException,
                                                      ArithmeticException,
                                                      IllegalArgumentException
```
    Description copied from interface: MutableUnlimitedIntegerValue
    
    Decrement the real value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this real
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - unlimitedIntegerPostIncrement
```
public final BigInteger unlimitedIntegerPostIncrement()
                                               throws UnsupportedOperationException,
                                                      ArithmeticException,
                                                      IllegalArgumentException
```
    Description copied from interface: MutableUnlimitedIntegerValue
    
    Increment the real value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this real
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - upperCase
```
public final PRIMITIVE upperCase()
```
    Description copied from interface: MutableTextValue
    
    For text-based objects, convert all characters in the text to upper case. For numeric objects, convert their character (BMP) or integer value (Unicode) to upper case, depending on the object's precision level
    
    Specified by:
    
    upperCase in interface MutableTextValue<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    upperCase in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    this object (facilitates operation chaining)
  - xor
```
public final PRIMITIVE xor(boolean aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xor in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
public final PRIMITIVE xor(byte aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xor in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
public final PRIMITIVE xor(short aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xor in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    xor in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - firstChar
```
public static final char firstChar(CharSequence p0)
```

Class AbstractCharacterPrimitive<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.Object

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

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

Methods inherited from interface net.sf.jaccumulator.SealedKernel

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

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

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.SealedAlgebraicStructure

Methods inherited from interface net.sf.jaccumulator.StructureProperties

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

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

Methods inherited from interface net.sf.jaccumulator.Replicator

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

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.MutableAlgebraicStructure

Methods inherited from interface net.sf.jaccumulator.Mutable

Constructor Detail

AbstractCharacterPrimitive

Method Detail

absoluteValue

and

and

and

booleanPostDecrement

booleanPostIncrement

booleanValue

bytePostDecrement

bytePostIncrement

byteValue

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsingPrimitive

copyUsingReal

copyUsingScalar

copyUsingText

cube

difference

difference

difference

doublePostDecrement

doublePostIncrement

doubleValue

floatPostDecrement

floatPostIncrement

floatValue

hashCode

inducePostDecrement

inducePostIncrement

induceRealMaximum

induceRealMinimum

induceRealValue

induceScalarMaximum

induceScalarMinimum

induceScalarValue

intPostDecrement

intPostIncrement

intValue

inverse