net.sf.jaccumulator.primitives

Class Variant

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.AbstractPrimitiveWrapper<Variant>

net.sf.jaccumulator.primitives.Variant

All Implemented Interfaces:

Serializable, Appendable, CharSequence, Comparable<SealedPrimitive<?>>, AlgebraicStructure<Variant>, BooleanValue<Variant>, MutableBooleanValue<Variant>, SealedBooleanValue, ByteValue<Variant>, MutableByteValue<Variant>, SealedByteValue, CharacterValue<Variant>, MutableCharacterValue<Variant>, SealedCharacterValue, DoubleValue<Variant>, MutableDoubleValue<Variant>, SealedDoubleValue, FloatValue<Variant>, MutableFloatValue<Variant>, SealedFloatValue, IntegerValue<Variant>, MutableIntegerValue<Variant>, SealedIntegerValue, LongValue<Variant>, MutableLongValue<Variant>, SealedLongValue, Mutable, MutableAlgebraicStructure<Variant>, MutableKernel<Variant>, MutablePrimitive<Variant>, Primitive<Variant>, PrimitiveInductor<Variant>, PrimitiveReplicator<Variant>, SealedPrimitive<Variant>, MutableReal<Variant>, MutableRealDomain<Variant>, Real<Variant>, RealDomain<Variant>, RealInductor<Variant>, RealReplicator<Variant>, SealedReal<Variant>, SealedRealBag, SealedRealDomain, Replicator<Variant>, CharacterProperties, MutableScalar<Variant>, MutableScalarDomain<Variant>, NumericProperties, Scalar<Variant>, ScalarDomain<Variant>, ScalarInductor<Variant>, ScalarReplicator<Variant>, SealedScalar<Variant>, SealedScalarBag, SealedScalarDomain, SealedAlgebraicStructure, SealedKernel, MutableShortValue<Variant>, SealedShortValue, ShortValue<Variant>, StructureProperties, MutableText<Variant>, MutableTextValue<Variant>, SealedText<Variant>, SealedTextValue, Text<Variant>, TextInductor, TextProperties, TextReplicator<Variant>, TextValue<Variant>, MutableUnlimitedDecimalValue<Variant>, MutableUnlimitedIntegerValue<Variant>, SealedUnlimitedDecimalValue, SealedUnlimitedIntegerValue, UnlimitedDecimalValue<Variant>, UnlimitedIntegerValue<Variant>

public final class Variant
extends AbstractPrimitiveWrapper<Variant>

An primitive that adjusts its numeric precision, and hence its implementation, based on the precision of function arguments

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
Variant(BigDecimal aValue)
Variant(BigInteger aValue)
Variant(boolean aValue)
Variant(byte aValue)
Variant(char aValue)
Variant(double aValue)
Variant(E aValue)
Variant(float aValue)
Variant(int aValue)
Variant(long aValue)
Variant(Primitive<?>... targets)
Variant(PrimitiveAction<Primitive<?>> aRealTranslator, Primitive<?>... targets)
Variant(short aValue)
Variant(String aValue)

Method Summary

Methods

