SCALAR
- this scalar type (used to facilitate operation chaining on write
operations)public abstract class AbstractScalar<SCALAR extends Scalar<SCALAR>> extends Number implements Scalar<SCALAR>, Serializable
Modifier and Type | Field and Description |
---|---|
static Double |
NaN |
static Integer |
ONEI |
static long |
ZERO_DOUBLE_LONG_BITS |
static int |
ZERO_FLOAT_INT_BITS |
static Integer |
ZEROI |
Constructor and Description |
---|
AbstractScalar() |
AbstractScalar(Domain aDomain,
NumericPrecision aPrecision) |
Modifier and Type | Method and Description |
---|---|
SCALAR |
absoluteValue()
Replace the current value with the absolute value of itself
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
andOfNumber(Number aValue)
Set this value to the bit and of the integral boolean
vector equivalent of this value and the specified integral boolean vector
|
SCALAR |
andOfScalar(SealedScalar<?> aValue)
Set this value to the bit and of the integral boolean
vector equivalent of this value and the specified integral boolean vector
|
SCALAR |
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.
|
SCALAR |
angleWithNumber(Number y)
Set this value to the angle formed by the rectangular coordinates given
by the current value, x, and the specified value, y.
|
SCALAR |
angleWithScalar(SealedScalar<?> aValue)
Set this value to the angle formed by the rectangular coordinates given
by the current value, x, and the specified value, y.
|
SCALAR |
arcCosine()
Replace the current value with its arc
cosine |
SCALAR |
arcSine()
Replace the current value with its arc
sine |
SCALAR |
arcTangent()
Replace the current value with its arc
tangent |
SCALAR |
assertDomain(Domain aDomain)
Attempt to convert the implementation
domain of this
structure to the closest available match for the proposed domain. |
SCALAR |
assertPrecision(NumericPrecision prec)
Convert the numeric
precision of this
implementation to the closest available match for the proposed precision. |
SCALAR |
base10Log()
Replace the current value with its base 10 logarithm
|
static void |
boundsCheck(int anIndex,
int anOrdinalBound) |
static byte |
byteMaskAt(int aBitPosition) |
static byte |
byteNotMaskAt(int aBitPosition) |
static byte |
byteValue(boolean[] aBooleanArray) |
SCALAR |
ceiling()
Replace the current value with the smallest (closest to negative
infinity) value that is greater than or equal to the current value and is
equal to a mathematical integer
|
static char |
charMaskAt(int aBitPosition) |
static char |
charNotMaskAt(int aBitPosition) |
static char |
charValue(boolean[] aBooleanArray) |
static byte |
clearByteBitAt(int anIndex,
byte myValue) |
static char |
clearCharBitAt(int anIndex,
char myValue) |
static double |
clearDoubleBitAt(int anIndex,
double myValue) |
static float |
clearFloatBitAt(int anIndex,
float myValue) |
static int |
clearIntBitAt(int anIndex,
int myValue) |
static long |
clearLongBitAt(int anIndex,
long myValue) |
static short |
clearShortBitAt(int anIndex,
short myValue) |
static BigDecimal |
clearUnlimitedDecimalBitAt(int anIndex,
BigDecimal myValue) |
static BigInteger |
clearUnlimitedIntegerBitAt(int anIndex,
BigInteger myValue) |
static int |
compareTo(BigDecimal p0,
BigDecimal p1) |
static int |
compareTo(BigInteger p0,
BigInteger p1) |
static int |
compareTo(boolean p0,
boolean p1) |
static int |
compareTo(byte p0,
byte p1) |
static int |
compareTo(char p0,
char p1) |
static int |
compareTo(CharSequence p0,
CharSequence p1) |
static int |
compareTo(double p0,
double p1) |
static int |
compareTo(float p0,
float p1) |
static int |
compareTo(int p0,
int p1) |
static int |
compareTo(long p0,
long p1) |
static int |
compareTo(short p0,
short p1) |
int |
compareToNumber(Number aValue)
Compares this object with the specified object for order
|
int |
compareToScalar(boolean aValue)
Compares this object with the specified scalar for order
|
int |
compareToScalar(byte aValue)
Compares this object with the specified scalar for order
|
int |
compareToScalar(char aValue)
Compares this object with the specified scalar for order
|
int |
compareToScalar(double aValue)
Compares this object with the specified scalar for order
|
int |
compareToScalar(float aValue)
Compares this object with the specified scalar for order
|
int |
compareToScalar(int aValue)
Compares this object with the specified scalar for order
|
int |
compareToScalar(long aValue)
Compares this object with the specified scalar for order
|
int |
compareToScalar(SealedScalar<?> aValue)
Compares this object with the specified object for order
|
int |
compareToScalar(short aValue)
Compares this object with the specified scalar for order
|
int |
compareToZero()
Compares this object with zero for order
|
SCALAR |
cosine()
Replace the current value, assumed to be an angle in radians, to its
cosine |
SCALAR |
cubeRoot()
Replace the current value with the cube root of itself
|
SCALAR |
degrees()
Replace the current value, assumed to be an angle in radians, to its
equivalent angle in degrees
|
SCALAR |
difference(boolean aValue)
Set the value of this scalar to the mathematical difference
between its current value and the specified value
|
SCALAR |
difference(byte aValue)
Set the value of this scalar to the mathematical difference
between its current value and the specified value
|
SCALAR |
difference(char aValue)
Set the value of this scalar to the mathematical difference
between its current value and the specified value
|
SCALAR |
difference(double aValue)
Set the value of this scalar to the mathematical difference
between its current value and the specified value
|
SCALAR |
difference(float aValue)
Set the value of this scalar to the mathematical difference
between its current value and the specified value
|
SCALAR |
difference(int aValue)
Set the value of this scalar to the mathematical difference
between its current value and the specified value
|
SCALAR |
difference(long aValue)
Set the value of this scalar to the mathematical difference
between its current value and the specified value
|
SCALAR |
difference(short aValue)
Set the value of this scalar to the mathematical difference
between its current value and the specified value
|
SCALAR |
differenceOfNumber(Number aValue)
Set the value of this scalar to the mathematical difference
between its current value and the specified value
|
SCALAR |
differenceOfScalar(SealedScalar<?> aValue)
Set the value of this scalar to the mathematical difference
between its current value and the specified value
|
static void |
divideByZero() |
SCALAR |
down()
Round the current value towards zero (truncate)
|
boolean |
equals(Object anObject) |
SCALAR |
exponential()
Replace the current value with e (Napier's constant) raised to the
current value (en)
|
SCALAR |
exponentialLessOne()
Replace the current value with e (Napier's constant) raised to the
current value, less 1 (en-1)
|
SCALAR |
floor()
Replace the current value with the largest (closest to positive infinity)
value that is less than or equal to the current value and is equal to a
mathematical integer
|
SCALAR |
gcd(byte aValue)
Replace the current value with the greatest common factor between this
value and the specific one
|
SCALAR |
gcd(char aValue)
Replace the current value with the greatest common factor between this
value and the specific one
|
SCALAR |
gcd(int aValue)
Replace the current value with the greatest common factor between this
value and the specific one
|
SCALAR |
gcd(long aValue)
Replace the current value with the greatest common factor between this
value and the specific one
|
SCALAR |
gcd(short aValue)
Replace the current value with the greatest common factor between this
value and the specific one
|
SCALAR |
gcdOfNumber(Number aValue)
Replace the current value with the greatest common factor between this
value and the specific one
|
SCALAR |
gcdOfScalar(Scalar<?> aScalar)
Replace the current value with the greatest common factor between this
value and the specific one
|
static boolean |
getBooleanBitAt(int anIndex,
boolean myValue) |
static boolean |
getByteBitAt(int anIndex,
byte myValue) |
static boolean |
getCharBitAt(int anIndex,
char myValue) |
Domain |
getDomain() |
static boolean |
getDoubleBitAt(int anIndex,
double myValue) |
static boolean |
getFloatBitAt(int anIndex,
float myValue) |
static boolean |
getIntBitAt(int anIndex,
int myValue) |
static boolean |
getLongBitAt(int anIndex,
long myValue) |
NumericPrecision |
getPrecision() |
static boolean |
getShortBitAt(int anIndex,
short myValue) |
static boolean |
getUnlimitedDecimalBitAt(int anIndex,
BigDecimal myValue) |
static boolean |
getUnlimitedIntegerBitAt(int anIndex,
BigInteger myValue) |
SCALAR |
halfDown()
Round towards "nearest neighbor" unless both neighbors are equidistant,
in which case round down
|
SCALAR |
halfEven()
Round towards "nearest neighbor" unless both neighbors are equidistant,
in which case round to the even neighbor
|
SCALAR |
halfUp()
Round towards "nearest neighbor" unless both neighbors are equidistant,
in which case round up
|
static int |
hashCode(boolean aValue) |
static int |
hashCode(byte aValue) |
static int |
hashCode(char aValue) |
static int |
hashCode(double aValue) |
static int |
hashCode(float aValue) |
static int |
hashCode(int aValue) |
static int |
hashCode(long aValue) |
static int |
hashCode(short aValue) |
SCALAR |
hyperbolicCosine()
Replace the current value, assumed to be an angle in radians, to its
hyperbolic
cosine |
SCALAR |
hyperbolicSine()
Replace the current value, assumed to be an angle in radians, to its
hyperbolic
sine |
SCALAR |
hyperbolicTangent()
Replace the current value, assumed to be an angle in radians, to its
hyperbolic
tangent |
SCALAR |
hypotenuseWith(double aValue)
Set this value to the hypotenuse formed by the square root of the sum of
the square of the current value, x, and the square of the
specified value, y, without intermediate overflow or underflow
|
SCALAR |
hypotenuseWithNumber(Number aValue)
Set this value to the hypotenuse formed by the square root of the sum of
the square of the current value, x, and the square of the
specified value, y, without intermediate overflow or underflow
|
SCALAR |
hypotenuseWithScalar(SealedScalar<?> aValue)
Set this value to the hypotenuse formed by the square root of the sum of
the square of the current value, x, and the square of the
specified value, y, without intermediate overflow or underflow
|
static void |
indexOutOfBoundsAt(int anIndex) |
<S extends Scalar<?>> |
induceScalarSize(S aTarget)
Update the target
scalar with the element count in this
structure |
static int |
intGCD(int p0,
int p1) |
static int |
intMaskAt(int aBitPosition) |
static int |
intModularInverse(int p0,
int p1) |
static int |
intModularQuotient(int aDividend,
int aDivisor,
int aModulus) |
static int |
intNotMaskAt(int aBitPosition) |
static int |
intValue(boolean[] aBooleanArray) |
SCALAR |
invalidate()
Replace the current value an invalid value such
INVALID if possible, otherwise replace it with zero |
boolean |
isAlphabetic() |
boolean |
isBmpCodePoint() |
boolean |
isConfigurable()
|
boolean |
isCountable()
Answer
true if this structure contains a countable number of
elements. |
boolean |
isDigit()
Determine if this
char -width or int -width
character is a digit within Unicode |
boolean |
isElastic()
Answer
true if this structure, in principle, can be
reduced via element removal or expanded via element addition. |
boolean |
isEmpty()
Answer
true if this structure contains no elements. |
boolean |
isEqual(boolean aScalar) |
boolean |
isEqual(byte aScalar) |
boolean |
isEqual(char aScalar) |
boolean |
isEqual(double aScalar) |
boolean |
isEqual(float aScalar) |
boolean |
isEqual(int aScalar) |
boolean |
isEqual(long aScalar) |
boolean |
isEqual(short aScalar) |
boolean |
isEqualToNumber(Number aNumber) |
boolean |
isEqualToScalar(SealedScalar<?> aScalar) |
boolean |
isExpandable() |
boolean |
isFalse() |
boolean |
isFinite() |
boolean |
isGreater(boolean aScalar) |
boolean |
isGreater(byte aScalar) |
boolean |
isGreater(char aScalar) |
boolean |
isGreater(double aScalar) |
boolean |
isGreater(float aScalar) |
boolean |
isGreater(int aScalar) |
boolean |
isGreater(long aScalar) |
boolean |
isGreater(short aScalar) |
boolean |
isGreaterOrEqual(boolean aScalar) |
boolean |
isGreaterOrEqual(byte aScalar) |
boolean |
isGreaterOrEqual(char aScalar) |
boolean |
isGreaterOrEqual(double aScalar) |
boolean |
isGreaterOrEqual(float aScalar) |
boolean |
isGreaterOrEqual(int aScalar) |
boolean |
isGreaterOrEqual(long aScalar) |
boolean |
isGreaterOrEqual(short aScalar) |
boolean |
isGreaterOrEqualToNumber(Number aNumber) |
boolean |
isGreaterOrEqualToScalar(SealedScalar<?> aScalar) |
boolean |
isGreaterThanNumber(Number aNumber) |
boolean |
isGreaterThanScalar(SealedScalar<?> aScalar) |
boolean |
isHighSurrogate() |
boolean |
isIdentifierIgnorable()
Determine if this
char -width or int -width
character ignorable character in a Java identifier or a Unicode
identifier |
boolean |
isIdeographic() |
boolean |
isImaginary()
Answer
true if this value represents the magnitude of a vector
into the set of imaginary numbers. |
boolean |
isISOControl()
Determine if this
char -width or int -width
character is an ISO control character within Unicode |
boolean |
isJavaIdentifierPart()
Determine if this
char -width or int -width
character is a part of a Java identifier as other than the first
character |
boolean |
isJavaIdentifierStart()
Determine if this
char -width or int -width
character is permissible as the first character in a Java identifier |
boolean |
isLess(boolean aScalar) |
boolean |
isLess(byte aScalar) |
boolean |
isLess(char aScalar) |
boolean |
isLess(double aScalar) |
boolean |
isLess(float aScalar) |
boolean |
isLess(int aScalar) |
boolean |
isLess(long aScalar) |
boolean |
isLess(short aScalar) |
boolean |
isLessOrEqual(boolean aScalar) |
boolean |
isLessOrEqual(byte aScalar) |
boolean |
isLessOrEqual(char aScalar) |
boolean |
isLessOrEqual(double aScalar) |
boolean |
isLessOrEqual(float aScalar) |
boolean |
isLessOrEqual(int aScalar) |
boolean |
isLessOrEqual(long aScalar) |
boolean |
isLessOrEqual(short aScalar) |
boolean |
isLessOrEqualToNumber(Number aNumber) |
boolean |
isLessOrEqualToScalar(SealedScalar<?> aScalar) |
boolean |
isLessThanNumber(Number aNumber) |
boolean |
isLessThanScalar(SealedScalar<?> aScalar) |
boolean |
isLetter()
Determine if this
char -width or int -width
character is a letter within Unicode |
boolean |
isLetterOrDigit()
Determine if this
char -width or int -width
character is a letter or digit within Unicode |
boolean |
isLowerCase()
Determine if this
char -width or int -width
character is a lower case character within Unicode |
boolean |
isLowSurrogate() |
boolean |
isMirrored()
Determine if this
char -width or int -width
character is "mirrored" within Unicode |
boolean |
isMutable() |
boolean |
isNegativeFinite() |
boolean |
isNotEqual(boolean aScalar) |
boolean |
isNotEqual(byte aScalar) |
boolean |
isNotEqual(char aScalar) |
boolean |
isNotEqual(double aScalar) |
boolean |
isNotEqual(float aScalar) |
boolean |
isNotEqual(int aScalar) |
boolean |
isNotEqual(long aScalar) |
boolean |
isNotEqual(short aScalar) |
boolean |
isNotEqualToNumber(Number aNumber) |
boolean |
isNotEqualToScalar(SealedScalar<?> aScalar) |
boolean |
isOrdered()
Answer
true if the elements of this structure necessarily
share a partial or total order between each other within the context of
this structure. |
boolean |
isPositiveFinite() |
boolean |
isReducible()
Answer
true if this structure, in principle, can be
reduced via element removal. |
boolean |
isSupplementaryCodePoint() |
boolean |
isSurrogate() |
boolean |
isTitleCase()
Determine if this
char -width or int -width
character is a title case character within Unicode |
boolean |
isTrue() |
boolean |
isUnicode()
Determine if this
char -width or int -width
character is defined within Unicode |
boolean |
isUnicodeIdentifierPart()
Determine if this
char -width or int -width
character is a part of a Unicode identifier as other than the first
character |
boolean |
isUnicodeIdentifierStart()
Determine if this
char -width or int -width
character is permissible as the first character in a Unicode identifier |
boolean |
isUnique() |
boolean |
isUpperCase()
Determine if this
char -width or int -width
character is an upper case character within Unicode |
boolean |
isValid() |
boolean |
isValidCodePoint() |
boolean |
isWhitespace()
Determine if this
char -width or int -width
character is whitespace within Unicode |
static long |
longGCD(long p0,
long p1) |
static long |
longMaskAt(int aBitPosition) |
static long |
longModularInverse(long p0,
long p1) |
static long |
longModularQuotient(long aDividend,
long aDivisor,
long aModulus) |
static long |
longNotMaskAt(int aBitPosition) |
long |
longSize()
Returns the number of elements in this algebraic structure as a
long scalar. |
static long |
longValue(boolean[] aBooleanArray) |
SCALAR |
milliseconds()
Set the value of this object to the current millisecond-precision system
time |
SCALAR |
mod(boolean aValue)
Set the value of this scalar to its current value modulo of the
specified value
|
SCALAR |
mod(byte aValue)
Set the value of this scalar to its current value modulo of the
specified value
|
SCALAR |
mod(char aValue)
Set the value of this scalar to its current value modulo of the
specified value
|
SCALAR |
mod(double aValue)
Set the value of this scalar to its current value modulo of the
specified value
|
SCALAR |
mod(float aValue)
Set the value of this scalar to its current value modulo of the
specified value
|
SCALAR |
mod(int aValue)
Set the value of this scalar to its current value modulo of the
specified value
|
SCALAR |
mod(long aValue)
Set the value of this scalar to its current value modulo of the
specified value
|
SCALAR |
mod(short aValue)
Set the value of this scalar to its current value modulo of the
specified value
|
SCALAR |
modOfNumber(Number aNumber)
Set the value of this scalar to its current value modulo of the
specified value
|
SCALAR |
modOfScalar(SealedScalar<?> aValue)
Set the value of this scalar to its current value modulo of the
specified value
|
SCALAR |
nanoseconds()
Set the value of this object to the current nanosecond-precision system
time |
SCALAR |
naturalLog()
Replace the current value with its base e (Napier's constant)
logarithm (loge(n))
|
SCALAR |
naturalLogPlusOne()
Replace the current value, plus 1, with its base e (Napier's
constant) logarithm (loge(n+1))
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
orOfNumber(Number aValue)
Set this value to the bit or of the integral boolean vector
equivalent of this value and the specified integral boolean vector
|
SCALAR |
orOfScalar(SealedScalar<?> aValue)
Set this value to the bit or of the integral boolean vector
equivalent of this value and the specified integral boolean vector
|
SCALAR |
power(double n)
Set this value to the current value, x, raised to the specified
exponent, n, or xn
|
SCALAR |
power(int n)
Set this value to the current value, x, raised to the specified
exponent, n, or xn
|
SCALAR |
powerOfNumber(Number aValue)
Set this value to the current value, x, raised to the specified
exponent, n, or xn
|
SCALAR |
powerOfScalar(SealedScalar<?> aValue)
Set this value to the current value, x, raised to the specified
exponent, n, or xn
|
SCALAR |
product(boolean aValue)
Set the value of this scalar to the mathematical product of its
current value and the specified value
|
SCALAR |
product(byte aValue)
Set the value of this scalar to the mathematical product of its
current value and the specified value
|
SCALAR |
product(char aValue)
Set the value of this scalar to the mathematical product of its
current value and the specified value
|
SCALAR |
product(double aValue)
Set the value of this scalar to the mathematical product of its
current value and the specified value
|
SCALAR |
product(float aValue)
Set the value of this scalar to the mathematical product of its
current value and the specified value
|
SCALAR |
product(int aValue)
Set the value of this scalar to the mathematical product of its
current value and the specified value
|
SCALAR |
product(long aValue)
Set the value of this scalar to the mathematical product of its
current value and the specified value
|
SCALAR |
product(short aValue)
Set the value of this scalar to the mathematical product of its
current value and the specified value
|
SCALAR |
productOfNumber(Number aValue)
Set the value of this scalar to the mathematical product of its
current value and the specified value
|
SCALAR |
productOfScalar(SealedScalar<?> aValue)
Set the value of this scalar to the mathematical product of its
current value and the specified value
|
SCALAR |
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. |
SCALAR |
quotient(boolean aValue)
Set the value of this scalar to the mathematical quotient between
its current value and the specified value
|
SCALAR |
quotient(byte aValue)
Set the value of this scalar to the mathematical quotient of its
current value and the specified value
|
SCALAR |
quotient(char aValue)
Set the value of this scalar to the mathematical quotient between
its current value and the specified value
|
SCALAR |
quotient(double aValue)
Set the value of this scalar to the mathematical quotient of its
current value and the specified value
|
SCALAR |
quotient(float aValue)
Set the value of this scalar to the mathematical quotient of its
current value and the specified value
|
SCALAR |
quotient(int aValue)
Set the value of this scalar to the mathematical quotient of its
current value and the specified value
|
SCALAR |
quotient(long aValue)
Set the value of this scalar to the mathematical quotient of its
current value and the specified value
|
SCALAR |
quotient(short aValue)
Set the value of this scalar to the mathematical quotient of its
current value and the specified value
|
SCALAR |
quotientOfNumber(Number aValue)
Set the value of this scalar to the mathematical quotient of its
current value and the specified value
|
SCALAR |
quotientOfScalar(SealedScalar<?> aValue)
Set the value of this scalar to the mathematical quotient between
its current value and the specified value
|
SCALAR |
radians()
Replace the current value, assumed to be an angle in degrees, to its
equivalent angle in radians
|
SCALAR |
random()
Replace the current value with an evenly-distributed
random value between zero (inclusive) and unity
(exclusive for floating point, inclusive for integrals) |
static byte |
setByteBitAt(int anIndex,
byte myValue) |
static char |
setCharBitAt(int anIndex,
char myValue) |
static double |
setDoubleBitAt(int anIndex,
double myValue) |
SCALAR |
setE()
Replace the current value with e, or Napier's constant
|
<E extends Enum<E>> |
setEnumeration(E aValue)
Match the value of this object with the identity of the specified
enumeration instance, then answer this object (facilitates
chaining) |
SCALAR |
setFalse()
Set this property to its equivalent of
true and answer this
object (facilitates chaining) |
static float |
setFloatBitAt(int anIndex,
float myValue) |
static int |
setIntBitAt(int anIndex,
int myValue) |
static long |
setLongBitAt(int anIndex,
long myValue) |
SCALAR |
setNegativeInfinity()
Replace the current value with a representation of negative infinity, if
available, otherwise replace with the implementation's
minimum value |
SCALAR |
setNumber(Number aValue)
Set this object to the specified system-supported
Number and
answer this object (facilitates chaining) |
SCALAR |
setPi()
Replace the current value with Pi
|
SCALAR |
setPositiveInfinity()
Replace the current value with a representation of positive infinity, if
available, otherwise replace with the implementation's
maximum value |
SCALAR |
setScalar(SealedScalar<?> aValue)
Set this object to the specified scalar
|
static short |
setShortBitAt(int anIndex,
short myValue) |
SCALAR |
setTrue()
Set this property to its equivalent of
true and answer this
object (facilitates chaining) |
SCALAR |
setUnity()
Replace the current value with the multiplicative identity appropriate
for the implementation (one)
|
static BigDecimal |
setUnlimitedDecimalBitAt(int anIndex,
BigDecimal myValue) |
static BigInteger |
setUnlimitedIntegerBitAt(int anIndex,
BigInteger myValue) |
SCALAR |
setZero()
Replace the current value with the additive identity appropriate for the
implementation (zero)
|
SCALAR |
shiftRightExtendZero(int count)
Attempt to shift the elements of this tuple to the "right" the specified
number of ordinal positions without sign extension.
|
static short |
shortMaskAt(int aBitPosition) |
static short |
shortNotMaskAt(int aBitPosition) |
static short |
shortValue(boolean[] aBooleanArray) |
int |
signum() |
SCALAR |
sine()
Replace the current value, assumed to be an angle in radians, to its
sine |
int |
size()
Returns the number of elements in this algebraic structure.
|
SCALAR |
squareRoot()
Replace the current value with the square root of itself
|
SCALAR |
sum(boolean aValue)
Set the value of this scalar to the mathematical sum of its
current value and the specified value
|
SCALAR |
sum(byte aValue)
Set the value of this scalar to the mathematical sum of its
current value and the specified value
|
SCALAR |
sum(char aValue)
Set the value of this scalar to the mathematical sum of its
current value and the specified value
|
SCALAR |
sum(double aValue)
Set the value of this scalar to the mathematical sum of its
current value and the specified value
|
SCALAR |
sum(float aValue)
Set the value of this scalar to the mathematical sum of its
current value and the specified value
|
SCALAR |
sum(int aValue)
Set the value of this scalar to the mathematical sum of its
current value and the specified value
|
SCALAR |
sum(long aValue)
Set the value of this scalar to the mathematical sum of its
current value and the specified value
|
SCALAR |
sum(short aValue)
Set the value of this scalar to the mathematical sum of its
current value and the specified value
|
SCALAR |
sumOfNumber(Number aValue)
Set the value of this scalar to the mathematical sum of its
current value and the specified value
|
SCALAR |
sumOfScalar(SealedScalar<?> aValue)
Set the value of this scalar to the mathematical sum of its
current value and the specified value
|
SCALAR |
tangent()
Replace the current value, assumed to be an angle in radians, to its
tangent |
Boolean |
toBoolean() |
static boolean[] |
toBooleanArray(BigDecimal aTuple) |
static boolean[] |
toBooleanArray(BigInteger aTuple) |
static boolean[] |
toBooleanArray(boolean aTuple) |
static boolean[] |
toBooleanArray(byte aTuple) |
static boolean[] |
toBooleanArray(char aTuple) |
static boolean[] |
toBooleanArray(CharSequence aTuple) |
static boolean[] |
toBooleanArray(double aTuple) |
static boolean[] |
toBooleanArray(float aTuple) |
static boolean[] |
toBooleanArray(int aTuple) |
static boolean[] |
toBooleanArray(long aTuple) |
static boolean[] |
toBooleanArray(short aTuple) |
static byte[] |
toByteArray(boolean[] aBooleanArray) |
Character |
toCharacter() |
int |
toCodePoint()
Represent the value of this object as a code point
|
<E extends Enum<E>> |
toEnumeration(Class<E> anEnumerationClass)
Represent the value of this object as an appropriate member of the class
of the specified
enumeration |
Scalar<?> |
toScalar()
If this scalar is already a
scalar then simply
call its Replicator.copy() function, otherwise produce a new scalar
with scalar precision |
static BigInteger |
toUnlimitedInteger(boolean[] aBooleanArray) |
static BigInteger |
unlimitedIntegerMaskAt(int aBitPosition) |
static BigInteger |
unlimitedIntegerNotMaskAt(int aBitPosition) |
SCALAR |
up()
Round away from zero
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
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
|
SCALAR |
xorOfNumber(Number aValue)
Set this value to the bit exclusive-or of the integral
boolean vector equivalent of this value and the specified integral
boolean vector
|
SCALAR |
xorOfScalar(SealedScalar<?> aValue)
Set this value to the bit exclusive-or of the integral
boolean vector equivalent of this value and the specified integral
boolean vector
|
byteValue, doubleValue, floatValue, intValue, longValue, shortValue
clone, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
inducePostDecrement, inducePostIncrement, induceScalarValue
toNumber
induceScalarMaximum, induceScalarMinimum
getStructureStrategy
getConcurrency, hashCode, toString
isInfinity, isInvalid, isMaximum, isMinimum, isModulo, isNegative, isNegativeInfinity, isPositive, isPositiveInfinity, isReal, isUnity, isZero
copyUsing, copyUsing, copyUsing, copyUsing, copyUsing, copyUsing, copyUsing, copyUsing, copyUsingScalar
copy
cube, decrement, increment, inverse, negate, not, round, setMaximum, setMinimum, shiftLeft, shiftRight, square
clear, clearContents
booleanValue
booleanPostDecrement, booleanPostIncrement, setScalar
byteValue
bytePostDecrement, bytePostIncrement, setScalar
charValue
charPostDecrement, charPostIncrement, setScalar
doubleValue
doublePostDecrement, doublePostIncrement, setScalar
floatValue
floatPostDecrement, floatPostIncrement, setScalar
intValue
intPostDecrement, intPostIncrement, setScalar
longValue
longPostDecrement, longPostIncrement, setScalar
shortValue
setScalar, shortPostDecrement, shortPostIncrement
public static final long ZERO_DOUBLE_LONG_BITS
public static final int ZERO_FLOAT_INT_BITS
public AbstractScalar()
public AbstractScalar(Domain aDomain, NumericPrecision aPrecision)
public SCALAR absoluteValue() throws UnsupportedOperationException, ArithmeticException, IllegalArgumentException
MutableScalar
absoluteValue
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectIllegalArgumentException
- if the new value was incommensurate with this object's
specificationpublic SCALAR and(boolean aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
and
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR and(byte aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
and
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR and(char aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
and
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR and(int aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
and
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR and(long aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
and
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR and(short aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
and
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR andOfNumber(Number aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
andOfNumber
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR andOfScalar(SealedScalar<?> aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
andOfScalar
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR angleWith(double aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
angleWith
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a y coordinate valueUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectMath.atan2(double, double)
public final SCALAR angleWithNumber(Number y) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
angleWithNumber
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
y
- a y coordinate valueUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectMath.atan2(double, double)
public final SCALAR angleWithScalar(SealedScalar<?> aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
angleWithScalar
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a y coordinate valueUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectMath.atan2(double, double)
public SCALAR arcCosine() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
cosine
arcCosine
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR arcSine() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
sine
arcSine
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR arcTangent() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
tangent
arcTangent
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR assertDomain(Domain aDomain)
MutableAlgebraicStructure
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.assertDomain
in interface MutableAlgebraicStructure<SCALAR extends Scalar<SCALAR>>
aDomain
- the proposed domainthis
object (facilitates operation chaining)StructureProperties.isConfigurable()
public SCALAR assertPrecision(NumericPrecision prec)
MutableScalarDomain
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.assertPrecision
in interface MutableScalarDomain<SCALAR extends Scalar<SCALAR>>
prec
- the proposed precisionthis
object (facilitates operation chaining)public SCALAR base10Log() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
base10Log
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic final SCALAR ceiling() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
ceiling
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic int compareToNumber(Number aValue)
SealedScalar
compareToNumber
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an object to be compared toComparable.compareTo(Object)
public int compareToScalar(boolean aValue)
SealedScalar
compareToScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a scalar to be compared toComparable.compareTo(Object)
public int compareToScalar(byte aValue)
SealedScalar
compareToScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a scalar to be compared toComparable.compareTo(Object)
public int compareToScalar(char aValue)
SealedScalar
compareToScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a scalar to be compared toComparable.compareTo(Object)
public int compareToScalar(double aValue)
SealedScalar
compareToScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a scalar to be compared toComparable.compareTo(Object)
public int compareToScalar(float aValue)
SealedScalar
compareToScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a scalar to be compared toComparable.compareTo(Object)
public int compareToScalar(int aValue)
SealedScalar
compareToScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a scalar to be compared toComparable.compareTo(Object)
public int compareToScalar(long aValue)
SealedScalar
compareToScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a scalar to be compared toComparable.compareTo(Object)
public int compareToScalar(SealedScalar<?> aValue)
SealedScalar
compareToScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an object to be compared toComparable.compareTo(Object)
public int compareToScalar(short aValue)
SealedScalar
compareToScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a scalar to be compared toComparable.compareTo(Object)
public int compareToZero()
SealedScalar
compareToZero
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
Comparable.compareTo(Object)
public SCALAR cosine() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
cosine
cosine
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR cubeRoot() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
cubeRoot
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR degrees() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
degrees
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR difference(boolean aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
difference
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a subtrahendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR difference(byte aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
difference
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a subtrahendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR difference(char aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
difference
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a subtrahendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR difference(double aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
difference
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a subtrahendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR difference(float aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
difference
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a subtrahendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR difference(int aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
difference
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a subtrahendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR difference(long aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
difference
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a subtrahendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR difference(short aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
difference
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a subtrahendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR differenceOfNumber(Number aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
differenceOfNumber
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a subtrahendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR differenceOfScalar(SealedScalar<?> aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
differenceOfScalar
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a subtrahendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic final SCALAR down() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
down
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic boolean equals(Object anObject)
equals
in interface SealedKernel
equals
in class Object
public SCALAR exponential() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
exponential
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR exponentialLessOne() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
exponentialLessOne
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic final SCALAR floor() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
floor
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR gcd(byte aValue) throws UnsupportedOperationException, ArithmeticException, IllegalArgumentException
MutableScalar
gcd
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a valueUnsupportedOperationException
- if this object's value cannot be changedArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectIllegalArgumentException
- if the new value was incommensurate with this object's
specificationpublic SCALAR gcd(char aValue) throws UnsupportedOperationException, ArithmeticException, IllegalArgumentException
MutableScalar
gcd
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a valueUnsupportedOperationException
- if this object's value cannot be changedArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectIllegalArgumentException
- if the new value was incommensurate with this object's
specificationpublic SCALAR gcd(int aValue) throws UnsupportedOperationException, ArithmeticException, IllegalArgumentException
MutableScalar
gcd
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a valueUnsupportedOperationException
- if this object's value cannot be changedArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectIllegalArgumentException
- if the new value was incommensurate with this object's
specificationpublic SCALAR gcd(long aValue) throws UnsupportedOperationException, ArithmeticException, IllegalArgumentException
MutableScalar
gcd
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a valueUnsupportedOperationException
- if this object's value cannot be changedArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectIllegalArgumentException
- if the new value was incommensurate with this object's
specificationpublic SCALAR gcd(short aValue) throws UnsupportedOperationException, ArithmeticException, IllegalArgumentException
MutableScalar
gcd
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a valueUnsupportedOperationException
- if this object's value cannot be changedArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectIllegalArgumentException
- if the new value was incommensurate with this object's
specificationpublic SCALAR gcdOfNumber(Number aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
gcdOfNumber
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic final SCALAR gcdOfScalar(Scalar<?> aScalar) throws UnsupportedOperationException, ArithmeticException, IllegalArgumentException
MutableScalar
gcdOfScalar
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectIllegalArgumentException
- if the new value was incommensurate with this object's
specificationpublic Domain getDomain()
getDomain
in interface SealedAlgebraicStructure
public NumericPrecision getPrecision()
getPrecision
in interface SealedScalarDomain
boolean
bit tuplepublic final SCALAR halfDown() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
halfDown
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic final SCALAR halfEven() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
halfEven
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic final SCALAR halfUp() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
halfUp
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR hyperbolicCosine() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
cosine
hyperbolicCosine
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR hyperbolicSine() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
sine
hyperbolicSine
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR hyperbolicTangent() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
tangent
hyperbolicTangent
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic final SCALAR hypotenuseWith(double aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
hypotenuseWith
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a y valueUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectMath.hypot(double, double)
public final SCALAR hypotenuseWithNumber(Number aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
hypotenuseWithNumber
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a y valueUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectMath.hypot(double, double)
public final SCALAR hypotenuseWithScalar(SealedScalar<?> aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
hypotenuseWithScalar
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a y valueUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectMath.hypot(double, double)
public <S extends Scalar<?>> S induceScalarSize(S aTarget) throws NullPointerException, NoSuchElementException, UnsupportedOperationException, IllegalStateException
SealedScalarBag
scalar
with the element count in this
structureinduceScalarSize
in interface SealedScalarBag
S
- the target typeaTarget
- the target to updateNullPointerException
- a null
value was provided when none was expectedNoSuchElementException
- an expected parameter was not found in the parameter sourceUnsupportedOperationException
- this target cannot be changedIllegalStateException
- this target cannot be changed at this timepublic SCALAR invalidate() throws UnsupportedOperationException, ArithmeticException, IllegalArgumentException
MutableScalar
INVALID
if possible, otherwise replace it with zeroinvalidate
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectIllegalArgumentException
- if the new value was incommensurate with this object's
specificationpublic boolean isAlphabetic()
isAlphabetic
in interface CharacterProperties
true
if the int
value of this object is a
proper alphabetical
value in
UnicodeCharacter.isAlphabetic(int)
public boolean isBmpCodePoint()
isBmpCodePoint
in interface CharacterProperties
true
if the int
value of this object is a
BMP
(Basic Multi-lingual
Plane) code point in UnicodeCharacter.isBmpCodePoint(int)
public boolean isConfigurable()
StructureProperties
true
if the implementation of this object can be changed.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
).isConfigurable
in interface StructureProperties
true
if the implementation of this object can be changedpublic boolean isCountable()
StructureProperties
true
if this structure contains a countable number of
elements. A countable set is a set with the same cardinality as some
subset of the set of natural numbers. A set that is not countable
contains an infinite number of elements.isCountable
in interface StructureProperties
true
if this structure contains a countable number
of elements, otherwise false
if it contains an infinite
number of elementspublic boolean isDigit()
CharacterProperties
char
-width or int
-width
character is a digit within UnicodeisDigit
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is a digit in UnicodeCharacter.isDigit(char)
,
Character.isDigit(int)
public boolean isElastic()
StructureProperties
true
if this structure, in principle, can be
reduced via element removal or expanded via element addition. Empty
collections are, in principle, reducible, but read-only
collections are neither reducible or expandable.isElastic
in interface StructureProperties
true
if this structure can be either
reduced
or expanded
public boolean isEmpty()
StructureProperties
true
if this structure contains no elements. For
strings
this would indicate an empty string (no characters
in an empty array). For scalars this would indicate an empty set, or a
zero bit count, which would be the case of null
values. Note
that, although the null
constant technically contains zero
elements, its string
value evaluates to "null", which from
a String perspective is not empty.isEmpty
in interface StructureProperties
true
if this structure contains no elementspublic boolean isEqual(boolean aScalar)
isEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isEqual(byte aScalar)
isEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isEqual(char aScalar)
isEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isEqual(double aScalar)
isEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isEqual(float aScalar)
isEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isEqual(int aScalar)
isEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isEqual(long aScalar)
isEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isEqual(short aScalar)
isEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isEqualToNumber(Number aNumber)
isEqualToNumber
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isEqualToScalar(SealedScalar<?> aScalar)
isEqualToScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isExpandable()
isExpandable
in interface StructureProperties
true
if this structure can be expanded via element
insertionpublic final boolean isFalse()
isFalse
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
false
value if boolean
,
or the additive identity otherwisepublic boolean isFinite()
isFinite
in interface NumericProperties
true
if this value represents a valid and finite valuepublic boolean isGreater(boolean aScalar)
isGreater
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreater(byte aScalar)
isGreater
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreater(char aScalar)
isGreater
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreater(double aScalar)
isGreater
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreater(float aScalar)
isGreater
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreater(int aScalar)
isGreater
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreater(long aScalar)
isGreater
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreater(short aScalar)
isGreater
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreaterOrEqual(boolean aScalar)
isGreaterOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreaterOrEqual(byte aScalar)
isGreaterOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreaterOrEqual(char aScalar)
isGreaterOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreaterOrEqual(double aScalar)
isGreaterOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreaterOrEqual(float aScalar)
isGreaterOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreaterOrEqual(int aScalar)
isGreaterOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreaterOrEqual(long aScalar)
isGreaterOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreaterOrEqual(short aScalar)
isGreaterOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreaterOrEqualToNumber(Number aNumber)
isGreaterOrEqualToNumber
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreaterOrEqualToScalar(SealedScalar<?> aScalar)
isGreaterOrEqualToScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreaterThanNumber(Number aNumber)
isGreaterThanNumber
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isGreaterThanScalar(SealedScalar<?> aScalar)
isGreaterThanScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isHighSurrogate()
isHighSurrogate
in interface CharacterProperties
true
if the char
value of this object is a
high
surrogate in UTF-16
Unicode encodingCharacter.isHighSurrogate(char)
public boolean isIdentifierIgnorable()
CharacterProperties
char
-width or int
-width
character ignorable character in a Java identifier or a Unicode
identifierisIdentifierIgnorable
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, ignorable character in a Java
identifier or a Unicode identifier as other than the first
characterCharacter.isIdentifierIgnorable(char)
,
Character.isIdentifierIgnorable(int)
public boolean isIdeographic()
isIdeographic
in interface CharacterProperties
true
if the int
value of this object is a
Unicode ideographic
symbolCharacter.isIdeographic(int)
public boolean isImaginary()
NumericProperties
true
if this value represents the magnitude of a vector
into the set of imaginary numbers. This is not the same as testing
whether this object's implementation resembles the specification for the
IMAGINARY
domain, since that is too specific to
implementation machinery. This more general test also includes imaginary
modulo
values in its specification.isImaginary
in interface NumericProperties
true
if this value represents the magnitude of a vector
into the set of imaginary numberspublic boolean isISOControl()
CharacterProperties
char
-width or int
-width
character is an ISO control character within UnicodeisISOControl
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is an ISO control character in
UnicodeCharacter.isISOControl(char)
,
Character.isISOControl(int)
public boolean isJavaIdentifierPart()
CharacterProperties
char
-width or int
-width
character is a part of a Java identifier as other than the first
characterisJavaIdentifierPart
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is a part of a Java identifier as
other than the first characterCharacter.isJavaIdentifierPart(char)
,
Character.isJavaIdentifierPart(int)
public boolean isJavaIdentifierStart()
CharacterProperties
char
-width or int
-width
character is permissible as the first character in a Java identifierisJavaIdentifierStart
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is permissible as the first
character in a Java identifierCharacter.isJavaIdentifierStart(char)
,
Character.isJavaIdentifierStart(int)
public boolean isLess(boolean aScalar)
isLess
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLess(byte aScalar)
isLess
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLess(char aScalar)
isLess
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLess(double aScalar)
isLess
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLess(float aScalar)
isLess
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLess(int aScalar)
isLess
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLess(long aScalar)
isLess
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLess(short aScalar)
isLess
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLessOrEqual(boolean aScalar)
isLessOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLessOrEqual(byte aScalar)
isLessOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLessOrEqual(char aScalar)
isLessOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLessOrEqual(double aScalar)
isLessOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLessOrEqual(float aScalar)
isLessOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLessOrEqual(int aScalar)
isLessOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLessOrEqual(long aScalar)
isLessOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLessOrEqual(short aScalar)
isLessOrEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLessOrEqualToNumber(Number aNumber)
isLessOrEqualToNumber
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLessOrEqualToScalar(SealedScalar<?> aScalar)
isLessOrEqualToScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLessThanNumber(Number aNumber)
isLessThanNumber
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLessThanScalar(SealedScalar<?> aScalar)
isLessThanScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isLetter()
CharacterProperties
char
-width or int
-width
character is a letter within UnicodeisLetter
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is a letter in UnicodeCharacter.isLetter(char)
,
Character.isLetter(int)
public boolean isLetterOrDigit()
CharacterProperties
char
-width or int
-width
character is a letter or digit within UnicodeisLetterOrDigit
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is a letter or digit in UnicodeCharacter.isLetterOrDigit(char)
,
Character.isLetterOrDigit(int)
public boolean isLowerCase()
CharacterProperties
char
-width or int
-width
character is a lower case character within UnicodeisLowerCase
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is a lower case character in
UnicodeCharacter.isLowerCase(char)
,
Character.isLowerCase(int)
public boolean isLowSurrogate()
isLowSurrogate
in interface CharacterProperties
true
if the char
value of this object is a
low
surrogate in UTF-16
Unicode encodingCharacter.isLowSurrogate(char)
public boolean isMirrored()
CharacterProperties
char
-width or int
-width
character is "mirrored" within UnicodeisMirrored
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is "mirrored" in UnicodeCharacter.isMirrored(char)
,
Character.isMirrored(int)
public boolean isMutable()
isMutable
in interface Mutable
true
if modification of the implementation is allowed and
that none of the modification functions will, in principle, throw
UnsupportedOperationExceptions
public boolean isNegativeFinite()
isNegativeFinite
in interface NumericProperties
true
if this value represents a valid, finite and
negative valuepublic boolean isNotEqual(boolean aScalar)
isNotEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isNotEqual(byte aScalar)
isNotEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isNotEqual(char aScalar)
isNotEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isNotEqual(double aScalar)
isNotEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isNotEqual(float aScalar)
isNotEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isNotEqual(int aScalar)
isNotEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isNotEqual(long aScalar)
isNotEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isNotEqual(short aScalar)
isNotEqual
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isNotEqualToNumber(Number aNumber)
isNotEqualToNumber
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isNotEqualToScalar(SealedScalar<?> aScalar)
isNotEqualToScalar
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public boolean isOrdered()
StructureProperties
true
if the elements of this structure necessarily
share a partial or total order between each other within the context of
this structure. Ordering does not necessarily imply a simple sequencing
between randomly selected elements, but rather a necessary sorting order
between elements independent of the sets they are related by. A
SortedSet
is ordered, not merely because its elements are de
facto sorted, but because the SortedSet
defines a universe in
which only sortable elements can exist and it defines a sorting function
which places those elements in their sorted order at the time of
iteration. An ordered
set has elements with values that are reflexive, antisymmetric, and
transitive relative to each other. Necessarily empty sets are not
considered ordered.isOrdered
in interface StructureProperties
true
if the structure has either a partial or total order
over its elementspublic boolean isPositiveFinite()
isPositiveFinite
in interface NumericProperties
true
if this value represents a valid, finite and
negative valuepublic boolean isReducible()
StructureProperties
true
if this structure, in principle, can be
reduced via element removal. Empty collections are, in principle,
reducible, but read-only collections are not.isReducible
in interface StructureProperties
true
if this structure, in principle, can be
reduced via element removalpublic boolean isSupplementaryCodePoint()
isSupplementaryCodePoint
in interface CharacterProperties
true
if the int
value of this object is a
supplementary
code point in UnicodeCharacter.isSupplementaryCodePoint(int)
public boolean isSurrogate()
isSurrogate
in interface CharacterProperties
true
if the char
value of this object is a
surrogate
value (high or low)
in UnicodeCharacter.isSurrogate(char)
public boolean isTitleCase()
CharacterProperties
char
-width or int
-width
character is a title case character within UnicodeisTitleCase
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is a title case character in
UnicodeCharacter.isTitleCase(char)
,
Character.isTitleCase(int)
public final boolean isTrue()
isTrue
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
true
value if boolean
,
or the multiplicative identity otherwisepublic boolean isUnicode()
CharacterProperties
char
-width or int
-width
character is defined within UnicodeisUnicode
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is defined in UnicodeCharacter.isDefined(char)
,
Character.isDefined(int)
public boolean isUnicodeIdentifierPart()
CharacterProperties
char
-width or int
-width
character is a part of a Unicode identifier as other than the first
characterisUnicodeIdentifierPart
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is a part of a Unicode identifier
as other than the first characterCharacter.isUnicodeIdentifierPart(char)
,
Character.isUnicodeIdentifierPart(int)
public boolean isUnicodeIdentifierStart()
CharacterProperties
char
-width or int
-width
character is permissible as the first character in a Unicode identifierisUnicodeIdentifierStart
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is permissible as the first
character in a Unicode identifierCharacter.isUnicodeIdentifierStart(char)
,
Character.isUnicodeIdentifierStart(int)
public boolean isUnique()
isUnique
in interface StructureProperties
true
if the elements in this structure are, by definition
of the structure's algebra, unique (e.g., sets
)public boolean isUpperCase()
CharacterProperties
char
-width or int
-width
character is an upper case character within UnicodeisUpperCase
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is an upper case character in
UnicodeCharacter.isUpperCase(char)
,
Character.isUpperCase(int)
public final boolean isValid()
isValid
in interface NumericProperties
true
if this value represents a valid number (not
INVALID
)public boolean isValidCodePoint()
isValidCodePoint
in interface CharacterProperties
true
if the int
value of this object is a
valid
code point in
UnicodeCharacter.isValidCodePoint(int)
public boolean isWhitespace()
CharacterProperties
char
-width or int
-width
character is whitespace within UnicodeisWhitespace
in interface CharacterProperties
true
if the scalar value of this object, as appropriate
for this objects's precision, is whitespace in UnicodeCharacter.isWhitespace(char)
,
Character.isWhitespace(int)
public long longSize()
SealedAlgebraicStructure
long
scalar. If the structure contains more than
Long.MAX_VALUE
elements, returns Long.MAX_VALUE
.longSize
in interface SealedAlgebraicStructure
long
scalarCollection.size()
,
SealedAlgebraicStructure.size()
public SCALAR milliseconds() throws UnsupportedOperationException
MutableScalar
time
milliseconds
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedpublic SCALAR mod(boolean aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
mod
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a modulusUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR mod(byte aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
mod
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a modulusUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR mod(char aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
mod
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a modulusUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR mod(double aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
mod
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a modulusUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR mod(float aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
mod
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a modulusUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR mod(int aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
mod
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a modulusUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR mod(long aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
mod
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a modulusUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR mod(short aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
mod
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a modulusUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR modOfNumber(Number aNumber) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
modOfNumber
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aNumber
- a modulusUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR modOfScalar(SealedScalar<?> aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
modOfScalar
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a modulusUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR nanoseconds() throws UnsupportedOperationException
MutableScalar
time
nanoseconds
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedpublic SCALAR naturalLog() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
naturalLog
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR naturalLogPlusOne() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
naturalLogPlusOne
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR or(boolean aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
or
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR or(byte aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
or
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR or(char aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
or
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR or(int aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
or
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR or(long aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
or
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR or(short aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
or
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR orOfNumber(Number aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
orOfNumber
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic final SCALAR orOfScalar(SealedScalar<?> aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
orOfScalar
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR power(double n) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
power
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
n
- an exponentUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR power(int n) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
power
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
n
- an exponentUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic final SCALAR powerOfNumber(Number aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
powerOfNumber
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an exponentUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR powerOfScalar(SealedScalar<?> aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
powerOfScalar
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an exponentUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR product(boolean aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
product
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a multiplicandUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR product(byte aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
product
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a multiplicandUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR product(char aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
product
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a multiplicandUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR product(double aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
product
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a multiplicandUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR product(float aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
product
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a multiplicandUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR product(int aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
product
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a multiplicandUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR product(long aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
product
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a multiplicandUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR product(short aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
product
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a multiplicandUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR productOfNumber(Number aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
productOfNumber
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a multiplicandUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR productOfScalar(SealedScalar<?> aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
productOfScalar
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a multiplicandUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR promoteTo(NumericPrecision prec)
MutableScalarDomain
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).promoteTo
in interface MutableScalarDomain<SCALAR extends Scalar<SCALAR>>
prec
- the proposed precisionthis
object (facilitates operation chaining)StructureProperties.isConfigurable()
public SCALAR quotient(boolean aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
quotient
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a divisorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR quotient(byte aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
quotient
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a divisorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR quotient(char aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
quotient
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a divisorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR quotient(double aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
quotient
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a divisorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR quotient(float aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
quotient
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a divisorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR quotient(int aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
quotient
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a divisorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR quotient(long aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
quotient
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a divisorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR quotient(short aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
quotient
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a divisorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR quotientOfNumber(Number aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
quotientOfNumber
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a divisorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR quotientOfScalar(SealedScalar<?> aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
quotientOfScalar
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a divisorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR radians() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
radians
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR random() throws UnsupportedOperationException
MutableScalar
random
value between zero (inclusive) and unity
(exclusive for floating point, inclusive for integrals)random
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedpublic SCALAR setE() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
setE
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic <E extends Enum<E>> SCALAR setEnumeration(E aValue) throws UnsupportedOperationException, ArithmeticException, IllegalArgumentException, NullPointerException
MutableScalar
enumeration
instance, then answer this object (facilitates
chaining)setEnumeration
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a system-supported enumeration
UnsupportedOperationException
- if this object's value cannot be changedArithmeticException
- the numeric value provided was incompatible with with algebraic
interpretation of this objectIllegalArgumentException
- if the specified value was incommensurate with this object's
specificationNullPointerException
- a null
value was provided though this object does not
accept null
valuespublic SCALAR setFalse() throws UnsupportedOperationException, ArithmeticException
MutableBooleanValue
true
and answer this
object (facilitates chaining)setFalse
in interface MutableBooleanValue<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedArithmeticException
- the new value was incompatible with with algebraic interpretation
of this objectpublic SCALAR setNegativeInfinity() throws UnsupportedOperationException, ArithmeticException, IllegalArgumentException
MutableScalar
minimum
valuesetNegativeInfinity
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectIllegalArgumentException
- if the new value was incommensurate with this object's
specificationpublic SCALAR setNumber(Number aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException, NullPointerException
MutableScalar
Number
and
answer this object (facilitates chaining)setNumber
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a system-supported Number
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the specified value was incommensurate with this object's
specificationArithmeticException
- the numeric value provided was incompatible with with algebraic
interpretation of this objectNullPointerException
- a null
value was provided though this object does not
accept null
valuespublic SCALAR setPi() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
setPi
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR setPositiveInfinity() throws UnsupportedOperationException, ArithmeticException, IllegalArgumentException
MutableScalar
maximum
valuesetPositiveInfinity
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectIllegalArgumentException
- if the new value was incommensurate with this object's
specificationpublic SCALAR setScalar(SealedScalar<?> aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException, NullPointerException
MutableScalar
setScalar
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- a scalarUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the specified value was incommensurate with this object's
specificationArithmeticException
- the numeric value provided was incompatible with with algebraic
interpretation of this objectNullPointerException
- a null
value was provided though this object does not
accept null
valuespublic SCALAR setTrue() throws UnsupportedOperationException, ArithmeticException
MutableBooleanValue
true
and answer this
object (facilitates chaining)setTrue
in interface MutableBooleanValue<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedArithmeticException
- the new value was incompatible with with algebraic interpretation
of this objectpublic SCALAR setUnity() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
setUnity
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR setZero() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
setZero
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR shiftRightExtendZero(int count) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
>>>
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.shiftRightExtendZero
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
count
- the number of values to be removed from the beginning of this
sequenceUnsupportedOperationException
- if this object's value cannot be changed or if this structure is
not an algebraic tupleIllegalArgumentException
- if the specified value was incommensurate with this structure's
specificationArithmeticException
- the numeric value provided was incompatible with with algebraic
interpretation of this structurepublic int signum()
signum
in interface NumericProperties
zero
, -1 if this number
is negative
or +1 if it is
positive
public SCALAR sine() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
sine
sine
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic int size()
SealedAlgebraicStructure
Integer.MAX_VALUE
elements, returns
Integer.MAX_VALUE
.size
in interface SealedAlgebraicStructure
Collection.size()
public SCALAR squareRoot() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
squareRoot
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR sum(boolean aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
sum
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an addendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR sum(byte aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
sum
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an addendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR sum(char aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
sum
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an addendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR sum(double aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
sum
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an addendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR sum(float aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
sum
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an addendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR sum(int aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
sum
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an addendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR sum(long aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
sum
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an addendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR sum(short aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
sum
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an addendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR sumOfNumber(Number aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
sumOfNumber
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an addendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR sumOfScalar(SealedScalar<?> aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
sumOfScalar
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an addendUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR tangent() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
tangent
tangent
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic Character toCharacter()
toCharacter
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
Boolean
objectpublic int toCodePoint()
SealedScalar
toCodePoint
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
public <E extends Enum<E>> E toEnumeration(Class<E> anEnumerationClass) throws ArithmeticException, IllegalArgumentException, NullPointerException
SealedScalar
enumeration
toEnumeration
in interface SealedScalar<SCALAR extends Scalar<SCALAR>>
anEnumerationClass
- the class of enumeration
to convert toArithmeticException
- the numeric value provided was incompatible with with algebraic
interpretation of this objectIllegalArgumentException
- if the specified value was incommensurate with this object's
specificationNullPointerException
- a null
value was provided though this object does not
accept null
valuespublic Scalar<?> toScalar()
ScalarReplicator
scalar
then simply
call its Replicator.copy()
function, otherwise produce a new scalar
with scalar precisiontoScalar
in interface ScalarReplicator<SCALAR extends Scalar<SCALAR>>
public final SCALAR up() throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
up
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
UnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR xor(boolean aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
xor
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR xor(byte aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
xor
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR xor(char aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
xor
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR xor(int aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
xor
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR xor(long aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
xor
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR xor(short aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
xor
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic SCALAR xorOfNumber(Number aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
xorOfNumber
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic final SCALAR xorOfScalar(SealedScalar<?> aValue) throws UnsupportedOperationException, IllegalArgumentException, ArithmeticException
MutableScalar
xorOfScalar
in interface MutableScalar<SCALAR extends Scalar<SCALAR>>
aValue
- an integral boolean vectorUnsupportedOperationException
- if this object's value cannot be changedIllegalArgumentException
- if the new value was incommensurate with this object's
specificationArithmeticException
- the new numeric value was incompatible with with algebraic
interpretation of this objectpublic static final void boundsCheck(int anIndex, int anOrdinalBound) throws IndexOutOfBoundsException
IndexOutOfBoundsException
public static final byte byteMaskAt(int aBitPosition)
public static final byte byteNotMaskAt(int aBitPosition)
public static final byte byteValue(boolean[] aBooleanArray)
public static final char charMaskAt(int aBitPosition)
public static final char charNotMaskAt(int aBitPosition)
public static final char charValue(boolean[] aBooleanArray)
public static final byte clearByteBitAt(int anIndex, byte myValue) throws IndexOutOfBoundsException
IndexOutOfBoundsException
public static final char clearCharBitAt(int anIndex, char myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final double clearDoubleBitAt(int anIndex, double myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final float clearFloatBitAt(int anIndex, float myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final int clearIntBitAt(int anIndex, int myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final long clearLongBitAt(int anIndex, long myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final short clearShortBitAt(int anIndex, short myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final BigDecimal clearUnlimitedDecimalBitAt(int anIndex, BigDecimal myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final BigInteger clearUnlimitedIntegerBitAt(int anIndex, BigInteger myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final int compareTo(BigDecimal p0, BigDecimal p1)
public static final int compareTo(BigInteger p0, BigInteger p1)
public static final int compareTo(boolean p0, boolean p1)
public static final int compareTo(byte p0, byte p1)
public static final int compareTo(char p0, char p1)
public static final int compareTo(CharSequence p0, CharSequence p1)
public static final int compareTo(double p0, double p1)
public static final int compareTo(float p0, float p1)
public static final int compareTo(int p0, int p1)
public static final int compareTo(long p0, long p1)
public static final int compareTo(short p0, short p1)
public static final void divideByZero()
public static final boolean getBooleanBitAt(int anIndex, boolean myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final boolean getByteBitAt(int anIndex, byte myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final boolean getCharBitAt(int anIndex, char myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final boolean getDoubleBitAt(int anIndex, double myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final boolean getFloatBitAt(int anIndex, float myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final boolean getIntBitAt(int anIndex, int myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final boolean getLongBitAt(int anIndex, long myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final boolean getShortBitAt(int anIndex, short myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final boolean getUnlimitedDecimalBitAt(int anIndex, BigDecimal myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final boolean getUnlimitedIntegerBitAt(int anIndex, BigInteger myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final int hashCode(boolean aValue)
public static final int hashCode(byte aValue)
public static final int hashCode(char aValue)
public static final int hashCode(double aValue)
public static final int hashCode(float aValue)
public static final int hashCode(int aValue)
public static final int hashCode(long aValue)
public static final int hashCode(short aValue)
public static final void indexOutOfBoundsAt(int anIndex) throws IndexOutOfBoundsException
IndexOutOfBoundsException
public static final int intGCD(int p0, int p1) throws UnsupportedOperationException, ArithmeticException, IllegalArgumentException
public static final int intMaskAt(int aBitPosition)
public static final int intModularInverse(int p0, int p1)
public static final int intModularQuotient(int aDividend, int aDivisor, int aModulus)
public static final int intNotMaskAt(int aBitPosition)
public static final int intValue(boolean[] aBooleanArray)
public static final long longGCD(long p0, long p1) throws UnsupportedOperationException, ArithmeticException, IllegalArgumentException
public static final long longMaskAt(int aBitPosition)
public static final long longModularInverse(long p0, long p1)
public static final long longModularQuotient(long aDividend, long aDivisor, long aModulus)
public static final long longNotMaskAt(int aBitPosition)
public static final long longValue(boolean[] aBooleanArray)
public static final byte setByteBitAt(int anIndex, byte myValue) throws IndexOutOfBoundsException
IndexOutOfBoundsException
public static final char setCharBitAt(int anIndex, char myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final double setDoubleBitAt(int anIndex, double myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final float setFloatBitAt(int anIndex, float myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final int setIntBitAt(int anIndex, int myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final long setLongBitAt(int anIndex, long myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final short setShortBitAt(int anIndex, short myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final BigDecimal setUnlimitedDecimalBitAt(int anIndex, BigDecimal myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final BigInteger setUnlimitedIntegerBitAt(int anIndex, BigInteger myValue) throws UnsupportedOperationException, IndexOutOfBoundsException
public static final short shortMaskAt(int aBitPosition)
public static final short shortNotMaskAt(int aBitPosition)
public static final short shortValue(boolean[] aBooleanArray)
public static final boolean[] toBooleanArray(BigDecimal aTuple)
public static final boolean[] toBooleanArray(BigInteger aTuple)
public static final boolean[] toBooleanArray(boolean aTuple)
public static final boolean[] toBooleanArray(byte aTuple)
public static final boolean[] toBooleanArray(char aTuple)
public static final boolean[] toBooleanArray(CharSequence aTuple)
public static final boolean[] toBooleanArray(double aTuple)
public static final boolean[] toBooleanArray(float aTuple)
public static final boolean[] toBooleanArray(int aTuple)
public static final boolean[] toBooleanArray(long aTuple)
public static final boolean[] toBooleanArray(short aTuple)
public static final byte[] toByteArray(boolean[] aBooleanArray)
public static final BigInteger toUnlimitedInteger(boolean[] aBooleanArray)
public static final BigInteger unlimitedIntegerMaskAt(int aBitPosition)
public static final BigInteger unlimitedIntegerNotMaskAt(int aBitPosition)
Copyright © 2006-2012 Ware-Squared Software Development. All Rights Reserved.