AbstractIntegerPrimitive (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.integers.AbstractIntegerPrimitive<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:

AbstractModuloIntegerPrimitive, IntegerPrimitive
```
public abstract class AbstractIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
extends AbstractNumericPrimitive<PRIMITIVE>
```
Abstract int 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

AbstractIntegerPrimitive()

AbstractIntegerPrimitive(Domain aDomain)

Constructors
Constructor and Description
`AbstractIntegerPrimitive()`
`AbstractIntegerPrimitive(Domain aDomain)`

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(char aValue)` Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`and(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()`
`char`	`charPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`char`	`charPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`char`	`charValue()`
`PRIMITIVE`	`copyUsing(BigDecimal aValue)` Using this real as a factory, produce a new real of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsing(BigInteger aValue)` Using this real as a factory, produce a new real of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsing(boolean aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(byte aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(char aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(double aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(float aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(long aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsing(short aValue)` Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
`PRIMITIVE`	`copyUsingPrimitive(SealedPrimitive<?> aValue)` Using this primitive as a factory, produce a new primitive of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsingReal(SealedReal<?> aValue)` Using this real as a factory, produce a new real of the same type but initialized with the value specified
`PRIMITIVE`	`copyUsingScalar(SealedScalar<?> aValue)` Using this scalar as a factory, produce a new scalar of the same type but initialized with the value specified
`PRIMITIVE`	`cube()` Replace the current value with the cube of itself
`PRIMITIVE`	`difference(boolean aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`difference(byte aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`difference(char aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`PRIMITIVE`	`difference(short aValue)` Set the value of this scalar to the mathematical difference between its current value and the specified value
`double`	`doublePostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`double`	`doublePostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`double`	`doubleValue()`
`float`	`floatPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`float`	`floatPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`float`	`floatValue()`
`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
`PRIMITIVE`	`inverse()` Replace the current value its multiplicative inverse (`1/x`)
`boolean`	`isFinite()`
`boolean`	`isInfinity()`
`boolean`	`isInvalid()`
`boolean`	`isMaximum()`
`boolean`	`isMinimum()`
`boolean`	`isModulo()` Answer `true` if this value represents the magnitude of a vector into a modulo set, or finite ring.
`boolean`	`isNegative()`
`boolean`	`isNegativeFinite()`
`boolean`	`isNegativeInfinity()`
`boolean`	`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`	`isUnity()` Answer `true` if this value represents the multiplicative identity in its arithmetic domain.
`boolean`	`isZero()` Answer `true` if this value represents the additive identity in its algebraic group.
`long`	`longPostDecrement()` Decrement the scalar value of this object then return the original value prior to decrementing
`long`	`longPostIncrement()` Increment the scalar value of this object then return the original value prior to incrementing
`long`	`longValue()`
`PRIMITIVE`	`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(char aValue)` Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`or(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(char 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(char aValue)` Set the value of this scalar to the mathematical quotient between 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(char aValue)` Set this property to the specified `char` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(double aValue)` Set this property to the specified `double` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(float aValue)` Set this property to the specified `float` value and answer this object (facilitates chaining)
`PRIMITIVE`	`setScalar(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(char 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
`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`	`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(char aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
`PRIMITIVE`	`xor(short aValue)` Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector

Methods inherited from class net.sf.jaccumulator.primitives.AbstractNumericPrimitive
append, append, append, append, append, append, append, append, append, append, append, append, append, append, appendCodePoint, charAt, clear, clearContents, clearText, codePointAt, codePointBefore, codePointCount, compareTo, compareToPrimitive, copyUsingText, delete, deleteCharAt, equals, 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, lowerCase, 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, titleCase, toPrimitive, toPrimitive, trim, upperCase

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, 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, 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, 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, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqualToScalar, isOrdered, 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, orOfScalar, power, power, powerOfNumber, powerOfScalar, product, product, product, product, productOfScalar, promoteTo, 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, 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, xorOfScalar

Methods inherited from class java.lang.Number
intValue

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, 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.integers.SealedIntegerValue
intValue

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, andOfNumber, andOfScalar, angleWith, angleWithNumber, angleWithScalar, arcCosine, arcSine, arcTangent, base10Log, ceiling, cosine, cubeRoot, decrement, degrees, 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, orOfNumber, orOfScalar, power, power, powerOfNumber, powerOfScalar, product, product, product, product, productOfNumber, productOfScalar, quotient, quotient, quotient, quotient, quotientOfNumber, quotientOfScalar, radians, random, setE, setEnumeration, setNegativeInfinity, setPi, setPositiveInfinity, shiftLeft, shiftRight, shiftRightExtendZero, sine, squareRoot, sum, sum, sum, sum, sumOfNumber, sumOfScalar, tangent, up, xor, xor, xorOfNumber, xorOfScalar

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

Methods inherited from interface net.sf.jaccumulator.integers.MutableIntegerValue
intPostDecrement, intPostIncrement, 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
  - AbstractIntegerPrimitive
```
public AbstractIntegerPrimitive()
```
  - AbstractIntegerPrimitive
```
public AbstractIntegerPrimitive(Domain aDomain)
```
- Method Detail
  - absoluteValue
```
public 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(char aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    and in interface MutableScalar<PRIMITIVE extends 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
  - charPostDecrement
```
public final char charPostDecrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableCharacterValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - charPostIncrement
```
public final char charPostIncrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableCharacterValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - charValue
```
public final char charValue()
```
    Returns:
    the property value as a system char
  - copyUsing
```
public final PRIMITIVE copyUsing(BigDecimal aValue)
```
    Description copied from interface: RealReplicator
    
    Using this real as a factory, produce a new real of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this real initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(BigInteger aValue)
```
    Description copied from interface: RealReplicator
    
    Using this real as a factory, produce a new real of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this real initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(boolean aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(byte aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(char aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(double aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(float aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(long aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsing
```
public final PRIMITIVE copyUsing(short aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - copyUsingPrimitive
```
public final PRIMITIVE copyUsingPrimitive(SealedPrimitive<?> aValue)
```
    Description copied from interface: PrimitiveReplicator
    
    Using this primitive as a factory, produce a new primitive of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this primitive initialized using the specified value
  - copyUsingReal
```
public final PRIMITIVE copyUsingReal(SealedReal<?> aValue)
```
    Description copied from interface: RealReplicator
    
    Using this real as a factory, produce a new real of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this real initialized using the specified value
  - copyUsingScalar
```
public final PRIMITIVE copyUsingScalar(SealedScalar<?> aValue)
```
    Description copied from interface: ScalarReplicator
    
    Using this scalar as a factory, produce a new scalar of the same type but initialized with the value specified
    
    Parameters:
    aValue - a new value
    
    Returns:
    a copy (clone) of this scalar initialized using the specified value
  - cube
```
public final PRIMITIVE cube()
                                                  throws UnsupportedOperationException,
                                                         IllegalArgumentException,
                                                         ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Replace the current value with the cube of itself
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - 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(char aValue)
                                                        throws UnsupportedOperationException,
                                                               IllegalArgumentException,
                                                               ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Specified by:
    
    difference in interface MutableScalar<PRIMITIVE extends 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 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 <S extends Scalar<?>> S induceScalarMaximum(S aTarget)
```
    Description copied from interface: SealedScalarDomain
    
    Induce the maximum domain value into the target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which this domain's maximum value will be induced
    
    Returns:
    the target
  - induceScalarMinimum
```
public <S extends Scalar<?>> S induceScalarMinimum(S aTarget)
```
    Description copied from interface: SealedScalarDomain
    
    Induce the minimum domain value into the target
    
    Type Parameters:
    S - the target type
    Parameters:
    aTarget - a target into which this domain's minimum value will be induced
    
    Returns:
    the target
  - induceScalarValue
```
public 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
  - inverse
```
public 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
  - 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
  - isInfinity
```
public final boolean isInfinity()
```
    Returns:
    true if this number represents either positive or negative infinity
  - isInvalid
```
public boolean isInvalid()
```
    Returns:
    true if this value does not represent a valid number, such as 0/0 (INVALID)
    See Also:
    INVALID at Wikipedia
  - isMaximum
```
public boolean isMaximum()
```
    Returns:
    true if this value represents the maximum rational value in the totally ordered set it represents
  - isMinimum
```
public boolean isMinimum()
```
    Returns:
    true if this value represents the minimum rational value in the totally ordered set it represents
  - isModulo
```
public 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
  - isUnity
```
public final boolean isUnity()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the multiplicative identity in its arithmetic domain. For real numbers this is 1, for matrices it would be the identity matrix and for functions this would be a pass-through.
    
    Returns:
    true if this value represents the multiplicative identity in its domain
  - isZero
```
public final boolean isZero()
```
    Description copied from interface: NumericProperties
    
    Answer true if this value represents the additive identity in its algebraic group. For real numbers this is 0, for matrices this would be the zero matrix and for functions this would map every parameter to zero.
    
    Returns:
    true if this value represents the additive identity in its algebraic group
  - longPostDecrement
```
public final long longPostDecrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableLongValue
    
    Decrement the scalar value of this object then return the original value prior to decrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - longPostIncrement
```
public final long longPostIncrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException
```
    Description copied from interface: MutableLongValue
    
    Increment the scalar value of this object then return the original value prior to incrementing
    
    Returns:
    the original value of this scalar
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
  - longValue
```
public final long longValue()
```
    Specified by:
    
    longValue in interface SealedLongValue
    
    Specified by:
    
    longValue in class Number
    
    Returns:
    the property value as a system long
  - 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(char aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    or in interface MutableScalar<PRIMITIVE extends 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(char aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Specified by:
    
    product in interface MutableScalar<PRIMITIVE extends 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(char 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(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 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 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 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 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 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 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 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(char aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Description copied from interface: MutableCharacterValue
    
    Set this property to the specified char value and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a char value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
  - setScalar
```
public 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 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 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 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(char aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Specified by:
    
    sum in interface MutableScalar<PRIMITIVE extends 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
  - toNumber
```
public final Number toNumber()
```
    Returns:
    this object as a best-match, system-supported Number object
  - toString
```
public 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
  - 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(char aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Description copied from interface: MutableScalar
    
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Specified by:
    
    xor in interface MutableScalar<PRIMITIVE extends 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

Class AbstractIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

Field Summary

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

Constructor Summary

Method Summary

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

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

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

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

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

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

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

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

AbstractIntegerPrimitive

AbstractIntegerPrimitive

Method Detail

absoluteValue

and

and

and

and

booleanPostDecrement

booleanPostIncrement

booleanValue

bytePostDecrement

bytePostIncrement

byteValue

charPostDecrement

charPostIncrement

charValue

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsing

copyUsingPrimitive

copyUsingReal

copyUsingScalar

cube

difference

difference

difference

difference

doublePostDecrement

doublePostIncrement

doubleValue

floatPostDecrement

floatPostIncrement

floatValue

hashCode

inducePostDecrement

inducePostIncrement

induceRealMaximum

induceRealMinimum

induceRealValue

induceScalarMaximum