AbstractNumericPrimitive (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>

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:

AbstractBooleanPrimitive, AbstractBytePrimitive, AbstractCharacterPrimitive, AbstractConstant, AbstractDoublePrimitive, AbstractFloatPrimitive, AbstractIntegerPrimitive, AbstractLongPrimitive, AbstractShortPrimitive, AbstractUnlimitedDecimalPrimitive, AbstractUnlimitedIntegerPrimitive, RandomPrimitive
```
public abstract class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
extends AbstractPrimitive<PRIMITIVE>
```
Common read and write behavior for representations of real number explicitly implemented either as a boolean vector into the real number domain, or any unlimited array

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
`AbstractNumericPrimitive()`
`AbstractNumericPrimitive(Domain aDomain, NumericPrecision aPrecision)`
`AbstractNumericPrimitive(NumericPrecision aPrecision)`

Method Summary

Methods
Modifier and Type	Method and Description
`PRIMITIVE`	`append(boolean aValue)`
`PRIMITIVE`	`append(char c)`
`PRIMITIVE`	`append(char[] content)`
`PRIMITIVE`	`append(char[] content, int contentIndex)`
`PRIMITIVE`	`append(char[] content, int contentIndex, int contentLength)`
`PRIMITIVE`	`append(CharSequence s)`
`PRIMITIVE`	`append(CharSequence s, int start)`
`PRIMITIVE`	`append(CharSequence s, int start, int end)`
`PRIMITIVE`	`append(double aValue)`
`PRIMITIVE`	`append(float aValue)`
`PRIMITIVE`	`append(int aValue)`
`PRIMITIVE`	`append(long aValue)`
`PRIMITIVE`	`append(Object aValue)`
`PRIMITIVE`	`append(StringBuffer sb)`
`PRIMITIVE`	`appendCodePoint(int codePoint)`
`char`	`charAt(int index)`
`void`	`clear()` Same as `Collection.clear()`.
`PRIMITIVE`	`clearContents()` Clear all elements of this structure and answer this object (facilitates chaining}. For text primitives all characters will be removed in an exact analog to `clear()`.
`PRIMITIVE`	`clearText()` Clear all characters from this primitive and re-interpret/re-set
`int`	`codePointAt(int index)`
`int`	`codePointBefore(int index)`
`int`	`codePointCount(int beginIndex, int endIndex)`
`int`	`compareTo(SealedPrimitive<?> aComparable)`
`int`	`compareToPrimitive(SealedPrimitive<?> aComparable)` Compares this object with the specified object for order
`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`	`delete(int start, int end)`
`PRIMITIVE`	`deleteCharAt(int anIndex)`
`boolean`	`equals(Object anObject)`
`StructureStrategy`	`getStructureStrategy()`
`int`	`indexOfText(CharSequence str)`
`int`	`indexOfText(CharSequence str, int beginIndex)`
`<P extends Primitive<?>> P`	`inducePostDecrement(P aTarget)` Decrement the value of this Primitive then induce its original value into the specified target
`<R extends Real<?>> R`	`inducePostDecrement(R aTarget)` Decrement the value of this real then induce its original value into the specified target
`<P extends Primitive<?>> P`	`inducePostIncrement(P aTarget)` Increment the value of this Primitive then induce its original value into the specified target
`<R extends Real<?>> R`	`inducePostIncrement(R aTarget)` Increment the value of this real then induce its original value into the specified target
`<P extends Primitive<?>> P`	`inducePrimitiveValue(P aTarget)` Induce the current value of this Primitive into the specified target
`<TEXT extends Text<?>> TEXT`	`induceTextValue(TEXT aTarget)` Induce the current value of this text into the specified target
`PRIMITIVE`	`insert(int anIndex, boolean aValue)`
`PRIMITIVE`	`insert(int anIndex, char aValue)`
`PRIMITIVE`	`insert(int anIndex, char[] content)`
`PRIMITIVE`	`insert(int targetIndex, char[] content, int contentIndex, int contentLength)`
`PRIMITIVE`	`insert(int anIndex, CharSequence content)`
`PRIMITIVE`	`insert(int targetIndex, CharSequence content, int contentIndex)`
`PRIMITIVE`	`insert(int targetIndex, CharSequence content, int contentStartIndex, int contentEndIndexPlusOne)`
`PRIMITIVE`	`insert(int anIndex, double aValue)`
`PRIMITIVE`	`insert(int anIndex, float aValue)`
`PRIMITIVE`	`insert(int anIndex, int aValue)`
`PRIMITIVE`	`insert(int anIndex, long aValue)`
`PRIMITIVE`	`insert(int anIndex, Object aValue)`
`boolean`	`isEmpty()` Answer `true` if this structure contains no elements.
`boolean`	`isEqualToPrimitive(SealedPrimitive<?> aValue)`
`boolean`	`isEqualToText(CharSequence aValue)`
`boolean`	`isGreaterOrEqualToPrimitive(SealedPrimitive<?> aValue)`
`boolean`	`isGreaterOrEqualToText(CharSequence aValue)`
`boolean`	`isGreaterThanPrimitive(SealedPrimitive<?> aValue)`
`boolean`	`isGreaterThanText(CharSequence aValue)`
`boolean`	`isLessOrEqualToPrimitive(SealedPrimitive<?> aValue)`
`boolean`	`isLessOrEqualToText(CharSequence aValue)`
`boolean`	`isLessThanPrimitive(SealedPrimitive<?> aValue)`
`boolean`	`isLessThanText(CharSequence aValue)`
`boolean`	`isNotEqualToPrimitive(SealedPrimitive<?> aValue)`
`boolean`	`isNotEqualToText(CharSequence aValue)`
`boolean`	`isText()`
`int`	`length()`
`PRIMITIVE`	`lowerCase()` For text-based objects, convert all characters in the text to lower case.
`PRIMITIVE`	`prepend(boolean aValue)`
`PRIMITIVE`	`prepend(char c)`
`PRIMITIVE`	`prepend(char[] content)`
`PRIMITIVE`	`prepend(char[] content, int contentIndex)`
`PRIMITIVE`	`prepend(char[] content, int contentIndex, int contentLength)`
`PRIMITIVE`	`prepend(CharSequence s)`
`PRIMITIVE`	`prepend(CharSequence s, int start)`
`PRIMITIVE`	`prepend(CharSequence s, int start, int end)`
`PRIMITIVE`	`prepend(double aValue)`
`PRIMITIVE`	`prepend(float aValue)`
`PRIMITIVE`	`prepend(int aValue)`
`PRIMITIVE`	`prepend(long aValue)`
`PRIMITIVE`	`prepend(Object aValue)`
`PRIMITIVE`	`replace(CharSequence target, CharSequence replacement)`
`PRIMITIVE`	`replace(int start, int end, String str)`
`PRIMITIVE`	`replaceAll(String regex, String replacement)`
`PRIMITIVE`	`replaceCharacter(char oldChar, char newChar)`
`PRIMITIVE`	`replaceFirst(String regex, String replacement)`
`PRIMITIVE`	`reverse()`
`PRIMITIVE`	`setBoolean(Boolean aValue)` Set this property to the specified system-supported `Boolean` and answer this object (facilitates chaining)
`PRIMITIVE`	`setCharacter(Character aValue)` Set this property to the specified system-supported `Character` and answer this object (facilitates chaining)
`PRIMITIVE`	`setCharAt(int index, char ch)`
`PRIMITIVE`	`setLength(int newLength)`
`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(SealedReal<?> aValue)` Set this property to the specified numeric `primitive` and answer this object (facilitates chaining)
`PRIMITIVE`	`setText(CharSequence content)` Set this property to the specified `text` value and answer this object (facilitates chaining)
`CharSequence`	`subSequence(int start, int end)`
`String`	`substring(int start)`
`String`	`substring(int start, int end)`
`String`	`textPostDecrement()` Decrement the real value of this text then return the original text prior to decrementing
`String`	`textPostIncrement()` Increment the real value of this text then return the original text prior to incrementing
`PRIMITIVE`	`titleCase()` For text-based objects, convert all characters in the text to `title` case.
`static Primitive<?>`	`toPrimitive(SealedReal<?> aReal)`
`static Primitive<?>`	`toPrimitive(SealedScalar<?> aScalar)`
`PRIMITIVE`	`trim()` Remove both leading and trailing `whitespace`
`PRIMITIVE`	`upperCase()` For text-based objects, convert all characters in the text to upper case.

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

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.primitives.Primitive
swapPrimitives

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

Methods inherited from interface net.sf.jaccumulator.reals.RealInductor
induceRealValue

Methods inherited from interface net.sf.jaccumulator.scalars.ScalarInductor
inducePostDecrement, inducePostIncrement, induceScalarValue

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

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

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

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

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

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

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

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

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.reals.SealedRealDomain
induceRealMaximum, induceRealMinimum

Methods inherited from interface net.sf.jaccumulator.scalars.SealedScalarDomain
getPrecision, induceScalarMaximum, induceScalarMinimum

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
copyUsing, copyUsing, copyUsingReal, toReal

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

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

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

Methods inherited from interface net.sf.jaccumulator.bytes.MutableByteValue
bytePostDecrement, bytePostIncrement, setScalar

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

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

Methods inherited from interface net.sf.jaccumulator.floats.MutableFloatValue
floatPostDecrement, floatPostIncrement, setScalar

Methods inherited from interface net.sf.jaccumulator.integers.MutableIntegerValue
intPostDecrement, intPostIncrement, setScalar

Methods inherited from interface net.sf.jaccumulator.longs.MutableLongValue
longPostDecrement, longPostIncrement, setScalar

Methods inherited from interface net.sf.jaccumulator.shorts.MutableShortValue
setScalar, shortPostDecrement, shortPostIncrement

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.unlimiteds.MutableUnlimitedIntegerValue
setReal, unlimitedIntegerPostDecrement, unlimitedIntegerPostIncrement

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

Methods inherited from interface net.sf.jaccumulator.unlimiteds.MutableUnlimitedDecimalValue
setReal, unlimitedDecimalPostDecrement, unlimitedDecimalPostIncrement

Methods inherited from interface java.lang.CharSequence
toString

- Constructor Detail
  - AbstractNumericPrimitive
```
public AbstractNumericPrimitive()
```
  - AbstractNumericPrimitive
```
public AbstractNumericPrimitive(Domain aDomain,
                        NumericPrecision aPrecision)
```
  - AbstractNumericPrimitive
```
public AbstractNumericPrimitive(NumericPrecision aPrecision)
```
- Method Detail
  - append
```
public PRIMITIVE append(boolean aValue)
```
  - append
```
public PRIMITIVE append(char c)
```
  - append
```
public PRIMITIVE append(char[] content)
```
  - append
```
public PRIMITIVE append(char[] content,
               int contentIndex)
```
  - append
```
public PRIMITIVE append(char[] content,
               int contentIndex,
               int contentLength)
```
  - append
```
public PRIMITIVE append(CharSequence s)
```
  - append
```
public PRIMITIVE append(CharSequence s,
               int start)
```
  - append
```
public PRIMITIVE append(CharSequence s,
               int start,
               int end)
```
  - append
```
public PRIMITIVE append(double aValue)
```
  - append
```
public PRIMITIVE append(float aValue)
```
  - append
```
public PRIMITIVE append(int aValue)
```
  - append
```
public PRIMITIVE append(long aValue)
```
  - append
```
public PRIMITIVE append(Object aValue)
```
  - append
```
public PRIMITIVE append(StringBuffer sb)
```
  - appendCodePoint
```
public PRIMITIVE appendCodePoint(int codePoint)
```
  - charAt
```
public char charAt(int index)
```
  - clear
```
public void clear()
```
    Description copied from interface: MutableAlgebraicStructure
    
    Same as Collection.clear(). So as to maintain compatibility, this function will not return the customary reference back to this structure.
    
    See Also:
    MutableAlgebraicStructure.clearContents(), Collection.clear(), MutableTextValue.clearText();
  - clearContents
```
public PRIMITIVE clearContents()
                                                     throws UnsupportedOperationException
```
    Description copied from interface: MutableAlgebraicStructure
    
    Clear all elements of this structure and answer this object (facilitates chaining}.
    
    For text primitives all characters will be removed in an exact analog to clear(). For bit tuples such as scalar primitives, this will reset all bits zero since those elements cannot be removed. For unlimited primitives all bytes in the representation will be removed, producing zero.
    
    Primarily, this function is provided as an alternative to clear(), which does not return a value. This function, in answering this object, facilitates operation chaining.
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    See Also:
    MutableAlgebraicStructure.clear(), Collection.clear(), MutableTextValue.clearText();
  - clearText
```
public PRIMITIVE clearText()
                                                 throws UnsupportedOperationException
```
    Description copied from interface: MutableTextValue
    
    Clear all characters from this primitive and re-interpret/re-set
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's text cannot be changed
    See Also:
    MutableTextValue.clear();, Collection.clear(), MutableAlgebraicStructure.clearContents()
  - codePointAt
```
public int codePointAt(int index)
```
  - codePointBefore
```
public int codePointBefore(int index)
```
  - codePointCount
```
public int codePointCount(int beginIndex,
                 int endIndex)
```
  - compareTo
```
public final int compareTo(SealedPrimitive<?> aComparable)
```
  - compareToPrimitive
```
public final int compareToPrimitive(SealedPrimitive<?> aComparable)
```
    Description copied from interface: SealedPrimitive
    
    Compares this object with the specified object for order
    
    Parameters:
    aComparable - an object to be compared to
    
    Returns:
    a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified object.
    See Also:
    Comparable.compareTo(Object)
  - 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
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this primitive initialized using the specified value
  - delete
```
public PRIMITIVE delete(int start,
               int end)
```
  - deleteCharAt
```
public PRIMITIVE deleteCharAt(int anIndex)
```
  - equals
```
public boolean equals(Object anObject)
```
    Specified by:
    
    equals in interface SealedKernel
    
    Overrides:
    
    equals in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
  - getStructureStrategy
```
public StructureStrategy getStructureStrategy()
```
    Returns:
    a lemma defining the general implementation approach for this structure
  - indexOfText
```
public int indexOfText(CharSequence str)
```
  - indexOfText
```
public int indexOfText(CharSequence str,
              int beginIndex)
```
  - inducePostDecrement
```
public <P extends Primitive<?>> P inducePostDecrement(P aTarget)
                                        throws NullPointerException,
                                               NoSuchElementException,
                                               UnsupportedOperationException,
                                               IllegalStateException
```
    Description copied from interface: PrimitiveInductor
    
    Decrement the value of this Primitive then induce its original value into the specified target
    
    Type Parameters:
    P - the target type
    Parameters:
    aTarget - a target into which the current value of this Primitive will be induced, prior to decrementing
    
    Returns:
    the target
    
    Throws:
    
    NullPointerException - a null value was provided when none was expected
    
    NoSuchElementException - an expected parameter was not found in the parameter source
    
    UnsupportedOperationException - this target Primitive cannot be changed
    
    IllegalStateException - this target Primitive cannot be changed at this time
  - inducePostDecrement
```
public <R extends Real<?>> R inducePostDecrement(R aTarget)
                                   throws NullPointerException,
                                          NoSuchElementException,
                                          UnsupportedOperationException,
                                          IllegalStateException
```
    Description copied from interface: RealInductor
    
    Decrement the value of this real then induce its original value into the specified target
    
    Type Parameters:
    R - the target type
    Parameters:
    aTarget - a target into which the current value of this real will be induced, prior to decrementing
    
    Returns:
    the target
    
    Throws:
    
    NullPointerException - a null value was provided when none was expected
    
    NoSuchElementException - an expected parameter was not found in the parameter source
    
    UnsupportedOperationException - this target primitive cannot be changed
    
    IllegalStateException - this target primitive cannot be changed at this time
  - inducePostIncrement
```
public <P extends Primitive<?>> P inducePostIncrement(P aTarget)
                                        throws NullPointerException,
                                               NoSuchElementException,
                                               UnsupportedOperationException,
                                               IllegalStateException
```
    Description copied from interface: PrimitiveInductor
    
    Increment the value of this Primitive then induce its original value into the specified target
    
    Type Parameters:
    P - the target type
    Parameters:
    aTarget - a target into which the current value of this Primitive will be induced, prior to incrementing
    
    Returns:
    the target
    
    Throws:
    
    NullPointerException - a null value was provided when none was expected
    
    NoSuchElementException - an expected parameter was not found in the parameter source
    
    UnsupportedOperationException - this target Primitive cannot be changed
    
    IllegalStateException - this target Primitive cannot be changed at this time
  - inducePostIncrement
```
public <R extends Real<?>> R inducePostIncrement(R aTarget)
                                   throws NullPointerException,
                                          NoSuchElementException,
                                          UnsupportedOperationException,
                                          IllegalStateException
```
    Description copied from interface: RealInductor
    
    Increment the value of this real then induce its original value into the specified target
    
    Type Parameters:
    R - the target type
    Parameters:
    aTarget - a target into which the current value of this real will be induced, prior to incrementing
    
    Returns:
    the target
    
    Throws:
    
    NullPointerException - a null value was provided when none was expected
    
    NoSuchElementException - an expected parameter was not found in the parameter source
    
    UnsupportedOperationException - this target primitive cannot be changed
    
    IllegalStateException - this target primitive cannot be changed at this time
  - inducePrimitiveValue
```
public <P extends Primitive<?>> P inducePrimitiveValue(P aTarget)
                                         throws NullPointerException,
                                                NoSuchElementException,
                                                UnsupportedOperationException,
                                                IllegalStateException
```
    Description copied from interface: PrimitiveInductor
    
    Induce the current value of this Primitive into the specified target
    
    Type Parameters:
    P - the target type
    Parameters:
    aTarget - a target into which the current value of this Primitive will be induced
    
    Returns:
    the target
    
    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
  - induceTextValue
```
public <TEXT extends Text<?>> TEXT induceTextValue(TEXT aTarget)
                                  throws NullPointerException,
                                         NoSuchElementException,
                                         UnsupportedOperationException,
                                         IllegalStateException
```
    Description copied from interface: TextInductor
    
    Induce the current value of this text into the specified target
    
    Type Parameters:
    TEXT - the target type
    Parameters:
    aTarget - a target into which the current value of this text 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
  - insert
```
public PRIMITIVE insert(int anIndex,
               boolean aValue)
```
  - insert
```
public PRIMITIVE insert(int anIndex,
               char aValue)
```
  - insert
```
public PRIMITIVE insert(int anIndex,
               char[] content)
```
  - insert
```
public PRIMITIVE insert(int targetIndex,
               char[] content,
               int contentIndex,
               int contentLength)
```
  - insert
```
public PRIMITIVE insert(int anIndex,
               CharSequence content)
```
  - insert
```
public PRIMITIVE insert(int targetIndex,
               CharSequence content,
               int contentIndex)
```
  - insert
```
public PRIMITIVE insert(int targetIndex,
               CharSequence content,
               int contentStartIndex,
               int contentEndIndexPlusOne)
```
  - insert
```
public PRIMITIVE insert(int anIndex,
               double aValue)
```
  - insert
```
public PRIMITIVE insert(int anIndex,
               float aValue)
```
  - insert
```
public PRIMITIVE insert(int anIndex,
               int aValue)
```
  - insert
```
public PRIMITIVE insert(int anIndex,
               long aValue)
```
  - insert
```
public PRIMITIVE insert(int anIndex,
               Object aValue)
```
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: StructureProperties
    
    Answer true if this structure contains no elements. For strings this would indicate an empty string (no characters in an empty array). For scalars this would indicate an empty set, or a zero bit count, which would be the case of null values. Note that, although the null constant technically contains zero elements, its string value evaluates to "null", which from a String perspective is not empty.
    
    Specified by:
    
    isEmpty in interface StructureProperties
    
    Specified by:
    
    isEmpty in interface TextProperties
    
    Overrides:
    
    isEmpty in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Returns:
    true if this structure contains no elements
  - isEqualToPrimitive
```
public final boolean isEqualToPrimitive(SealedPrimitive<?> aValue)
```
  - isEqualToText
```
public final boolean isEqualToText(CharSequence aValue)
```
  - isGreaterOrEqualToPrimitive
```
public final boolean isGreaterOrEqualToPrimitive(SealedPrimitive<?> aValue)
```
  - isGreaterOrEqualToText
```
public final boolean isGreaterOrEqualToText(CharSequence aValue)
```
  - isGreaterThanPrimitive
```
public final boolean isGreaterThanPrimitive(SealedPrimitive<?> aValue)
```
  - isGreaterThanText
```
public final boolean isGreaterThanText(CharSequence aValue)
```
  - isLessOrEqualToPrimitive
```
public final boolean isLessOrEqualToPrimitive(SealedPrimitive<?> aValue)
```
  - isLessOrEqualToText
```
public final boolean isLessOrEqualToText(CharSequence aValue)
```
  - isLessThanPrimitive
```
public final boolean isLessThanPrimitive(SealedPrimitive<?> aValue)
```
  - isLessThanText
```
public final boolean isLessThanText(CharSequence aValue)
```
  - isNotEqualToPrimitive
```
public final boolean isNotEqualToPrimitive(SealedPrimitive<?> aValue)
```
  - isNotEqualToText
```
public final boolean isNotEqualToText(CharSequence aValue)
```
  - isText
```
public boolean isText()
```
    Returns:
    true if this object utilizes a text-based implementation
  - length
```
public int length()
```
  - lowerCase
```
public 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
    
    Returns:
    this object (facilitates operation chaining)
  - prepend
```
public final PRIMITIVE prepend(boolean aValue)
```
  - prepend
```
public final PRIMITIVE prepend(char c)
```
  - prepend
```
public final PRIMITIVE prepend(char[] content)
```
  - prepend
```
public final PRIMITIVE prepend(char[] content,
                int contentIndex)
```
  - prepend
```
public final PRIMITIVE prepend(char[] content,
                int contentIndex,
                int contentLength)
```
  - prepend
```
public final PRIMITIVE prepend(CharSequence s)
```
  - prepend
```
public final PRIMITIVE prepend(CharSequence s,
                int start)
```
  - prepend
```
public final PRIMITIVE prepend(CharSequence s,
                int start,
                int end)
```
  - prepend
```
public final PRIMITIVE prepend(double aValue)
```
  - prepend
```
public final PRIMITIVE prepend(float aValue)
```
  - prepend
```
public final PRIMITIVE prepend(int aValue)
```
  - prepend
```
public final PRIMITIVE prepend(long aValue)
```
  - prepend
```
public final PRIMITIVE prepend(Object aValue)
```
  - replace
```
public PRIMITIVE replace(CharSequence target,
                CharSequence replacement)
```
  - replace
```
public PRIMITIVE replace(int start,
                int end,
                String str)
```
  - replaceAll
```
public PRIMITIVE replaceAll(String regex,
                   String replacement)
```
  - replaceCharacter
```
public PRIMITIVE replaceCharacter(char oldChar,
                         char newChar)
```
  - replaceFirst
```
public PRIMITIVE replaceFirst(String regex,
                     String replacement)
```
  - reverse
```
public PRIMITIVE reverse()
```
  - setBoolean
```
public final PRIMITIVE setBoolean(Boolean aValue)
                                                        throws UnsupportedOperationException,
                                                               IllegalArgumentException,
                                                               ArithmeticException,
                                                               NullPointerException
```
    Description copied from interface: MutablePrimitive
    
    Set this property to the specified system-supported Boolean and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a system-supported Boolean
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setCharacter
```
public final PRIMITIVE setCharacter(Character aValue)
                                                          throws UnsupportedOperationException,
                                                                 IllegalArgumentException,
                                                                 ArithmeticException,
                                                                 NullPointerException
```
    Description copied from interface: MutablePrimitive
    
    Set this property to the specified system-supported Character and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a system-supported Character
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setCharAt
```
public PRIMITIVE setCharAt(int index,
                  char ch)
```
  - setLength
```
public PRIMITIVE setLength(int newLength)
```
  - setNumber
```
public PRIMITIVE setNumber(Number aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException,
                                                        NullPointerException
```
    Description copied from interface: MutableScalar
    
    Set this object to the specified system-supported Number and answer this object (facilitates chaining)
    
    Specified by:
    
    setNumber in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Overrides:
    
    setNumber in class AbstractReal<PRIMITIVE extends Primitive<PRIMITIVE>>
    
    Parameters:
    aValue - a system-supported Number
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setPrimitive
```
public PRIMITIVE setPrimitive(SealedPrimitive<?> aValue)
                                                    throws UnsupportedOperationException,
                                                           IllegalArgumentException,
                                                           ArithmeticException,
                                                           NullPointerException
```
    Description copied from interface: MutablePrimitive
    
    Set this property to the specified primitive
    
    Parameters:
    aValue - a primitive
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setReal
```
public 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 AbstractReal<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
  - setText
```
public PRIMITIVE setText(CharSequence content)
                                               throws UnsupportedOperationException,
                                                      NullPointerException,
                                                      IllegalArgumentException
```
    Description copied from interface: MutableTextValue
    
    Set this property to the specified text value and answer this object (facilitates chaining)
    
    Parameters:
    content - a text value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    NullPointerException - a null value was provided and this implementation does not accept null values
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
  - subSequence
```
public CharSequence subSequence(int start,
                       int end)
```
  - substring
```
public String substring(int start)
```
  - substring
```
public String substring(int start,
               int end)
```
  - textPostDecrement
```
public String textPostDecrement()
                         throws UnsupportedOperationException,
                                ArithmeticException,
                                IllegalArgumentException
```
    Description copied from interface: MutableTextValue
    
    Decrement the real value of this text then return the original text prior to decrementing
    
    Returns:
    the original value of this text
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - textPostIncrement
```
public String textPostIncrement()
                         throws UnsupportedOperationException,
                                ArithmeticException,
                                IllegalArgumentException
```
    Description copied from interface: MutableTextValue
    
    Increment the real value of this text then return the original text prior to incrementing
    
    Returns:
    the original value of this text
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - titleCase
```
public 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
    
    Returns:
    this object (facilitates operation chaining)
  - trim
```
public PRIMITIVE trim()
```
    Description copied from interface: MutableTextValue
    
    Remove both leading and trailing whitespace
    
    Returns:
    this object (facilitates operation chaining)
  - upperCase
```
public 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
    
    Returns:
    this object (facilitates operation chaining)
  - toPrimitive
```
public static final Primitive<?> toPrimitive(SealedReal<?> aReal)
```
  - toPrimitive
```
public static final Primitive<?> toPrimitive(SealedScalar<?> aScalar)
```

Class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

Field Summary

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

Constructor Summary

Method Summary

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

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

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

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

Methods inherited from interface net.sf.jaccumulator.primitives.Primitive

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

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.SealedKernel

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Methods inherited from interface net.sf.jaccumulator.MutableAlgebraicStructure

Methods inherited from interface net.sf.jaccumulator.Mutable

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

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

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

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

Methods inherited from interface java.lang.CharSequence

Constructor Detail

AbstractNumericPrimitive

AbstractNumericPrimitive

AbstractNumericPrimitive

Method Detail

append

append

append

append

append

append

append

append

append

append

append

append

append

append

appendCodePoint

charAt

clear

clearContents

clearText

codePointAt

codePointBefore