Modifier and Type	Method and Description
Variant	absoluteValue() Replace the current value with the absolute value of itself
Variant	and(BigInteger aValue) Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
Variant	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
Variant	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
Variant	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
Variant	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
Variant	and(long aValue) Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
Variant	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
Variant	angleWith(double aValue) Set this value to the angle formed by the rectangular coordinates given by the current value, x, and the specified value, y.
Variant	append(boolean aValue)
Variant	append(char c)
Variant	append(char[] content)
Variant	append(char[] content, int contentIndex)
Variant	append(char[] content, int contentIndex, int contentLength)
Variant	append(CharSequence s)
Variant	append(CharSequence content, int contentStartIndex)
Variant	append(CharSequence s, int start, int end)
Variant	append(double aValue)
Variant	append(float aValue)
Variant	append(int aValue)
Variant	append(long aValue)
Variant	append(Object aValue)
Variant	append(StringBuffer sb)
Variant	appendCodePoint(int codePoint)
Variant	arcCosine() Replace the current value with its arc cosine
Variant	arcSine() Replace the current value with its arc sine
Variant	arcTangent() Replace the current value with its arc tangent
Variant	assertDomain(Domain aDomain) Attempt to convert the implementation domain of this structure to the closest available match for the proposed domain.
Variant	assertPrecision(NumericPrecision prec) Convert the numeric precision of this implementation to the closest available match for the proposed precision.
Variant	base10Log() Replace the current value with its base 10 logarithm
Variant	copy() Produce a replica of this object
Variant	copyUsing(BigDecimal aValue) Using this real as a factory, produce a new real of the same type but initialized with the value specified
Variant	copyUsing(BigInteger aValue) Using this real as a factory, produce a new real of the same type but initialized with the value specified
Variant	copyUsing(boolean aValue) Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
Variant	copyUsing(byte aValue) Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
Variant	copyUsing(char aValue) Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
Variant	copyUsing(double aValue) Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
Variant	copyUsing(float aValue) Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
Variant	copyUsing(int aValue) Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
Variant	copyUsing(long aValue) Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
Variant	copyUsing(short aValue) Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified
Variant	copyUsingPrimitive(SealedPrimitive<?> aValue) Using this primitive as a factory, produce a new primitive of the same type but initialized with the value specified
Variant	copyUsingReal(SealedReal<?> aValue) Using this real as a factory, produce a new real of the same type but initialized with the value specified
Variant	copyUsingScalar(SealedScalar<?> aValue) Using this scalar as a factory, produce a new scalar of the same type but initialized with the value specified
Variant	copyUsingText(CharSequence aValue) Using this primitive as a factory, produce a new primitive of the same type but initialized with the value specified
Variant	cosine() Replace the current value, assumed to be an angle in radians, to its cosine
Variant	cube() Replace the current value with the cube of itself
Variant	cubeRoot() Replace the current value with the cube root of itself
Variant	decrement() Replace the current value with the current value minus unity (one)
Variant	degrees() Replace the current value, assumed to be an angle in radians, to its equivalent angle in degrees
Variant	delete(int start, int end)
Variant	deleteCharAt(int anIndex)
Variant	difference(BigDecimal aValue) Set the value of this scalar to the mathematical difference between its current value and the specified value
Variant	difference(BigInteger aValue) Set the value of this scalar to the mathematical difference between its current value and the specified value
Variant	difference(boolean aValue) Set the value of this scalar to the mathematical difference between its current value and the specified value
Variant	difference(byte aValue) Set the value of this scalar to the mathematical difference between its current value and the specified value
Variant	difference(char aValue) Set the value of this scalar to the mathematical difference between its current value and the specified value
Variant	difference(double aValue) Set the value of this scalar to the mathematical difference between its current value and the specified value
Variant	difference(float aValue) Set the value of this scalar to the mathematical difference between its current value and the specified value
Variant	difference(int aValue) Set the value of this scalar to the mathematical difference between its current value and the specified value
Variant	difference(long aValue) Set the value of this scalar to the mathematical difference between its current value and the specified value
Variant	difference(short aValue) Set the value of this scalar to the mathematical difference between its current value and the specified value
Variant	exponential() Replace the current value with e (Napier's constant) raised to the current value (en)
Variant	exponentialLessOne() Replace the current value with e (Napier's constant) raised to the current value, less 1 (en-1)
Variant	gcd(BigInteger aValue) Replace the current value with the greatest common denonimator between this value and the specific one
Variant	gcd(byte aValue) Replace the current value with the greatest common factor between this value and the specific one
Variant	gcd(char aValue) Replace the current value with the greatest common factor between this value and the specific one
Variant	gcd(int aValue) Replace the current value with the greatest common factor between this value and the specific one
Variant	gcd(long aValue) Replace the current value with the greatest common factor between this value and the specific one
Variant	gcd(short aValue) Replace the current value with the greatest common factor between this value and the specific one
PrimitiveAction<Primitive<?>>	getRealTranslator()
Primitive<?>	getTarget()
Variant	hyperbolicCosine() Replace the current value, assumed to be an angle in radians, to its hyperbolic cosine
Variant	hyperbolicSine() Replace the current value, assumed to be an angle in radians, to its hyperbolic sine
Variant	hyperbolicTangent() Replace the current value, assumed to be an angle in radians, to its hyperbolic tangent
Variant	increment() Replace the current value with the current value plus unity (one)
Variant	insert(int anIndex, boolean aValue)
Variant	insert(int anIndex, char aValue)
Variant	insert(int anIndex, char[] content)
Variant	insert(int targetIndex, char[] content, int contentIndex, int contentLength)
Variant	insert(int anIndex, CharSequence content)
Variant	insert(int targetIndex, CharSequence content, int contentIndex)
Variant	insert(int targetIndex, CharSequence content, int contentStartIndex, int contentEndIndexPlusOne)
Variant	insert(int anIndex, double aValue)
Variant	insert(int anIndex, float aValue)
Variant	insert(int anIndex, int aValue)
Variant	insert(int anIndex, long aValue)
Variant	insert(int anIndex, Object aValue)
Variant	invalidate() Replace the current value an invalid value such INVALID if possible, otherwise replace it with zero
Variant	inverse() Replace the current value its multiplicative inverse (1/x)
boolean	isConfigurable() Answer true if the implementation of this object can be changed. A configurable object has a structure that can be expanded, or reduced, or has replaceable components.
Variant	lowerCase() For text-based objects, convert all characters in the text to lower case.
Variant	mod(BigDecimal aValue) Set the value of this scalar to its current value modulo of the specified value
Variant	mod(BigInteger aValue) Set the value of this scalar to its current value modulo of the specified value
Variant	mod(boolean aValue) Set the value of this scalar to its current value modulo of the specified value
Variant	mod(byte aValue) Set the value of this scalar to its current value modulo of the specified value
Variant	mod(char aValue) Set the value of this scalar to its current value modulo of the specified value
Variant	mod(double aValue) Set the value of this scalar to its current value modulo of the specified value
Variant	mod(float aValue) Set the value of this scalar to its current value modulo of the specified value
Variant	mod(int aValue) Set the value of this scalar to its current value modulo of the specified value
Variant	mod(long aValue) Set the value of this scalar to its current value modulo of the specified value
Variant	mod(short aValue) Set the value of this scalar to its current value modulo of the specified value
Variant	naturalLog() Replace the current value with its base e (Napier's constant) logarithm (loge(n))
Variant	naturalLogPlusOne() Replace the current value, plus 1, with its base e (Napier's constant) logarithm (loge(n+1))
Variant	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.
Variant	not() Replace the current integral binary vector with its one's complement.
Variant	or(BigInteger aValue) Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
Variant	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
Variant	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
Variant	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
Variant	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
Variant	or(long aValue) Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
Variant	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
Variant	power(double n) Set this value to the current value, x, raised to the specified exponent, n, or xn
Variant	power(int n) Set this value to the current value, x, raised to the specified exponent, n, or xn
Variant	prepend(boolean aValue)
Variant	prepend(char aValue)
Variant	prepend(char[] content)
Variant	prepend(char[] content, int contentIndex)
Variant	prepend(char[] content, int contentIndex, int contentLength)
Variant	prepend(CharSequence content)
Variant	prepend(CharSequence content, int contentIndex)
Variant	prepend(CharSequence content, int contentStartIndex, int contentEndIndexPlusOne)
Variant	prepend(double aValue)
Variant	prepend(float aValue)
Variant	prepend(int aValue)
Variant	prepend(long aValue)
Variant	prepend(Object aValue)
Variant	product(BigDecimal aValue) Set the value of this scalar to the mathematical product of its current value and the specified value
Variant	product(BigInteger aValue) Set the value of this scalar to the mathematical product of its current value and the specified value
Variant	product(boolean aValue) Set the value of this scalar to the mathematical product of its current value and the specified value
Variant	product(byte aValue) Set the value of this scalar to the mathematical product of its current value and the specified value
Variant	product(char aValue) Set the value of this scalar to the mathematical product of its current value and the specified value
Variant	product(double aValue) Set the value of this scalar to the mathematical product of its current value and the specified value
Variant	product(float aValue) Set the value of this scalar to the mathematical product of its current value and the specified value
Variant	product(int aValue) Set the value of this scalar to the mathematical product of its current value and the specified value
Variant	product(long aValue) Set the value of this scalar to the mathematical product of its current value and the specified value
Variant	product(short aValue) Set the value of this scalar to the mathematical product of its current value and the specified value
Variant	promoteTo(NumericPrecision prec) If this object's implementation is less precise than the specified numeric precision, then convert this implementation to the closest available match for the proposed precision.
Variant	quotient(BigDecimal aValue) Set the value of this scalar to the mathematical quotient between its current value and the specified value
Variant	quotient(BigInteger aValue) Set the value of this scalar to the mathematical quotient between its current value and the specified value
Variant	quotient(boolean aValue) Set the value of this scalar to the mathematical quotient between its current value and the specified value
Variant	quotient(byte aValue) Set the value of this scalar to the mathematical quotient of its current value and the specified value
Variant	quotient(char aValue) Set the value of this scalar to the mathematical quotient between its current value and the specified value
Variant	quotient(double aValue) Set the value of this scalar to the mathematical quotient of its current value and the specified value
Variant	quotient(float aValue) Set the value of this scalar to the mathematical quotient of its current value and the specified value
Variant	quotient(int aValue) Set the value of this scalar to the mathematical quotient of its current value and the specified value
Variant	quotient(long aValue) Set the value of this scalar to the mathematical quotient of its current value and the specified value
Variant	quotient(short aValue) Set the value of this scalar to the mathematical quotient of its current value and the specified value
Variant	radians() Replace the current value, assumed to be an angle in degrees, to its equivalent angle in radians
Variant	replace(CharSequence target, CharSequence replacement)
Variant	replace(int start, int end, String str)
Variant	replaceAll(String regex, String replacement)
Variant	replaceCharacter(char oldChar, char newChar)
Variant	replaceFirst(String regex, String replacement)
Variant	reverse()
Variant	round(RoundingStrategy aRoundingStrategy) Round the current value using the specified rounding strategy
Variant	setBoolean(Boolean aValue) Set this property to the specified system-supported Boolean and answer this object (facilitates chaining)
Variant	setCharacter(Character aValue) Set this property to the specified system-supported Character and answer this object (facilitates chaining)
Variant	setCharAt(int index, char ch)
Variant	setE() Replace the current value with e, or Napier's constant
<E extends Enum<E>> Variant	setEnumeration(E aValue) Match the value of this object with the identity of the specified enumeration instance, then answer this object (facilitates chaining)
Variant	setFalse() Set this property to its equivalent of true and answer this object (facilitates chaining)
Variant	setLength(int newLength)
Variant	setMaximum() Replace the current value with maximum value available for the implementation's numeric precision.
Variant	setMinimum() Replace the current value with minimum value available for the implementation's numeric precision.
Variant	setNegativeInfinity() Replace the current value with a representation of negative infinity, if available, otherwise replace with the implementation's minimum value
Variant	setPi() Replace the current value with Pi
Variant	setPositiveInfinity() Replace the current value with a representation of positive infinity, if available, otherwise replace with the implementation's maximum value
Variant	setReal(BigDecimal aValue) Set this property to the specified unlimited decimal value and answer this object (facilitates chaining)
Variant	setReal(BigInteger aValue) Set this property to the specified unlimited integer value and answer this object (facilitates chaining)
Variant	setReal(SealedReal<?> aValue) Set this property to the specified numeric primitive and answer this object (facilitates chaining)
Variant	setScalar(boolean aValue) Set this property to the specified boolean value and answer this object (facilitates chaining)
Variant	setScalar(byte aValue) Set this property to the specified byte value and answer this object (facilitates chaining)
Variant	setScalar(char aValue) Set this property to the specified char value and answer this object (facilitates chaining)
Variant	setScalar(double aValue) Set this property to the specified double value and answer this object (facilitates chaining)
Variant	setScalar(float aValue) Set this property to the specified float value and answer this object (facilitates chaining)
Variant	setScalar(int aValue) Set this property to the specified int value and answer this object (facilitates chaining)
Variant	setScalar(long aValue) Set this property to the specified long value and answer this object (facilitates chaining)
Variant	setScalar(SealedScalar<?> aValue) Set this object to the specified scalar
Variant	setScalar(short aValue) Set this property to the specified short value and answer this object (facilitates chaining)
Variant	setText(CharSequence content) Set this property to the specified text value and answer this object (facilitates chaining)
Variant	setTrue() Set this property to its equivalent of true and answer this object (facilitates chaining)
Variant	setUnity() Replace the current value with the multiplicative identity appropriate for the implementation (one)
Variant	setZero() Replace the current value with the additive identity appropriate for the implementation (zero)
Variant	shiftLeft(int count) Attempt to shift the elements of this tuple to the "left" the specified number of ordinal positions.
Variant	shiftRight(int count) Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions.
Variant	shiftRightExtendZero(int count) Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions without sign extension.
Variant	sine() Replace the current value, assumed to be an angle in radians, to its sine
Variant	square() Replace the current value with the square of itself
Variant	squareRoot() Replace the current value with the square root of itself
CharSequence	subSequence(int start, int end)
String	substring(int beginIndex)
String	substring(int beginIndex, int endIndex)
Variant	sum(BigDecimal aValue) Set the value of this scalar to the mathematical sum of its current value and the specified value
Variant	sum(BigInteger aValue) Set the value of this scalar to the mathematical sum of its current value and the specified value
Variant	sum(boolean aValue) Set the value of this scalar to the mathematical sum of its current value and the specified value
Variant	sum(byte aValue) Set the value of this scalar to the mathematical sum of its current value and the specified value
Variant	sum(char aValue) Set the value of this scalar to the mathematical sum of its current value and the specified value
Variant	sum(double aValue) Set the value of this scalar to the mathematical sum of its current value and the specified value
Variant	sum(float aValue) Set the value of this scalar to the mathematical sum of its current value and the specified value
Variant	sum(int aValue) Set the value of this scalar to the mathematical sum of its current value and the specified value
Variant	sum(long aValue) Set the value of this scalar to the mathematical sum of its current value and the specified value
Variant	sum(short aValue) Set the value of this scalar to the mathematical sum of its current value and the specified value
Variant	swapPrimitives(Primitive<?> aValue) Swap the value of this primitive for the specified one and set the specified primitive's value to the current value of this primitive
Variant	tangent() Replace the current value, assumed to be an angle in radians, to its tangent
static Primitive<?>	toPrimitive(Number aNumber)
static Primitive<?>	toPrimitive(NumericPrecision prec)
static Primitive<?>	toPrimitive(SealedReal<?> aReal)
static Primitive<?>	toPrimitive(SealedScalar<?> aScalar)
Variant	upperCase() For text-based objects, convert all characters in the text to upper case.
static Variant	valueOfPrimitive(SealedPrimitive<?> aValue)
static Variant	valueOfReal(SealedReal<?> aReal)
static Variant	valueOfScalar(SealedScalar<?> aScalar)
Variant	xor(BigInteger aValue) Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
Variant	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
Variant	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
Variant	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
Variant	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
Variant	xor(long aValue) Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
Variant	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.AbstractPrimitiveWrapper

booleanPostDecrement, booleanPostIncrement, booleanValue, bytePostDecrement, bytePostIncrement, byteValue, charAt, charPostDecrement, charPostIncrement, charValue, clear, clearContents, clearText, codePointAt, codePointBefore, codePointCount, compareTo, compareToPrimitive, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToText, compareToZero, doublePostDecrement, doublePostIncrement, doubleValue, equals, floatPostDecrement, floatPostIncrement, floatValue, getConcurrency, getDomain, getPrecision, getStructureStrategy, hashCode, indexOfText, indexOfText, inducePostDecrement, inducePostDecrement, inducePostDecrement, inducePostIncrement, inducePostIncrement, inducePostIncrement, inducePrimitiveMaximum, inducePrimitiveMinimum, inducePrimitiveValue, induceRealMaximum, induceRealMinimum, induceRealSize, induceRealValue, induceScalarMaximum, induceScalarMinimum, induceScalarSize, induceScalarValue, induceTextSize, induceTextValue, intPostDecrement, intPostIncrement, intValue, isAlphabetic, isBmpCodePoint, isCountable, isDigit, isElastic, isEmpty, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqualToPrimitive, isEqualToText, isExpandable, isFinite, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqualToPrimitive, isGreaterOrEqualToText, isGreaterThanPrimitive, isGreaterThanText, isHighSurrogate, isIdentifierIgnorable, isIdeographic, isImaginary, isInfinity, isInvalid, isISOControl, isJavaIdentifierPart, isJavaIdentifierStart, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqualToPrimitive, isLessOrEqualToText, isLessThanPrimitive, isLessThanText, isLetter, isLetterOrDigit, isLowerCase, isLowSurrogate, isMaximum, isMinimum, isMirrored, isModulo, isMutable, isNegative, isNegativeFinite, isNegativeInfinity, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqualToPrimitive, isNotEqualToText, isOrdered, isPositive, isPositiveFinite, isPositiveInfinity, isReal, isReducible, isSupplementaryCodePoint, isSurrogate, isText, isTitleCase, isUnicode, isUnicodeIdentifierPart, isUnicodeIdentifierStart, isUnique, isUnity, isUpperCase, isValidCodePoint, isWhitespace, isZero, length, longPostDecrement, longPostIncrement, longSize, longValue, milliseconds, nanoseconds, random, setPrimitive, shortPostDecrement, shortPostIncrement, shortValue, signum, size, textPostDecrement, textPostIncrement, titleCase, toBoolean, toCharacter, toCodePoint, toEnumeration, toNumber, toPrimitive, toReal, toScalar, toString, toUnlimitedDecimal, toUnlimitedInteger, trim, unlimitedDecimalPostDecrement, unlimitedDecimalPostIncrement, unlimitedIntegerPostDecrement, unlimitedIntegerPostIncrement

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

andOfPrimitive, angleWithPrimitive, differenceOfPrimitive, hypotenuseWithPrimitive, modOfPrimitive, orOfPrimitive, powerOfPrimitive, productOfPrimitive, quotientOfPrimitive, sumOfPrimitive, xorOfPrimitive

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

andOfNumber, andOfReal, angleWithReal, compareToNumber, compareToReal, compareToReal, compareToReal, differenceOfNumber, differenceOfReal, gcdOfNumber, gcdOfReal, hypotenuseWithReal, isEqualToNumber, isEqualToReal, isGreaterOrEqualToNumber, isGreaterOrEqualToReal, isGreaterThanNumber, isGreaterThanReal, isLessOrEqualToNumber, isLessOrEqualToReal, isLessThanNumber, isLessThanReal, isNotEqualToNumber, isNotEqualToReal, modOfNumber, modOfReal, orOfNumber, orOfReal, powerOfReal, productOfNumber, productOfReal, quotientOfNumber, quotientOfReal, setNumber, sumOfNumber, sumOfReal, unlimitedIntegerModularInverse, xorOfNumber, xorOfReal

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

andOfScalar, angleWithNumber, angleWithScalar, 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, differenceOfScalar, divideByZero, down, floor, gcdOfScalar, getBooleanBitAt, getByteBitAt, getCharBitAt, getDoubleBitAt, getFloatBitAt, getIntBitAt, getLongBitAt, getShortBitAt, getUnlimitedDecimalBitAt, getUnlimitedIntegerBitAt, halfDown, halfEven, halfUp, hashCode, hashCode, hashCode, hashCode, hashCode, hashCode, hashCode, hashCode, hypotenuseWith, hypotenuseWithNumber, hypotenuseWithScalar, indexOutOfBoundsAt, intGCD, intMaskAt, intModularInverse, intModularQuotient, intNotMaskAt, intValue, isEqualToScalar, isFalse, isGreaterOrEqualToScalar, isGreaterThanScalar, isLessOrEqualToScalar, isLessThanScalar, isNotEqualToScalar, isTrue, isValid, longGCD, longMaskAt, longModularInverse, longModularQuotient, longNotMaskAt, longValue, modOfScalar, orOfScalar, powerOfNumber, powerOfScalar, productOfScalar, quotientOfScalar, setByteBitAt, setCharBitAt, setDoubleBitAt, setFloatBitAt, setIntBitAt, setLongBitAt, setShortBitAt, setUnlimitedDecimalBitAt, setUnlimitedIntegerBitAt, shortMaskAt, shortNotMaskAt, shortValue, sumOfScalar, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toByteArray, toUnlimitedInteger, unlimitedIntegerMaskAt, unlimitedIntegerNotMaskAt, up, xorOfScalar

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

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

andOfPrimitive, angleWithPrimitive, differenceOfPrimitive, hypotenuseWithPrimitive, modOfPrimitive, orOfPrimitive, powerOfPrimitive, productOfPrimitive, quotientOfPrimitive, sumOfPrimitive, xorOfPrimitive

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

compareToReal, compareToReal, compareToReal, isEqualToReal, isGreaterOrEqualToReal, isGreaterThanReal, isLessOrEqualToReal, isLessThanReal, isNotEqualToReal

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

compareToNumber, compareToScalar, isEqualToNumber, isEqualToScalar, isFalse, isGreaterOrEqualToNumber, isGreaterOrEqualToScalar, isGreaterThanNumber, isGreaterThanScalar, isLessOrEqualToNumber, isLessOrEqualToScalar, isLessThanNumber, isLessThanScalar, isNotEqualToNumber, isNotEqualToScalar, isTrue

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

isValid

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

andOfReal, angleWithReal, differenceOfReal, gcdOfReal, hypotenuseWithReal, modOfReal, orOfReal, powerOfReal, productOfReal, quotientOfReal, sumOfReal, xorOfReal

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

andOfNumber, andOfScalar, angleWithNumber, angleWithScalar, ceiling, differenceOfNumber, differenceOfScalar, down, floor, gcdOfNumber, gcdOfScalar, halfDown, halfEven, halfUp, hypotenuseWith, hypotenuseWithNumber, hypotenuseWithScalar, modOfNumber, modOfScalar, orOfNumber, orOfScalar, powerOfNumber, powerOfScalar, productOfNumber, productOfScalar, quotientOfNumber, quotientOfScalar, setNumber, sumOfNumber, sumOfScalar, up, xorOfNumber, xorOfScalar

Constructor Detail

Variant

public Variant(BigDecimal aValue)

Variant

public Variant(BigInteger aValue)

Variant

public Variant(boolean aValue)

Variant

public Variant(byte aValue)

Variant

public Variant(char aValue)

Variant

public Variant(double aValue)

Variant

public Variant(E aValue)

Variant

public Variant(float aValue)

Variant

public Variant(int aValue)

Variant

public Variant(long aValue)

Variant

public Variant(Primitive<?>... targets)

Variant

public Variant(PrimitiveAction<Primitive<?>> aRealTranslator,
       Primitive<?>... targets)

Variant

public Variant(short aValue)

Variant

public Variant(String aValue)

Method Detail

absoluteValue

public final Variant absoluteValue()
                            throws UnsupportedOperationException

Description copied from interface: MutableScalar

Replace the current value with the absolute value of itself

Specified by:

absoluteValue in interface MutableScalar<Variant>

Overrides:

absoluteValue in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

and

public final Variant and(BigInteger aValue)
                  throws UnsupportedOperationException,
                         IllegalArgumentException,
                         ArithmeticException

Description copied from interface: MutableReal

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 MutableReal<Variant>

Overrides:

and in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

and in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

and in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

and in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

and in class AbstractPrimitiveWrapper<Variant>

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 Variant and(long 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<Variant>

Overrides:

and in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

and in class AbstractPrimitiveWrapper<Variant>

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

angleWith

public final Variant angleWith(double aValue)
                        throws UnsupportedOperationException,
                               IllegalArgumentException,
                               ArithmeticException

Description copied from interface: MutableScalar

Set this value to the angle formed by the rectangular coordinates given by the current value, x, and the specified value, y. In other words returns the angle theta from the conversion of rectangular coordinates (x,y) to polar coordinates (r,theta).

Specified by:

angleWith in interface MutableScalar<Variant>

Overrides:

angleWith in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a y coordinate value

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

See Also:

Math.atan2(double, double)

append

public final Variant append(boolean aValue)
                     throws UnsupportedOperationException

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

append

public final Variant append(char c)
                     throws UnsupportedOperationException

Specified by:

append in interface Appendable

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

append

public final Variant append(char[] content)
                     throws UnsupportedOperationException

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

append

public final Variant append(char[] content,
             int contentIndex)
                     throws UnsupportedOperationException

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

append

public final Variant append(char[] content,
             int contentIndex,
             int contentLength)
                     throws UnsupportedOperationException

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

append

public final Variant append(CharSequence s)
                     throws UnsupportedOperationException

Specified by:

append in interface Appendable

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

append

public final Variant append(CharSequence content,
             int contentStartIndex)
                     throws UnsupportedOperationException

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

append

public final Variant append(CharSequence s,
             int start,
             int end)
                     throws UnsupportedOperationException

Specified by:

append in interface Appendable

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

append

public final Variant append(double aValue)
                     throws UnsupportedOperationException

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

append

public final Variant append(float aValue)
                     throws UnsupportedOperationException

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

append

public final Variant append(int aValue)
                     throws UnsupportedOperationException

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

append

public final Variant append(long aValue)
                     throws UnsupportedOperationException

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

append

public final Variant append(Object aValue)
                     throws UnsupportedOperationException

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

append

public final Variant append(StringBuffer sb)
                     throws UnsupportedOperationException

Specified by:

append in interface MutableTextValue<Variant>

Overrides:

append in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

appendCodePoint

public final Variant appendCodePoint(int codePoint)
                              throws UnsupportedOperationException

Specified by:

appendCodePoint in interface MutableTextValue<Variant>

Overrides:

appendCodePoint in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

arcCosine

public final Variant arcCosine()
                        throws UnsupportedOperationException,
                               IllegalArgumentException,
                               ArithmeticException

Description copied from interface: MutableScalar

Replace the current value with its arc cosine

Specified by:

arcCosine in interface MutableScalar<Variant>

Overrides:

arcCosine in class AbstractPrimitiveWrapper<Variant>

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

arcSine

public final Variant arcSine()
                      throws UnsupportedOperationException,
                             IllegalArgumentException,
                             ArithmeticException

Description copied from interface: MutableScalar

Replace the current value with its arc sine

Specified by:

arcSine in interface MutableScalar<Variant>

Overrides:

arcSine in class AbstractPrimitiveWrapper<Variant>

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

arcTangent

public final Variant arcTangent()
                         throws UnsupportedOperationException,
                                IllegalArgumentException,
                                ArithmeticException

Description copied from interface: MutableScalar

Replace the current value with its arc tangent

Specified by:

arcTangent in interface MutableScalar<Variant>

Overrides:

arcTangent in class AbstractPrimitiveWrapper<Variant>

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

assertDomain

public final Variant assertDomain(Domain aDomain)

Description copied from interface: MutableAlgebraicStructure

Attempt to convert the implementation domain of this structure to the closest available match for the proposed domain. Note that the domain of this implementation may not change as a result of calling this function if an available internal conversion is not available.

Specified by:

assertDomain in interface MutableAlgebraicStructure<Variant>

Overrides:

assertDomain in class AbstractPrimitiveWrapper<Variant>

Parameters:

aDomain - the proposed domain

Returns:

this object (facilitates operation chaining)

See Also:

StructureProperties.isConfigurable()

assertPrecision

public final Variant assertPrecision(NumericPrecision prec)

Description copied from interface: MutableScalarDomain

Convert the numeric precision of this implementation to the closest available match for the proposed precision. Note that the precision of this implementation may not change as a result of calling this function if this structure is not configurable.

Specified by:

assertPrecision in interface MutableScalarDomain<Variant>

Overrides:

assertPrecision in class AbstractPrimitiveWrapper<Variant>

Parameters:

prec - the proposed precision

Returns:

this object (facilitates operation chaining)

base10Log

public final Variant base10Log()
                        throws UnsupportedOperationException,
                               IllegalArgumentException,
                               ArithmeticException

Description copied from interface: MutableScalar

Replace the current value with its base 10 logarithm

Specified by:

base10Log in interface MutableScalar<Variant>

Overrides:

base10Log in class AbstractPrimitiveWrapper<Variant>

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

copy

public final Variant copy()

Description copied from interface: Replicator

Produce a replica of this object

Returns:

a replica of this object

copyUsing

public final Variant 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 Variant 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 Variant 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 Variant 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 Variant 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 Variant 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 Variant 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 Variant copyUsing(int aValue)

Description copied from interface: ScalarReplicator

Using this object as a factory, produce a new scalar of an appropriately matching type but initialized with the value specified

Parameters:

aValue - a new value

Returns:

a copy (clone) of this scalar initialized using the specified value

copyUsing

public final Variant 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 Variant 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 Variant 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 Variant 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 Variant copyUsingScalar(SealedScalar<?> aValue)

Description copied from interface: ScalarReplicator

Using this scalar as a factory, produce a new scalar of the same type but initialized with the value specified

Parameters:

aValue - a new value

Returns:

a copy (clone) of this scalar initialized using the specified value

copyUsingText

public final Variant copyUsingText(CharSequence aValue)

Description copied from interface: PrimitiveReplicator

Using this primitive as a factory, produce a new primitive of the same type but initialized with the value specified

Parameters:

aValue - a new value

Returns:

a copy (clone) of this primitive initialized using the specified value

cosine

public final Variant cosine()
                     throws UnsupportedOperationException,
                            IllegalArgumentException,
                            ArithmeticException

Description copied from interface: MutableScalar

Replace the current value, assumed to be an angle in radians, to its cosine

Specified by:

cosine in interface MutableScalar<Variant>

Overrides:

cosine in class AbstractPrimitiveWrapper<Variant>

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

cube

public final Variant cube()
                   throws UnsupportedOperationException,
                          IllegalArgumentException,
                          ArithmeticException

Description copied from interface: MutableScalar

Replace the current value with the cube of itself

Specified by:

cube in interface MutableScalar<Variant>

Overrides:

cube in class AbstractPrimitiveWrapper<Variant>

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

cubeRoot

public final Variant cubeRoot()
                       throws UnsupportedOperationException,
                              IllegalArgumentException,
                              ArithmeticException

Description copied from interface: MutableScalar

Replace the current value with the cube root of itself

Specified by:

cubeRoot in interface MutableScalar<Variant>

Overrides:

cubeRoot in class AbstractPrimitiveWrapper<Variant>

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 Variant decrement()
                        throws UnsupportedOperationException,
                               IllegalArgumentException,
                               ArithmeticException

Description copied from interface: MutableScalar

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

Specified by:

decrement in interface MutableScalar<Variant>

Overrides:

decrement in class AbstractPrimitiveWrapper<Variant>

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

degrees

public final Variant degrees()
                      throws UnsupportedOperationException,
                             IllegalArgumentException,
                             ArithmeticException

Description copied from interface: MutableScalar

Replace the current value, assumed to be an angle in radians, to its equivalent angle in degrees

Specified by:

degrees in interface MutableScalar<Variant>

Overrides:

degrees in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

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

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

delete

public final Variant delete(int start,
             int end)
                     throws UnsupportedOperationException

Specified by:

delete in interface MutableTextValue<Variant>

Overrides:

delete in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

deleteCharAt

public final Variant deleteCharAt(int anIndex)
                           throws UnsupportedOperationException

Specified by:

deleteCharAt in interface MutableTextValue<Variant>

Overrides:

deleteCharAt in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

difference

public final Variant difference(BigDecimal aValue)
                         throws UnsupportedOperationException,
                                IllegalArgumentException,
                                ArithmeticException

Description copied from interface: MutableReal

Set the value of this scalar to the mathematical difference between its current value and the specified value

Specified by:

difference in interface MutableReal<Variant>

Overrides:

difference in class AbstractPrimitiveWrapper<Variant>

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 Variant difference(BigInteger aValue)
                         throws UnsupportedOperationException,
                                IllegalArgumentException,
                                ArithmeticException

Description copied from interface: MutableReal

Set the value of this scalar to the mathematical difference between its current value and the specified value

Specified by:

difference in interface MutableReal<Variant>

Overrides:

difference in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

difference in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

difference in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

difference in class AbstractPrimitiveWrapper<Variant>

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 Variant difference(double 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<Variant>

Overrides:

difference in class AbstractPrimitiveWrapper<Variant>

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 Variant difference(float 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<Variant>

Overrides:

difference in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

difference in class AbstractPrimitiveWrapper<Variant>

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 Variant difference(long 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<Variant>

Overrides:

difference in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

difference in class AbstractPrimitiveWrapper<Variant>

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

exponential

public final Variant exponential()
                          throws UnsupportedOperationException,
                                 IllegalArgumentException,
                                 ArithmeticException

Description copied from interface: MutableScalar

Replace the current value with e (Napier's constant) raised to the current value (eⁿ)

Specified by:

exponential in interface MutableScalar<Variant>

Overrides:

exponential in class AbstractPrimitiveWrapper<Variant>

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

See Also:

e (Wikipedia)

exponentialLessOne

public final Variant exponentialLessOne()
                                 throws UnsupportedOperationException,
                                        IllegalArgumentException,
                                        ArithmeticException

Description copied from interface: MutableScalar

Replace the current value with e (Napier's constant) raised to the current value, less 1 (eⁿ-1)

Specified by:

exponentialLessOne in interface MutableScalar<Variant>

Overrides:

exponentialLessOne in class AbstractPrimitiveWrapper<Variant>

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

See Also:

e (Wikipedia)

gcd

public final Variant gcd(BigInteger aValue)
                  throws UnsupportedOperationException,
                         ArithmeticException,
                         IllegalArgumentException

Description copied from interface: MutableReal

Replace the current value with the greatest common denonimator between this value and the specific one

Specified by:

gcd in interface MutableReal<Variant>

Overrides:

gcd in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a 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

gcd

public final Variant gcd(byte aValue)
                  throws UnsupportedOperationException,
                         ArithmeticException,
                         IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value with the greatest common factor between this value and the specific one

Specified by:

gcd in interface MutableScalar<Variant>

Overrides:

gcd in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a 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

gcd

public final Variant gcd(char aValue)
                  throws UnsupportedOperationException,
                         ArithmeticException,
                         IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value with the greatest common factor between this value and the specific one

Specified by:

gcd in interface MutableScalar<Variant>

Overrides:

gcd in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a 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

gcd

public final Variant gcd(int aValue)
                  throws UnsupportedOperationException,
                         ArithmeticException,
                         IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value with the greatest common factor between this value and the specific one

Specified by:

gcd in interface MutableScalar<Variant>

Overrides:

gcd in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a 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

gcd

public final Variant gcd(long aValue)
                  throws UnsupportedOperationException,
                         ArithmeticException,
                         IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value with the greatest common factor between this value and the specific one

Specified by:

gcd in interface MutableScalar<Variant>

Overrides:

gcd in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a 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

gcd

public final Variant gcd(short aValue)
                  throws UnsupportedOperationException,
                         ArithmeticException,
                         IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value with the greatest common factor between this value and the specific one

Specified by:

gcd in interface MutableScalar<Variant>

Overrides:

gcd in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a 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

getRealTranslator

public final PrimitiveAction<Primitive<?>> getRealTranslator()

getTarget

public final Primitive<?> getTarget()

Specified by:

getTarget in class AbstractPrimitiveWrapper<Variant>

hyperbolicCosine

public final Variant hyperbolicCosine()
                               throws UnsupportedOperationException,
                                      IllegalArgumentException,
                                      ArithmeticException

Description copied from interface: MutableScalar

Replace the current value, assumed to be an angle in radians, to its hyperbolic cosine

Specified by:

hyperbolicCosine in interface MutableScalar<Variant>

Overrides:

hyperbolicCosine in class AbstractPrimitiveWrapper<Variant>

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

hyperbolicSine

public final Variant hyperbolicSine()
                             throws UnsupportedOperationException,
                                    IllegalArgumentException,
                                    ArithmeticException

Description copied from interface: MutableScalar

Replace the current value, assumed to be an angle in radians, to its hyperbolic sine

Specified by:

hyperbolicSine in interface MutableScalar<Variant>

Overrides:

hyperbolicSine in class AbstractPrimitiveWrapper<Variant>

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

hyperbolicTangent

public final Variant hyperbolicTangent()
                                throws UnsupportedOperationException,
                                       IllegalArgumentException,
                                       ArithmeticException

Description copied from interface: MutableScalar

Replace the current value, assumed to be an angle in radians, to its hyperbolic tangent

Specified by:

hyperbolicTangent in interface MutableScalar<Variant>

Overrides:

hyperbolicTangent in class AbstractPrimitiveWrapper<Variant>

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

increment

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

Description copied from interface: MutableScalar

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

Specified by:

increment in interface MutableScalar<Variant>

Overrides:

increment in class AbstractPrimitiveWrapper<Variant>

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

insert

public final Variant insert(int anIndex,
             boolean aValue)
                     throws UnsupportedOperationException

Specified by:

insert in interface MutableTextValue<Variant>

Overrides:

insert in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

insert

public final Variant insert(int anIndex,
             char aValue)
                     throws UnsupportedOperationException

Specified by:

insert in interface MutableTextValue<Variant>

Overrides:

insert in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

insert

public final Variant insert(int anIndex,
             char[] content)
                     throws UnsupportedOperationException

Specified by:

insert in interface MutableTextValue<Variant>

Overrides:

insert in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

insert

public final Variant insert(int targetIndex,
             char[] content,
             int contentIndex,
             int contentLength)
                     throws UnsupportedOperationException

Specified by:

insert in interface MutableTextValue<Variant>

Overrides:

insert in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

insert

public final Variant insert(int anIndex,
             CharSequence content)
                     throws UnsupportedOperationException

Specified by:

insert in interface MutableTextValue<Variant>

Overrides:

insert in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

insert

public final Variant insert(int targetIndex,
             CharSequence content,
             int contentIndex)
                     throws UnsupportedOperationException

Specified by:

insert in interface MutableTextValue<Variant>

Overrides:

insert in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

insert

public final Variant insert(int targetIndex,
             CharSequence content,
             int contentStartIndex,
             int contentEndIndexPlusOne)
                     throws UnsupportedOperationException

Specified by:

insert in interface MutableTextValue<Variant>

Overrides:

insert in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

insert

public final Variant insert(int anIndex,
             double aValue)
                     throws UnsupportedOperationException

Specified by:

insert in interface MutableTextValue<Variant>

Overrides:

insert in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

insert

public final Variant insert(int anIndex,
             float aValue)
                     throws UnsupportedOperationException

Specified by:

insert in interface MutableTextValue<Variant>

Overrides:

insert in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

insert

public final Variant insert(int anIndex,
             int aValue)
                     throws UnsupportedOperationException

Specified by:

insert in interface MutableTextValue<Variant>

Overrides:

insert in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

insert

public final Variant insert(int anIndex,
             long aValue)
                     throws UnsupportedOperationException

Specified by:

insert in interface MutableTextValue<Variant>

Overrides:

insert in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

insert

public final Variant insert(int anIndex,
             Object aValue)
                     throws UnsupportedOperationException

Specified by:

insert in interface MutableTextValue<Variant>

Overrides:

insert in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

invalidate

public final Variant invalidate()
                         throws UnsupportedOperationException

Description copied from interface: MutableScalar

Replace the current value an invalid value such INVALID if possible, otherwise replace it with zero

Specified by:

invalidate in interface MutableScalar<Variant>

Overrides:

invalidate in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

inverse

public final Variant inverse()
                      throws UnsupportedOperationException

Description copied from interface: MutableScalar

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

Specified by:

inverse in interface MutableScalar<Variant>

Overrides:

inverse in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

isConfigurable

public boolean isConfigurable()

Description copied from interface: StructureProperties

Answer true if the implementation of this object can be changed.

A configurable object has a structure that can be expanded, or reduced, or has replaceable components. Configurable structures are necessarily mutable; in fact, "configurability" can be used as a strict definition of mutability. This predicate however overrides #isMutable in the respect that, for some types of objects such as Variants, mutability can be changed by switching from a non-mutable implementation to a mutable one (e.g., via assertPrecision).

Specified by:

isConfigurable in interface StructureProperties

Overrides:

isConfigurable in class AbstractPrimitiveWrapper<Variant>

Returns:

true if the implementation of this object can be changed

lowerCase

public final Variant lowerCase()
                        throws UnsupportedOperationException

Description copied from interface: MutableTextValue

For text-based objects, convert all characters in the text to lower case. For numeric objects, convert their character (BMP) or integer value (Unicode) to lower case, depending on the object's precision level

Specified by:

lowerCase in interface MutableTextValue<Variant>

Overrides:

lowerCase in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException

mod

public final Variant mod(BigDecimal aValue)
                  throws UnsupportedOperationException,
                         IllegalArgumentException,
                         ArithmeticException

Description copied from interface: MutableReal

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

Specified by:

mod in interface MutableReal<Variant>

Overrides:

mod in class AbstractPrimitiveWrapper<Variant>

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

mod

public final Variant mod(BigInteger aValue)
                  throws UnsupportedOperationException,
                         IllegalArgumentException,
                         ArithmeticException

Description copied from interface: MutableReal

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

Specified by:

mod in interface MutableReal<Variant>

Overrides:

mod in class AbstractPrimitiveWrapper<Variant>

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

mod

public final Variant mod(boolean 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<Variant>

Overrides:

mod in class AbstractPrimitiveWrapper<Variant>

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

mod

public final Variant mod(byte 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<Variant>

Overrides:

mod in class AbstractPrimitiveWrapper<Variant>

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

mod

public final Variant mod(char 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<Variant>

Overrides:

mod in class AbstractPrimitiveWrapper<Variant>

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

mod

public final Variant mod(double 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<Variant>

Overrides:

mod in class AbstractPrimitiveWrapper<Variant>

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

mod

public final Variant mod(float 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<Variant>

Overrides:

mod in class AbstractPrimitiveWrapper<Variant>

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

mod

public final Variant 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<Variant>

Overrides:

mod in class AbstractPrimitiveWrapper<Variant>

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

mod

public final Variant mod(long 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<Variant>

Overrides:

mod in class AbstractPrimitiveWrapper<Variant>

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

mod

public final Variant mod(short 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<Variant>

Overrides:

mod in class AbstractPrimitiveWrapper<Variant>

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

naturalLog

public final Variant naturalLog()
                         throws UnsupportedOperationException,
                                IllegalArgumentException,
                                ArithmeticException

Description copied from interface: MutableScalar

Replace the current value with its base e (Napier's constant) logarithm (log_e(n))

Specified by:

naturalLog in interface MutableScalar<Variant>

Overrides:

naturalLog in class AbstractPrimitiveWrapper<Variant>

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

See Also:

e (Wikipedia)

naturalLogPlusOne

public final Variant naturalLogPlusOne()
                                throws UnsupportedOperationException,
                                       IllegalArgumentException,
                                       ArithmeticException

Description copied from interface: MutableScalar

Replace the current value, plus 1, with its base e (Napier's constant) logarithm (log_e(n+1))

Specified by:

naturalLogPlusOne in interface MutableScalar<Variant>

Overrides:

naturalLogPlusOne in class AbstractPrimitiveWrapper<Variant>

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

See Also:

e (Wikipedia)

negate

public final Variant negate()
                     throws UnsupportedOperationException

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.)

Specified by:

negate in interface MutableScalar<Variant>

Overrides:

negate in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

not

public final Variant not()
                  throws UnsupportedOperationException

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.

Specified by:

not in interface MutableScalar<Variant>

Overrides:

not in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

or

public final Variant or(BigInteger aValue)
                 throws UnsupportedOperationException,
                        IllegalArgumentException,
                        ArithmeticException

Description copied from interface: MutableReal

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 MutableReal<Variant>

Overrides:

or in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

or in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

or in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

or in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

or in class AbstractPrimitiveWrapper<Variant>

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 Variant or(long 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<Variant>

Overrides:

or in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

or in class AbstractPrimitiveWrapper<Variant>

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

power

public final Variant power(double n)
                    throws UnsupportedOperationException,
                           IllegalArgumentException,
                           ArithmeticException

Description copied from interface: MutableScalar

Set this value to the current value, x, raised to the specified exponent, n, or xⁿ

Specified by:

power in interface MutableScalar<Variant>

Overrides:

power in class AbstractPrimitiveWrapper<Variant>

Parameters:

n - an exponent

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

power

public final Variant power(int n)
                    throws UnsupportedOperationException,
                           IllegalArgumentException,
                           ArithmeticException

Description copied from interface: MutableScalar

Set this value to the current value, x, raised to the specified exponent, n, or xⁿ

Specified by:

power in interface MutableScalar<Variant>

Overrides:

power in class AbstractPrimitiveWrapper<Variant>

Parameters:

n - an exponent

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

prepend

public final Variant prepend(boolean aValue)
                      throws UnsupportedOperationException

Specified by:

prepend in interface MutableTextValue<Variant>

Overrides:

prepend in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

prepend

public final Variant prepend(char aValue)
                      throws UnsupportedOperationException

Specified by:

prepend in interface MutableTextValue<Variant>

Overrides:

prepend in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

prepend

public final Variant prepend(char[] content)
                      throws UnsupportedOperationException

Specified by:

prepend in interface MutableTextValue<Variant>

Overrides:

prepend in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

prepend

public final Variant prepend(char[] content,
              int contentIndex)
                      throws UnsupportedOperationException

Specified by:

prepend in interface MutableTextValue<Variant>

Overrides:

prepend in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

prepend

public final Variant prepend(char[] content,
              int contentIndex,
              int contentLength)
                      throws UnsupportedOperationException

Specified by:

prepend in interface MutableTextValue<Variant>

Overrides:

prepend in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

prepend

public final Variant prepend(CharSequence content)
                      throws UnsupportedOperationException

Specified by:

prepend in interface MutableTextValue<Variant>

Overrides:

prepend in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

prepend

public final Variant prepend(CharSequence content,
              int contentIndex)
                      throws UnsupportedOperationException

Specified by:

prepend in interface MutableTextValue<Variant>

Overrides:

prepend in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

prepend

public final Variant prepend(CharSequence content,
              int contentStartIndex,
              int contentEndIndexPlusOne)
                      throws UnsupportedOperationException

Specified by:

prepend in interface MutableTextValue<Variant>

Overrides:

prepend in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

prepend

public final Variant prepend(double aValue)
                      throws UnsupportedOperationException

Specified by:

prepend in interface MutableTextValue<Variant>

Overrides:

prepend in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

prepend

public final Variant prepend(float aValue)
                      throws UnsupportedOperationException

Specified by:

prepend in interface MutableTextValue<Variant>

Overrides:

prepend in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

prepend

public final Variant prepend(int aValue)
                      throws UnsupportedOperationException

Specified by:

prepend in interface MutableTextValue<Variant>

Overrides:

prepend in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

prepend

public final Variant prepend(long aValue)
                      throws UnsupportedOperationException

Specified by:

prepend in interface MutableTextValue<Variant>

Overrides:

prepend in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

prepend

public final Variant prepend(Object aValue)
                      throws UnsupportedOperationException

Specified by:

prepend in interface MutableTextValue<Variant>

Overrides:

prepend in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

product

public final Variant product(BigDecimal aValue)
                      throws UnsupportedOperationException,
                             IllegalArgumentException,
                             ArithmeticException

Description copied from interface: MutableReal

Set the value of this scalar to the mathematical product of its current value and the specified value

Specified by:

product in interface MutableReal<Variant>

Overrides:

product in class AbstractPrimitiveWrapper<Variant>

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 Variant product(BigInteger aValue)
                      throws UnsupportedOperationException,
                             IllegalArgumentException,
                             ArithmeticException

Description copied from interface: MutableReal

Set the value of this scalar to the mathematical product of its current value and the specified value

Specified by:

product in interface MutableReal<Variant>

Overrides:

product in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

product in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

product in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

product in class AbstractPrimitiveWrapper<Variant>

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 Variant product(double 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<Variant>

Overrides:

product in class AbstractPrimitiveWrapper<Variant>

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 Variant product(float 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<Variant>

Overrides:

product in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

product in class AbstractPrimitiveWrapper<Variant>

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 Variant product(long 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<Variant>

Overrides:

product in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

product in class AbstractPrimitiveWrapper<Variant>

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

promoteTo

public final Variant promoteTo(NumericPrecision prec)

Description copied from interface: MutableScalarDomain

If this object's implementation is less precise than the specified numeric precision, then convert this implementation to the closest available match for the proposed precision. Note that the precision of this implementation may not change as a result of calling this function if the proposed precision is less precise than the this object's current precision level or if this structure is not {@link StructureProperties#isConfigurable() configurable).

Specified by:

promoteTo in interface MutableScalarDomain<Variant>

Overrides:

promoteTo in class AbstractPrimitiveWrapper<Variant>

Parameters:

prec - the proposed precision

Returns:

this object (facilitates operation chaining)

See Also:

StructureProperties.isConfigurable()

quotient

public final Variant quotient(BigDecimal aValue)
                       throws UnsupportedOperationException,
                              IllegalArgumentException,
                              ArithmeticException

Description copied from interface: MutableReal

Set the value of this scalar to the mathematical quotient between its current value and the specified value

Specified by:

quotient in interface MutableReal<Variant>

Overrides:

quotient in class AbstractPrimitiveWrapper<Variant>

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 Variant quotient(BigInteger aValue)
                       throws UnsupportedOperationException,
                              IllegalArgumentException,
                              ArithmeticException

Description copied from interface: MutableReal

Set the value of this scalar to the mathematical quotient between its current value and the specified value

Specified by:

quotient in interface MutableReal<Variant>

Overrides:

quotient in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

quotient in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

quotient in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

quotient in class AbstractPrimitiveWrapper<Variant>

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 Variant quotient(double 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<Variant>

Overrides:

quotient in class AbstractPrimitiveWrapper<Variant>

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 Variant quotient(float 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<Variant>

Overrides:

quotient in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

quotient in class AbstractPrimitiveWrapper<Variant>

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 Variant quotient(long 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<Variant>

Overrides:

quotient in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

quotient in class AbstractPrimitiveWrapper<Variant>

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

radians

public final Variant radians()
                      throws UnsupportedOperationException,
                             IllegalArgumentException,
                             ArithmeticException

Description copied from interface: MutableScalar

Replace the current value, assumed to be an angle in degrees, to its equivalent angle in radians

Specified by:

radians in interface MutableScalar<Variant>

Overrides:

radians in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

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

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

replace

public final Variant replace(CharSequence target,
              CharSequence replacement)

Specified by:

replace in interface MutableTextValue<Variant>

Overrides:

replace in class AbstractPrimitiveWrapper<Variant>

replace

public final Variant replace(int start,
              int end,
              String str)
                      throws UnsupportedOperationException

Specified by:

replace in interface MutableTextValue<Variant>

Overrides:

replace in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

replaceAll

public final Variant replaceAll(String regex,
                 String replacement)

Specified by:

replaceAll in interface MutableTextValue<Variant>

Overrides:

replaceAll in class AbstractPrimitiveWrapper<Variant>

replaceCharacter

public final Variant replaceCharacter(char oldChar,
                       char newChar)

Specified by:

replaceCharacter in interface MutableTextValue<Variant>

Overrides:

replaceCharacter in class AbstractPrimitiveWrapper<Variant>

replaceFirst

public final Variant replaceFirst(String regex,
                   String replacement)

Specified by:

replaceFirst in interface MutableTextValue<Variant>

Overrides:

replaceFirst in class AbstractPrimitiveWrapper<Variant>

reverse

public final Variant reverse()
                      throws UnsupportedOperationException

Specified by:

reverse in interface MutableTextValue<Variant>

Overrides:

reverse in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

round

public final Variant round(RoundingStrategy aRoundingStrategy)
                    throws UnsupportedOperationException,
                           IllegalArgumentException,
                           ArithmeticException,
                           NullPointerException

Description copied from interface: MutableScalar

Round the current value using the specified rounding strategy

Specified by:

round in interface MutableScalar<Variant>

Overrides:

round in class AbstractPrimitiveWrapper<Variant>

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

setBoolean

public final Variant setBoolean(Boolean aValue)
                         throws UnsupportedOperationException,
                                IllegalArgumentException,
                                ArithmeticException,
                                NullPointerException

Description copied from interface: MutablePrimitive

Set this property to the specified system-supported Boolean and answer this object (facilitates chaining)

Specified by:

setBoolean in interface MutablePrimitive<Variant>

Overrides:

setBoolean in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a system-supported Boolean

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

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

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

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

setCharacter

public final Variant setCharacter(Character aValue)
                           throws UnsupportedOperationException,
                                  IllegalArgumentException,
                                  ArithmeticException,
                                  NullPointerException

Description copied from interface: MutablePrimitive

Set this property to the specified system-supported Character and answer this object (facilitates chaining)

Specified by:

setCharacter in interface MutablePrimitive<Variant>

Overrides:

setCharacter in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a system-supported Character

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

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

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

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

setCharAt

public final Variant setCharAt(int index,
                char ch)
                        throws UnsupportedOperationException

Specified by:

setCharAt in interface MutableTextValue<Variant>

Overrides:

setCharAt in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

setE

public final Variant setE()
                   throws UnsupportedOperationException,
                          IllegalArgumentException,
                          ArithmeticException

Description copied from interface: MutableScalar

Replace the current value with e, or Napier's constant

Specified by:

setE in interface MutableScalar<Variant>

Overrides:

setE in class AbstractPrimitiveWrapper<Variant>

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

See Also:

e (Wikipedia)

setEnumeration

public <E extends Enum<E>> Variant setEnumeration(E aValue)
                       throws UnsupportedOperationException,
                              ArithmeticException,
                              IllegalArgumentException,
                              NullPointerException

Description copied from interface: MutableScalar

Match the value of this object with the identity of the specified enumeration instance, then answer this object (facilitates chaining)

Specified by:

setEnumeration in interface MutableScalar<Variant>

Overrides:

setEnumeration in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a system-supported enumeration

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

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

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

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

setFalse

public final Variant setFalse()
                       throws UnsupportedOperationException,
                              ArithmeticException

Description copied from interface: MutableBooleanValue

Set this property to its equivalent of true and answer this object (facilitates chaining)

Specified by:

setFalse in interface MutableBooleanValue<Variant>

Overrides:

setFalse in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

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

setLength

public final Variant setLength(int newLength)
                        throws UnsupportedOperationException

Specified by:

setLength in interface MutableTextValue<Variant>

Overrides:

setLength in class AbstractPrimitiveWrapper<Variant>

Throws:

UnsupportedOperationException

setMaximum

public final Variant 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<Variant>

Overrides:

setMaximum in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

setMinimum in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

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

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

setNegativeInfinity

public final Variant setNegativeInfinity()
                                  throws UnsupportedOperationException

Description copied from interface: MutableScalar

Replace the current value with a representation of negative infinity, if available, otherwise replace with the implementation's minimum value

Specified by:

setNegativeInfinity in interface MutableScalar<Variant>

Overrides:

setNegativeInfinity in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

setPi

public final Variant setPi()
                    throws UnsupportedOperationException,
                           ArithmeticException,
                           IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value with Pi

Specified by:

setPi in interface MutableScalar<Variant>

Overrides:

setPi in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

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

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

setPositiveInfinity

public final Variant setPositiveInfinity()
                                  throws UnsupportedOperationException,
                                         ArithmeticException,
                                         IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value with a representation of positive infinity, if available, otherwise replace with the implementation's maximum value

Specified by:

setPositiveInfinity in interface MutableScalar<Variant>

Overrides:

setPositiveInfinity in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

setReal in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

setReal in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - an unlimited integer value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

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

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

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

setReal

public final Variant 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<Variant>

Overrides:

setReal in class AbstractReal<Variant>

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 Variant setScalar(boolean aValue)
                        throws UnsupportedOperationException

Description copied from interface: MutableBooleanValue

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

Specified by:

setScalar in interface MutableBooleanValue<Variant>

Overrides:

setScalar in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a boolean value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

setScalar

public final Variant setScalar(byte aValue)
                        throws UnsupportedOperationException

Description copied from interface: MutableByteValue

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

Specified by:

setScalar in interface MutableByteValue<Variant>

Overrides:

setScalar in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a byte value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

setScalar

public final Variant setScalar(char aValue)
                        throws UnsupportedOperationException

Description copied from interface: MutableCharacterValue

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

Specified by:

setScalar in interface MutableCharacterValue<Variant>

Overrides:

setScalar in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a char value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

setScalar

public final Variant setScalar(double aValue)
                        throws UnsupportedOperationException

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<Variant>

Overrides:

setScalar in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a double value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

setScalar

public final Variant setScalar(float aValue)
                        throws UnsupportedOperationException

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<Variant>

Overrides:

setScalar in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a float value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

setScalar

public final Variant setScalar(int aValue)
                        throws UnsupportedOperationException

Description copied from interface: MutableIntegerValue

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

Specified by:

setScalar in interface MutableIntegerValue<Variant>

Overrides:

setScalar in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - an int value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

setScalar

public final Variant setScalar(long aValue)
                        throws UnsupportedOperationException

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<Variant>

Overrides:

setScalar in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a long value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

setScalar

public final Variant 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<Variant>

Overrides:

setScalar in class AbstractPrimitiveWrapper<Variant>

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 Variant setScalar(short aValue)
                        throws UnsupportedOperationException

Description copied from interface: MutableShortValue

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

Specified by:

setScalar in interface MutableShortValue<Variant>

Overrides:

setScalar in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - a short value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

setText

public final Variant setText(CharSequence content)
                      throws UnsupportedOperationException,
                             NullPointerException,
                             IllegalArgumentException

Description copied from interface: MutableTextValue

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

Specified by:

setText in interface MutableTextValue<Variant>

Overrides:

setText in class AbstractPrimitiveWrapper<Variant>

Parameters:

content - a text value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

NullPointerException - a null value was provided and this implementation does not accept null values

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

setTrue

public final Variant setTrue()
                      throws UnsupportedOperationException,
                             ArithmeticException

Description copied from interface: MutableBooleanValue

Set this property to its equivalent of true and answer this object (facilitates chaining)

Specified by:

setTrue in interface MutableBooleanValue<Variant>

Overrides:

setTrue in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

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

setUnity

public final Variant 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<Variant>

Overrides:

setUnity in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

setZero in class AbstractPrimitiveWrapper<Variant>

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

shiftLeft

public final Variant 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.

Specified by:

shiftLeft in interface MutableScalar<Variant>

Overrides:

shiftLeft in class AbstractPrimitiveWrapper<Variant>

Parameters:

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

Returns:

this structure (facilitates chaining)

Throws:

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

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

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

shiftRight

public final Variant 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.

Specified by:

shiftRight in interface MutableScalar<Variant>

Overrides:

shiftRight in class AbstractPrimitiveWrapper<Variant>

Parameters:

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

Returns:

this structure (facilitates chaining)

Throws:

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

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

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

shiftRightExtendZero

public final Variant 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<Variant>

Overrides:

shiftRightExtendZero in class AbstractPrimitiveWrapper<Variant>

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

sine

public final Variant sine()
                   throws UnsupportedOperationException,
                          IllegalArgumentException,
                          ArithmeticException

Description copied from interface: MutableScalar

Replace the current value, assumed to be an angle in radians, to its sine

Specified by:

sine in interface MutableScalar<Variant>

Overrides:

sine in class AbstractPrimitiveWrapper<Variant>

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

square

public final Variant square()
                     throws UnsupportedOperationException,
                            IllegalArgumentException,
                            ArithmeticException

Description copied from interface: MutableScalar

Replace the current value with the square of itself

Specified by:

square in interface MutableScalar<Variant>

Overrides:

square in class AbstractPrimitiveWrapper<Variant>

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

squareRoot

public final Variant squareRoot()
                         throws UnsupportedOperationException,
                                IllegalArgumentException,
                                ArithmeticException

Description copied from interface: MutableScalar

Replace the current value with the square root of itself

Specified by:

squareRoot in interface MutableScalar<Variant>

Overrides:

squareRoot in class AbstractPrimitiveWrapper<Variant>

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

subSequence

public final CharSequence subSequence(int start,
                       int end)

Specified by:

subSequence in interface CharSequence

Overrides:

subSequence in class AbstractPrimitiveWrapper<Variant>

substring

public final String substring(int beginIndex)
                       throws IndexOutOfBoundsException

Specified by:

substring in interface SealedTextValue

Overrides:

substring in class AbstractPrimitiveWrapper<Variant>

Throws:

IndexOutOfBoundsException

substring

public final String substring(int beginIndex,
               int endIndex)
                       throws IndexOutOfBoundsException

Specified by:

substring in interface SealedTextValue

Overrides:

substring in class AbstractPrimitiveWrapper<Variant>

Throws:

IndexOutOfBoundsException

sum

public final Variant sum(BigDecimal aValue)
                  throws UnsupportedOperationException,
                         IllegalArgumentException,
                         ArithmeticException

Description copied from interface: MutableReal

Set the value of this scalar to the mathematical sum of its current value and the specified value

Specified by:

sum in interface MutableReal<Variant>

Overrides:

sum in class AbstractPrimitiveWrapper<Variant>

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 Variant sum(BigInteger aValue)
                  throws UnsupportedOperationException,
                         IllegalArgumentException,
                         ArithmeticException

Description copied from interface: MutableReal

Set the value of this scalar to the mathematical sum of its current value and the specified value

Specified by:

sum in interface MutableReal<Variant>

Overrides:

sum in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

sum in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

sum in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

sum in class AbstractPrimitiveWrapper<Variant>

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 Variant sum(double 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<Variant>

Overrides:

sum in class AbstractPrimitiveWrapper<Variant>

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 Variant sum(float 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<Variant>

Overrides:

sum in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

sum in class AbstractPrimitiveWrapper<Variant>

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 Variant sum(long 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<Variant>

Overrides:

sum in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

sum in class AbstractPrimitiveWrapper<Variant>

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 Variant swapPrimitives(Primitive<?> aValue)
                             throws UnsupportedOperationException

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

Specified by:

swapPrimitives in interface Primitive<Variant>

Overrides:

swapPrimitives in class AbstractPrimitiveWrapper<Variant>

Parameters:

aValue - the primitive to swap with

Returns:

this primitive

Throws:

UnsupportedOperationException

tangent

public final Variant tangent()
                      throws UnsupportedOperationException,
                             IllegalArgumentException,
                             ArithmeticException

Description copied from interface: MutableScalar

Replace the current value, assumed to be an angle in radians, to its tangent

Specified by:

tangent in interface MutableScalar<Variant>

Overrides:

tangent in class AbstractPrimitiveWrapper<Variant>

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

upperCase

public final Variant upperCase()
                        throws UnsupportedOperationException

Description copied from interface: MutableTextValue

For text-based objects, convert all characters in the text to upper case. For numeric objects, convert their character (BMP) or integer value (Unicode) to upper case, depending on the object's precision level

Specified by:

upperCase in interface MutableTextValue<Variant>

Overrides:

upperCase in class AbstractPrimitiveWrapper<Variant>

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException

xor

public final Variant xor(BigInteger aValue)
                  throws UnsupportedOperationException,
                         IllegalArgumentException,
                         ArithmeticException

Description copied from interface: MutableReal

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 MutableReal<Variant>

Overrides:

xor in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

xor in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

xor in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

xor in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

xor in class AbstractPrimitiveWrapper<Variant>

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 Variant xor(long 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<Variant>

Overrides:

xor in class AbstractPrimitiveWrapper<Variant>

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 Variant 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<Variant>

Overrides:

xor in class AbstractPrimitiveWrapper<Variant>

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

toPrimitive

public static final Primitive<?> toPrimitive(Number aNumber)

toPrimitive

public static final Primitive<?> toPrimitive(NumericPrecision prec)

toPrimitive

public static final Primitive<?> toPrimitive(SealedReal<?> aReal)

toPrimitive

public static final Primitive<?> toPrimitive(SealedScalar<?> aScalar)

valueOfPrimitive

public static final Variant valueOfPrimitive(SealedPrimitive<?> aValue)

valueOfReal

public static final Variant valueOfReal(SealedReal<?> aReal)

valueOfScalar

public static final Variant valueOfScalar(SealedScalar<?> aScalar)