net.sf.jaccumulator.integers

Class AbstractModuloIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

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>

net.sf.jaccumulator.integers.AbstractModuloIntegerPrimitive<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:

EnumerationPrimitive, ModuloIntegerPrimitive

public abstract class AbstractModuloIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
extends AbstractIntegerPrimitive<PRIMITIVE>

Common behavior for all integer primitives that obey modular arithmetic

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
AbstractModuloIntegerPrimitive()
AbstractModuloIntegerPrimitive(Class<E> anEnumerationClass)
AbstractModuloIntegerPrimitive(Enum<?> anEnumeration)
AbstractModuloIntegerPrimitive(Enum<?>[] values)
AbstractModuloIntegerPrimitive(int aLimit)

Method Summary

Methods

Modifier and Type	Method and Description
PRIMITIVE	absoluteValue() Replace the current value with the absolute value of itself
PRIMITIVE	and(int aValue) Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
PRIMITIVE	decrement() Replace the current value with the current value minus unity (one)
PRIMITIVE	difference(int aValue) Set the value of this scalar to the mathematical difference between its current value and the specified value
int	getMaximumValue()
int	getModularLimit()
StructureStrategy	getStructureStrategy()
PRIMITIVE	increment() Replace the current value with the current value plus unity (one)
<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
int	intPostDecrement() Decrement the scalar value of this object then return the original value prior to decrementing
int	intPostIncrement() Increment the scalar value of this object then return the original value prior to incrementing
PRIMITIVE	inverse() Replace the current value its multiplicative inverse (1/x)
boolean	isEmpty() Answer true if this structure contains no elements.
boolean	isModulo() Answer true if this value represents the magnitude of a vector into a modulo set, or finite ring.
boolean	isOrdered() Answer true if the elements of this structure necessarily share a partial or total order between each other within the context of this structure.
PRIMITIVE	mod(int aValue) Set the value of this scalar to its current value modulo of the specified value
protected int	modulo(int aValue)
PRIMITIVE	not() Replace the current integral binary vector with its one's complement.
PRIMITIVE	or(int 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(int aValue) Set the value of this scalar to the mathematical product of its current value and the specified value
PRIMITIVE	quotient(int aValue) Set the value of this scalar to the mathematical quotient of its current value and the specified value
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	setReal(BigDecimal aValue) Set this property to the specified unlimited decimal value and answer this object (facilitates chaining)
PRIMITIVE	setReal(BigInteger aValue) Set this property to the specified unlimited integer value and answer this object (facilitates chaining)
PRIMITIVE	setScalar(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	shiftLeft(int count) Attempt to shift the elements of this tuple to the "left" the specified number of ordinal positions.
PRIMITIVE	shiftRight(int count) Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions.
PRIMITIVE	shiftRightExtendZero(int count) Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions without sign extension.
PRIMITIVE	sum(int aValue) Set the value of this scalar to the mathematical sum of its current value and the specified value
PRIMITIVE	xor(int 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.integers.AbstractIntegerPrimitive

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, induceScalarValue, isFinite, isInfinity, isInvalid, isMaximum, isMinimum, isNegative, isNegativeFinite, isNegativeInfinity, isPositive, isPositiveFinite, isPositiveInfinity, isReal, isUnity, isZero, longPostDecrement, longPostIncrement, longValue, negate, or, or, or, or, product, product, product, product, quotient, quotient, quotient, quotient, round, setNumber, setPrimitive, setReal, setScalar, setScalar, setScalar, setScalar, setScalar, setUnity, setZero, shortPostDecrement, shortPostIncrement, shortValue, square, sum, sum, sum, sum, swapPrimitives, toNumber, toString, toUnlimitedDecimal, toUnlimitedInteger, unlimitedDecimalPostDecrement, unlimitedDecimalPostIncrement, unlimitedIntegerPostDecrement, unlimitedIntegerPostIncrement, xor, xor, xor, xor

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, indexOfText, indexOfText, inducePostDecrement, inducePostDecrement, inducePostIncrement, inducePostIncrement, inducePrimitiveValue, induceTextValue, insert, insert, insert, insert, insert, insert, insert, insert, insert, insert, insert, insert, 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, 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, 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, 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, modOfScalar, nanoseconds, naturalLog, naturalLogPlusOne, or, orOfScalar, power, power, powerOfNumber, powerOfScalar, product, product, product, productOfScalar, promoteTo, quotient, quotient, quotient, quotientOfScalar, radians, random, setByteBitAt, setCharBitAt, setDoubleBitAt, setE, setEnumeration, setFalse, setFloatBitAt, setIntBitAt, setLongBitAt, setNegativeInfinity, setPi, setPositiveInfinity, setShortBitAt, setTrue, setUnlimitedDecimalBitAt, setUnlimitedIntegerBitAt, shortMaskAt, shortNotMaskAt, shortValue, signum, sine, size, squareRoot, 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, 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, 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, andOfNumber, andOfScalar, angleWith, angleWithNumber, angleWithScalar, arcCosine, arcSine, arcTangent, base10Log, ceiling, cosine, cubeRoot, degrees, difference, difference, difference, differenceOfNumber, differenceOfScalar, down, exponential, exponentialLessOne, floor, gcd, gcd, gcd, gcd, gcd, gcdOfNumber, gcdOfScalar, halfDown, halfEven, halfUp, hyperbolicCosine, hyperbolicSine, hyperbolicTangent, hypotenuseWith, hypotenuseWithNumber, hypotenuseWithScalar, invalidate, milliseconds, mod, mod, mod, mod, mod, mod, mod, modOfNumber, modOfScalar, nanoseconds, naturalLog, naturalLogPlusOne, or, orOfNumber, orOfScalar, power, power, powerOfNumber, powerOfScalar, product, product, product, productOfNumber, productOfScalar, quotient, quotient, quotient, quotientOfNumber, quotientOfScalar, radians, random, setE, setEnumeration, setNegativeInfinity, setPi, setPositiveInfinity, sine, squareRoot, sum, sum, sum, sumOfNumber, sumOfScalar, tangent, up, xor, xorOfNumber, xorOfScalar

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

setFalse, setTrue

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

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

AbstractModuloIntegerPrimitive

public AbstractModuloIntegerPrimitive()

AbstractModuloIntegerPrimitive

public AbstractModuloIntegerPrimitive(Class<E> anEnumerationClass)

AbstractModuloIntegerPrimitive

public AbstractModuloIntegerPrimitive(Enum<?> anEnumeration)

AbstractModuloIntegerPrimitive

public AbstractModuloIntegerPrimitive(Enum<?>[] values)

AbstractModuloIntegerPrimitive

public AbstractModuloIntegerPrimitive(int aLimit)

Method Detail

modulo

protected final int modulo(int aValue)

absoluteValue

public final PRIMITIVE absoluteValue()
                                                           throws UnsupportedOperationException,
                                                                  ArithmeticException,
                                                                  IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value with the absolute value of itself

Specified by:

absoluteValue in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>

Overrides:

absoluteValue in class AbstractIntegerPrimitive<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(int 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

decrement

public final PRIMITIVE decrement()
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException

Description copied from interface: MutableScalar

Replace the current value with the current value minus unity (one)

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the new value was incommensurate with this object's specification

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

difference

public final PRIMITIVE difference(int 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

getMaximumValue

public final int getMaximumValue()

getModularLimit

public final int getModularLimit()

getStructureStrategy

public StructureStrategy getStructureStrategy()

Specified by:

getStructureStrategy in interface SealedAlgebraicStructure

Overrides:

getStructureStrategy in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

Returns:

a lemma defining the general implementation approach for this structure

increment

public final PRIMITIVE increment()
                                                       throws UnsupportedOperationException,
                                                              ArithmeticException,
                                                              IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value with the current value plus unity (one)

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

IllegalArgumentException - if the new value was incommensurate with this object's specification

induceScalarMaximum

public final <S extends Scalar<?>> S induceScalarMaximum(S aTarget)

Description copied from interface: SealedScalarDomain

Induce the maximum domain value into the target

Specified by:

induceScalarMaximum in interface SealedScalarDomain

Overrides:

induceScalarMaximum in class AbstractIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

Type Parameters:

S - the target type

Parameters:

aTarget - a target into which this domain's maximum value will be induced

Returns:

the target

induceScalarMinimum

public final <S extends Scalar<?>> S induceScalarMinimum(S aTarget)

Description copied from interface: SealedScalarDomain

Induce the minimum domain value into the target

Specified by:

induceScalarMinimum in interface SealedScalarDomain

Overrides:

induceScalarMinimum in class AbstractIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

Type Parameters:

S - the target type

Parameters:

aTarget - a target into which this domain's minimum value will be induced

Returns:

the target

intPostDecrement

public final int intPostDecrement()
                           throws UnsupportedOperationException,
                                  ArithmeticException,
                                  IllegalArgumentException

Description copied from interface: MutableIntegerValue

Decrement the scalar value of this object then return the original value prior to decrementing

Returns:

the original value of this scalar

Throws:

UnsupportedOperationException - if this object's value cannot be changed

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

IllegalArgumentException - if the new value was incommensurate with this object's specification

intPostIncrement

public final int intPostIncrement()
                           throws UnsupportedOperationException,
                                  ArithmeticException,
                                  IllegalArgumentException

Description copied from interface: MutableIntegerValue

Increment the scalar value of this object then return the original value prior to incrementing

Returns:

the original value of this scalar

Throws:

UnsupportedOperationException - if this object's value cannot be changed

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

IllegalArgumentException - if the new value was incommensurate with this object's specification

inverse

public final PRIMITIVE inverse()
                                                     throws UnsupportedOperationException,
                                                            ArithmeticException,
                                                            IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value its multiplicative inverse (1/x)

Specified by:

inverse in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>

Overrides:

inverse in class AbstractIntegerPrimitive<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

isEmpty

public final boolean isEmpty()

Description copied from interface: StructureProperties

Answer true if this structure contains no elements. For strings this would indicate an empty string (no characters in an empty array). For scalars this would indicate an empty set, or a zero bit count, which would be the case of null values. Note that, although the null constant technically contains zero elements, its string value evaluates to "null", which from a String perspective is not empty.

Specified by:

isEmpty in interface StructureProperties

Specified by:

isEmpty in interface TextProperties

Overrides:

isEmpty in class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

Returns:

true if this structure contains no elements

isModulo

public final boolean isModulo()

Description copied from interface: NumericProperties

Answer true if this value represents the magnitude of a vector into a modulo set, or finite ring. This is not the same as testing whether this object's implementation resembles the specification for the MODULO domain, since that is too specific to implementation machinery. Modulo values, for instance can either be real or imaginary.

Specified by:

isModulo in interface NumericProperties

Overrides:

isModulo in class AbstractIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

Returns:

true if this value represents the magnitude of a vector into a modulo set, or finite ring

isOrdered

public final boolean isOrdered()

Description copied from interface: StructureProperties

Answer true if the elements of this structure necessarily share a partial or total order between each other within the context of this structure. Ordering does not necessarily imply a simple sequencing between randomly selected elements, but rather a necessary sorting order between elements independent of the sets they are related by. A SortedSet is ordered, not merely because its elements are de facto sorted, but because the SortedSet defines a universe in which only sortable elements can exist and it defines a sorting function which places those elements in their sorted order at the time of iteration. An ordered set has elements with values that are reflexive, antisymmetric, and transitive relative to each other. Necessarily empty sets are not considered ordered.

Specified by:

isOrdered in interface StructureProperties

Overrides:

isOrdered in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>

Returns:

true if the structure has either a partial or total order over its elements

See Also:

order theory (Wikipedia)

mod

public final PRIMITIVE mod(int aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException

Description copied from interface: MutableScalar

Set the value of this scalar to its current value modulo of the specified value

Specified by:

mod in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>

Overrides:

mod in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>

Parameters:

aValue - a modulus

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the new value was incommensurate with this object's specification

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

not

public final PRIMITIVE not()
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException

Description copied from interface: MutableScalar

Replace the current integral binary vector with its one's complement. Decimal values, such as double, will be first converted to unlimited integers before their bits are reversed.

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the new value was incommensurate with this object's specification

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

or

public final PRIMITIVE or(int 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(int 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(int 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

setMaximum

public final PRIMITIVE setMaximum()
                                                        throws UnsupportedOperationException,
                                                               ArithmeticException,
                                                               IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value with maximum value available for the implementation's numeric precision. Unlimited values will be replaced with the maximum value available for the most precise system scalar appropriate for the implementation, that is unlimited integer primitives will set themselves to the maximum long value and unlimited decimal primitives will set themselves to the maximum double value.

Specified by:

setMaximum in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>

Overrides:

setMaximum in class AbstractIntegerPrimitive<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

setMinimum

public final PRIMITIVE setMinimum()
                                                        throws UnsupportedOperationException,
                                                               ArithmeticException,
                                                               IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value with minimum value available for the implementation's numeric precision. Unlimited values will be replaced with the minimum value available for the most precise system scalar appropriate for the implementation, that is unlimited integer primitives will set themselves to the minimum long value and unlimited decimal primitives will set themselves to the minimum double value.

Specified by:

setMinimum in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>

Overrides:

setMinimum in class AbstractIntegerPrimitive<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

setReal

public final PRIMITIVE setReal(BigDecimal aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException,
                                                            NullPointerException

Description copied from interface: MutableUnlimitedDecimalValue

Set this property to the specified unlimited decimal value and answer this object (facilitates chaining)

Specified by:

setReal in interface MutableUnlimitedDecimalValue<PRIMITIVE extends Primitive<PRIMITIVE>>

Overrides:

setReal in class AbstractIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

Parameters:

aValue - an unlimited decimal value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the specified value was incommensurate with this object's specification

ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object

NullPointerException - a null value was provided though this object does not accept null values

setReal

public final PRIMITIVE setReal(BigInteger aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException,
                                                            NullPointerException

Description copied from interface: MutableUnlimitedIntegerValue

Set this property to the specified unlimited integer value and answer this object (facilitates chaining)

Specified by:

setReal in interface MutableUnlimitedIntegerValue<PRIMITIVE extends Primitive<PRIMITIVE>>

Overrides:

setReal in class AbstractIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

Parameters:

aValue - an unlimited integer value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the specified value was incommensurate with this object's specification

ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object

NullPointerException - a null value was provided though this object does not accept null values

setScalar

public final PRIMITIVE setScalar(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)

Specified by:

setScalar in interface MutableDoubleValue<PRIMITIVE extends Primitive<PRIMITIVE>>

Overrides:

setScalar in class AbstractIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

Parameters:

aValue - a double value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the specified value was incommensurate with this object's specification

ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object

setScalar

public final PRIMITIVE setScalar(float aValue)
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException

Description copied from interface: MutableFloatValue

Set this property to the specified float value and answer this object (facilitates chaining)

Specified by:

setScalar in interface MutableFloatValue<PRIMITIVE extends Primitive<PRIMITIVE>>

Overrides:

setScalar in class AbstractIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

Parameters:

aValue - a float value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the specified value was incommensurate with this object's specification

ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object

setScalar

public final PRIMITIVE setScalar(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)

Specified by:

setScalar in interface MutableLongValue<PRIMITIVE extends Primitive<PRIMITIVE>>

Overrides:

setScalar in class AbstractIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>

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

shiftLeft

public PRIMITIVE shiftLeft(int count)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException

Description copied from interface: MutableScalar

Attempt to shift the elements of this tuple to the "left" the specified number of ordinal positions. In a bit sequence this functions resorts to the familiar "left shift" process (e.g., Java <<). In other sequences, the specified number of default values will be prepended to the beginning of the sequence, increasing the ordinal position of all existing elements by the specified count.

Parameters:

count - the number of default values to be prepended to this sequence

Returns:

this structure (facilitates chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed or if this structure is not an algebraic tuple

IllegalArgumentException - if the specified value was incommensurate with this structure's specification

ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this structure

shiftRight

public PRIMITIVE shiftRight(int count)
                                                  throws UnsupportedOperationException,
                                                         IllegalArgumentException,
                                                         ArithmeticException

Description copied from interface: MutableScalar

Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions. In a bit sequence this functions resorts to the familiar "right shift" process, with sign extension (e.g., the Java >> operator). In other sequences, the specified number of values will be removed from the beginning of the sequence, decreasing the ordinal position of all remaining elements by the specified count.

Parameters:

count - the number of values to be removed from the beginning of this sequence

Returns:

this structure (facilitates chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed or if this structure is not an algebraic tuple

IllegalArgumentException - if the specified value was incommensurate with this structure's specification

ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this structure

shiftRightExtendZero

public PRIMITIVE shiftRightExtendZero(int count)
                                                            throws UnsupportedOperationException,
                                                                   IllegalArgumentException,
                                                                   ArithmeticException

Description copied from interface: MutableScalar

Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions without sign extension. In a bit sequence this functions resorts to the familiar "right shift" process, with zero extension (e.g., the Java >>> operator). In other sequences, the specified number of values will be removed from the beginning of the sequence, decreasing the ordinal position of all remaining elements by the specified count.

Specified by:

shiftRightExtendZero in interface MutableScalar<PRIMITIVE extends Primitive<PRIMITIVE>>

Overrides:

shiftRightExtendZero in class AbstractScalar<PRIMITIVE extends Primitive<PRIMITIVE>>

Parameters:

count - the number of values to be removed from the beginning of this sequence

Returns:

this structure (facilitates chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed or if this structure is not an algebraic tuple

IllegalArgumentException - if the specified value was incommensurate with this structure's specification

ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this structure

sum

public final PRIMITIVE sum(int 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

xor

public final PRIMITIVE xor(int 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