MutableScalar (Java Accumulators and Variants)

Type Parameters:
SCALAR - this scalar type (used to facilitate operation chaining)

All Superinterfaces:

Mutable, MutableAlgebraicStructure<SCALAR>, MutableBooleanValue<SCALAR>, MutableByteValue<SCALAR>, MutableCharacterValue<SCALAR>, MutableDoubleValue<SCALAR>, MutableFloatValue<SCALAR>, MutableIntegerValue<SCALAR>, MutableKernel<SCALAR>, MutableLongValue<SCALAR>, MutableScalarDomain<SCALAR>, MutableShortValue<SCALAR>

All Known Subinterfaces:

Accumulator<ACCUMULATOR>, MutableAccumulator<ACCUMULATOR>, MutablePrimitive<PRIMITIVE>, MutableReal<REAL>, Primitive<PRIMITIVE>, Real<REAL>, Scalar<SCALAR>

All Known Implementing Classes:

AbstractAccumulator, AbstractBooleanPrimitive, AbstractBytePrimitive, AbstractCharacterPrimitive, AbstractConstant, AbstractConstantAccumulator, AbstractDoublePrimitive, AbstractFloatPrimitive, AbstractIntegerPrimitive, AbstractLongPrimitive, AbstractModuloIntegerPrimitive, AbstractNumericPrimitive, AbstractPrimitive, AbstractPrimitiveWrapper, AbstractReal, AbstractScalar, AbstractShortPrimitive, AbstractSimpleAccumulator, AbstractStickyTarget, AbstractTextPrimitive, AbstractUnlimitedDecimalPrimitive, AbstractUnlimitedIntegerPrimitive, BooleanArrayCursor, BooleanPrimitive, ByteArrayCursor, BytePrimitive, CharacterArrayCursor, CharacterPrimitive, Constant, ConstantAccumulator, DoublePrimitive, EnumerationPrimitive, FloatPrimitive, GaussianRandomPrimitive, IntegerPrimitive, LongPrimitive, Milliseconds, ModuloIntegerPrimitive, Nanoseconds, RandomPrimitive, ShortPrimitive, SimpleAccumulator, TextPrimitive, UnlimitedDecimalPrimitive, UnlimitedIntegerPrimitive, Variant
```
public interface MutableScalar<SCALAR extends MutableScalar<SCALAR>>
extends MutableScalarDomain<SCALAR>, MutableKernel<SCALAR>, MutableBooleanValue<SCALAR>, MutableByteValue<SCALAR>, MutableCharacterValue<SCALAR>, MutableDoubleValue<SCALAR>, MutableFloatValue<SCALAR>, MutableIntegerValue<SCALAR>, MutableLongValue<SCALAR>, MutableShortValue<SCALAR>
```
Write operations for all system supported "scalar" values, or binary vectors optimized for processing and generally participate in arithmetic operators supported by the host programming language

Since:

JAccumulator 4.0

Author:

Nicole Tedesco (Nicole@NicoleTedesco.com)

Method Summary

Methods
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 y)` 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<?> y)` 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`	`base10Log()` Replace the current value with its base 10 logarithm
`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
`SCALAR`	`cosine()` Replace the current value, assumed to be an angle in radians, to its `cosine`
`SCALAR`	`cube()` Replace the current value with the cube of itself
`SCALAR`	`cubeRoot()` Replace the current value with the cube root of itself
`SCALAR`	`decrement()` Replace the current value with the current value minus unity (one)
`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
`SCALAR`	`down()` Round the current value towards zero (truncate)
`SCALAR`	`exponential()` Replace the current value with e (Napier's constant) raised to the current value (eⁿ)
`SCALAR`	`exponentialLessOne()` Replace the current value with e (Napier's constant) raised to the current value, less 1 (eⁿ-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 aNumber)` 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
`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
`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 y)` 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 y)` 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<?> y)` 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`	`increment()` Replace the current value with the current value plus unity (one)
`SCALAR`	`invalidate()` Replace the current value an invalid value such `INVALID` if possible, otherwise replace it with zero
`SCALAR`	`inverse()` Replace the current value its multiplicative inverse (`1/x`)
`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 aValue)` 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 (log_e(`n`))
`SCALAR`	`naturalLogPlusOne()` Replace the current value, plus 1, with its base e (Napier's constant) logarithm (log_e(`n`+1))
`SCALAR`	`negate()` Replace the current value with the additive inverse (sign negation) of itself, that is transform it into a number that when added to the original yields zero.
`SCALAR`	`not()` Replace the current integral binary vector with its one's complement.
`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 xⁿ
`SCALAR`	`power(int n)` Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
`SCALAR`	`powerOfNumber(Number n)` Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
`SCALAR`	`powerOfScalar(SealedScalar<?> aValue)` Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
`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`	`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)
`SCALAR`	`round(RoundingStrategy aRoundingStrategy)` Round the current value using the specified rounding `strategy`
`SCALAR`	`setE()` Replace the current value with e, or Napier's constant
`<E extends Enum<E>> SCALAR`	`setEnumeration(E aValue)` Match the value of this object with the identity of the specified `enumeration` instance, then answer this object (facilitates chaining)
`SCALAR`	`setMaximum()` Replace the current value with maximum value available for the implementation's numeric `precision`.
`SCALAR`	`setMinimum()` Replace the current value with minimum value available for the implementation's numeric `precision`.
`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
`SCALAR`	`setUnity()` Replace the current value with the multiplicative identity appropriate for the implementation (one)
`SCALAR`	`setZero()` Replace the current value with the additive identity appropriate for the implementation (zero)
`SCALAR`	`shiftLeft(int count)` Attempt to shift the elements of this tuple to the "left" the specified number of ordinal positions.
`SCALAR`	`shiftRight(int count)` Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions.
`SCALAR`	`shiftRightExtendZero(int count)` Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions without sign extension.
`SCALAR`	`sine()` Replace the current value, assumed to be an angle in radians, to its `sine`
`SCALAR`	`square()` Replace the current value with the square of itself
`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`
`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

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

Methods inherited from interface net.sf.jaccumulator.MutableAlgebraicStructure
assertDomain, clear, clearContents

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

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

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

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

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

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

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

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

- Method Detail
  - absoluteValue
```
SCALAR absoluteValue()
                                                   throws UnsupportedOperationException,
                                                          ArithmeticException,
                                                          IllegalArgumentException
```
    Replace the current value with the absolute value of itself
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - and
```
SCALAR and(boolean aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - and
```
SCALAR and(byte aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - and
```
SCALAR and(char aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - and
```
SCALAR and(int aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - and
```
SCALAR and(long aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - and
```
SCALAR and(short aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - andOfNumber
```
SCALAR andOfNumber(Number aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - andOfScalar
```
SCALAR andOfScalar(SealedScalar<?> aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - angleWith
```
SCALAR angleWith(double y)
                                               throws UnsupportedOperationException,
                                                      IllegalArgumentException,
                                                      ArithmeticException
```
    Set this value to the angle formed by the rectangular coordinates given by the current value, x, and the specified value, y. In other words returns the angle theta from the conversion of rectangular coordinates (x,y) to polar coordinates (r,theta).
    
    Parameters:
    y - a y coordinate value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    Math.atan2(double, double)
  - angleWithNumber
```
SCALAR angleWithNumber(Number y)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException
```
    Set this value to the angle formed by the rectangular coordinates given by the current value, x, and the specified value, y. In other words returns the angle theta from the conversion of rectangular coordinates (x,y) to polar coordinates (r,theta).
    
    Parameters:
    y - a y coordinate value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    Math.atan2(double, double)
  - angleWithScalar
```
SCALAR angleWithScalar(SealedScalar<?> y)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException
```
    Set this value to the angle formed by the rectangular coordinates given by the current value, x, and the specified value, y. In other words returns the angle theta from the conversion of rectangular coordinates (x,y) to polar coordinates (r,theta).
    
    Parameters:
    y - a y coordinate value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    Math.atan2(double, double)
  - arcCosine
```
SCALAR arcCosine()
                                               throws UnsupportedOperationException,
                                                      IllegalArgumentException,
                                                      ArithmeticException
```
    Replace the current value with its arc cosine
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - arcSine
```
SCALAR arcSine()
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Replace the current value with its arc sine
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - arcTangent
```
SCALAR arcTangent()
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Replace the current value with its arc tangent
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - base10Log
```
SCALAR base10Log()
                                               throws UnsupportedOperationException,
                                                      IllegalArgumentException,
                                                      ArithmeticException
```
    Replace the current value with its base 10 logarithm
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - ceiling
```
SCALAR ceiling()
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    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
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - cosine
```
SCALAR cosine()
                                            throws UnsupportedOperationException,
                                                   IllegalArgumentException,
                                                   ArithmeticException
```
    Replace the current value, assumed to be an angle in radians, to its cosine
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - cube
```
SCALAR cube()
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Replace the current value with the cube of itself
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - cubeRoot
```
SCALAR cubeRoot()
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Replace the current value with the cube root of itself
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - decrement
```
SCALAR decrement()
                                               throws UnsupportedOperationException,
                                                      IllegalArgumentException,
                                                      ArithmeticException
```
    Replace the current value with the current value minus unity (one)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - degrees
```
SCALAR degrees()
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Replace the current value, assumed to be an angle in radians, to its equivalent angle in degrees
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
SCALAR difference(boolean aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
SCALAR difference(byte aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
SCALAR difference(char aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
SCALAR difference(double aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
SCALAR difference(float aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
SCALAR difference(int aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
SCALAR difference(long aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - difference
```
SCALAR difference(short aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - differenceOfNumber
```
SCALAR differenceOfNumber(Number aValue)
                                                        throws UnsupportedOperationException,
                                                               IllegalArgumentException,
                                                               ArithmeticException
```
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - differenceOfScalar
```
SCALAR differenceOfScalar(SealedScalar<?> aValue)
                                                        throws UnsupportedOperationException,
                                                               IllegalArgumentException,
                                                               ArithmeticException
```
    Set the value of this scalar to the mathematical difference between its current value and the specified value
    
    Parameters:
    aValue - a subtrahend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - down
```
SCALAR down()
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Round the current value towards zero (truncate)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - exponential
```
SCALAR exponential()
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Replace the current value with e (Napier's constant) raised to the current value (eⁿ)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    e (Wikipedia)
  - exponentialLessOne
```
SCALAR exponentialLessOne()
                                                        throws UnsupportedOperationException,
                                                               IllegalArgumentException,
                                                               ArithmeticException
```
    Replace the current value with e (Napier's constant) raised to the current value, less 1 (eⁿ-1)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    e (Wikipedia)
  - floor
```
SCALAR floor()
                                           throws UnsupportedOperationException,
                                                  IllegalArgumentException,
                                                  ArithmeticException
```
    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
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - gcd
```
SCALAR gcd(byte aValue)
                                         throws UnsupportedOperationException,
                                                ArithmeticException,
                                                IllegalArgumentException
```
    Replace the current value with the greatest common factor between this value and the specific one
    
    Parameters:
    aValue - a value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - gcd
```
SCALAR gcd(char aValue)
                                         throws UnsupportedOperationException,
                                                ArithmeticException,
                                                IllegalArgumentException
```
    Replace the current value with the greatest common factor between this value and the specific one
    
    Parameters:
    aValue - a value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - gcd
```
SCALAR gcd(int aValue)
                                         throws UnsupportedOperationException,
                                                ArithmeticException,
                                                IllegalArgumentException
```
    Replace the current value with the greatest common factor between this value and the specific one
    
    Parameters:
    aValue - a value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - gcd
```
SCALAR gcd(long aValue)
                                         throws UnsupportedOperationException,
                                                ArithmeticException,
                                                IllegalArgumentException
```
    Replace the current value with the greatest common factor between this value and the specific one
    
    Parameters:
    aValue - a value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - gcd
```
SCALAR gcd(short aValue)
                                         throws UnsupportedOperationException,
                                                ArithmeticException,
                                                IllegalArgumentException
```
    Replace the current value with the greatest common factor between this value and the specific one
    
    Parameters:
    aValue - a value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - gcdOfNumber
```
SCALAR gcdOfNumber(Number aNumber)
                                                 throws UnsupportedOperationException,
                                                        ArithmeticException,
                                                        IllegalArgumentException
```
    Replace the current value with the greatest common factor between this value and the specific one
    
    Parameters:
    aValue - a value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - gcdOfScalar
```
SCALAR gcdOfScalar(Scalar<?> aScalar)
                                                 throws UnsupportedOperationException,
                                                        ArithmeticException,
                                                        IllegalArgumentException
```
    Replace the current value with the greatest common factor between this value and the specific one
    
    Parameters:
    aValue - a value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - halfDown
```
SCALAR halfDown()
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Round towards "nearest neighbor" unless both neighbors are equidistant, in which case round down
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - halfEven
```
SCALAR halfEven()
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Round towards "nearest neighbor" unless both neighbors are equidistant, in which case round to the even neighbor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - halfUp
```
SCALAR halfUp()
                                            throws UnsupportedOperationException,
                                                   IllegalArgumentException,
                                                   ArithmeticException
```
    Round towards "nearest neighbor" unless both neighbors are equidistant, in which case round up
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - hyperbolicCosine
```
SCALAR hyperbolicCosine()
                                                      throws UnsupportedOperationException,
                                                             IllegalArgumentException,
                                                             ArithmeticException
```
    Replace the current value, assumed to be an angle in radians, to its hyperbolic cosine
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - hyperbolicSine
```
SCALAR hyperbolicSine()
                                                    throws UnsupportedOperationException,
                                                           IllegalArgumentException,
                                                           ArithmeticException
```
    Replace the current value, assumed to be an angle in radians, to its hyperbolic sine
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - hyperbolicTangent
```
SCALAR hyperbolicTangent()
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Replace the current value, assumed to be an angle in radians, to its hyperbolic tangent
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - hypotenuseWith
```
SCALAR hypotenuseWith(double y)
                                                    throws UnsupportedOperationException,
                                                           IllegalArgumentException,
                                                           ArithmeticException
```
    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
    
    Parameters:
    y - a y value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    Math.hypot(double, double)
  - hypotenuseWithNumber
```
SCALAR hypotenuseWithNumber(Number y)
                                                          throws UnsupportedOperationException,
                                                                 IllegalArgumentException,
                                                                 ArithmeticException
```
    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
    
    Parameters:
    y - a y value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    Math.hypot(double, double)
  - hypotenuseWithScalar
```
SCALAR hypotenuseWithScalar(SealedScalar<?> y)
                                                          throws UnsupportedOperationException,
                                                                 IllegalArgumentException,
                                                                 ArithmeticException
```
    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
    
    Parameters:
    y - a y value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    Math.hypot(double, double)
  - increment
```
SCALAR increment()
                                               throws UnsupportedOperationException,
                                                      ArithmeticException,
                                                      IllegalArgumentException
```
    Replace the current value with the current value plus unity (one)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - invalidate
```
SCALAR invalidate()
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Replace the current value an invalid value such INVALID if possible, otherwise replace it with zero
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - inverse
```
SCALAR inverse()
                                             throws UnsupportedOperationException,
                                                    ArithmeticException,
                                                    IllegalArgumentException
```
    Replace the current value its multiplicative inverse (1/x)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - milliseconds
```
SCALAR milliseconds()
                                                  throws UnsupportedOperationException
```
    Set the value of this object to the current millisecond-precision system time
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
  - mod
```
SCALAR mod(boolean aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to its current value modulo of the specified value
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
SCALAR mod(byte aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to its current value modulo of the specified value
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
SCALAR mod(char aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to its current value modulo of the specified value
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
SCALAR mod(double aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to its current value modulo of the specified value
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
SCALAR mod(float aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to its current value modulo of the specified value
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
SCALAR mod(int aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to its current value modulo of the specified value
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
SCALAR mod(long aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to its current value modulo of the specified value
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - mod
```
SCALAR mod(short aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to its current value modulo of the specified value
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - modOfNumber
```
SCALAR modOfNumber(Number aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Set the value of this scalar to its current value modulo of the specified value
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - modOfScalar
```
SCALAR modOfScalar(SealedScalar<?> aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Set the value of this scalar to its current value modulo of the specified value
    
    Parameters:
    aValue - a modulus
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - nanoseconds
```
SCALAR nanoseconds()
                                                 throws UnsupportedOperationException
```
    Set the value of this object to the current nanosecond-precision system time
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
  - naturalLog
```
SCALAR naturalLog()
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Replace the current value with its base e (Napier's constant) logarithm (log_e(n))
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    e (Wikipedia)
  - naturalLogPlusOne
```
SCALAR naturalLogPlusOne()
                                                       throws UnsupportedOperationException,
                                                              IllegalArgumentException,
                                                              ArithmeticException
```
    Replace the current value, plus 1, with its base e (Napier's constant) logarithm (log_e(n+1))
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    e (Wikipedia)
  - negate
```
SCALAR negate()
                                            throws UnsupportedOperationException,
                                                   ArithmeticException,
                                                   IllegalArgumentException
```
    Replace the current value with the additive inverse (sign negation) of itself, that is transform it into a number that when added to the original yields zero. (Though additive inverses for non-zero boolean and char values do not exist, these implementations will simply fail silently.)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification (optional)
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object (optional)
  - not
```
SCALAR not()
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Replace the current integral binary vector with its one's complement. Decimal values, such as double, will be first converted to unlimited integers before their bits are reversed.
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - or
```
SCALAR or(boolean aValue)
                                        throws UnsupportedOperationException,
                                               IllegalArgumentException,
                                               ArithmeticException
```
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - or
```
SCALAR or(byte aValue)
                                        throws UnsupportedOperationException,
                                               IllegalArgumentException,
                                               ArithmeticException
```
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - or
```
SCALAR or(char aValue)
                                        throws UnsupportedOperationException,
                                               IllegalArgumentException,
                                               ArithmeticException
```
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - or
```
SCALAR or(int aValue)
                                        throws UnsupportedOperationException,
                                               IllegalArgumentException,
                                               ArithmeticException
```
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - or
```
SCALAR or(long aValue)
                                        throws UnsupportedOperationException,
                                               IllegalArgumentException,
                                               ArithmeticException
```
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - or
```
SCALAR or(short aValue)
                                        throws UnsupportedOperationException,
                                               IllegalArgumentException,
                                               ArithmeticException
```
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - orOfNumber
```
SCALAR orOfNumber(Number aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - orOfScalar
```
SCALAR orOfScalar(SealedScalar<?> aValue)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - power
```
SCALAR power(double n)
                                           throws UnsupportedOperationException,
                                                  IllegalArgumentException,
                                                  ArithmeticException
```
    Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
    
    Parameters:
    n - an exponent
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - power
```
SCALAR power(int n)
                                           throws UnsupportedOperationException,
                                                  IllegalArgumentException,
                                                  ArithmeticException
```
    Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
    
    Parameters:
    n - an exponent
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - powerOfNumber
```
SCALAR powerOfNumber(Number n)
                                                   throws UnsupportedOperationException,
                                                          IllegalArgumentException,
                                                          ArithmeticException
```
    Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
    
    Parameters:
    n - an exponent
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - powerOfScalar
```
SCALAR powerOfScalar(SealedScalar<?> aValue)
                                                   throws UnsupportedOperationException,
                                                          IllegalArgumentException,
                                                          ArithmeticException
```
    Set this value to the current value, x, raised to the specified exponent, n, or xⁿ
    
    Parameters:
    aValue - an exponent
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
SCALAR product(boolean aValue)
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
SCALAR product(byte aValue)
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
SCALAR product(char aValue)
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
SCALAR product(double aValue)
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
SCALAR product(float aValue)
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
SCALAR product(int aValue)
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
SCALAR product(long aValue)
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - product
```
SCALAR product(short aValue)
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - productOfNumber
```
SCALAR productOfNumber(Number aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException
```
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - productOfScalar
```
SCALAR productOfScalar(SealedScalar<?> aValue)
                                                     throws UnsupportedOperationException,
                                                            IllegalArgumentException,
                                                            ArithmeticException
```
    Set the value of this scalar to the mathematical product of its current value and the specified value
    
    Parameters:
    aValue - a multiplicand
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
SCALAR quotient(boolean aValue)
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Set the value of this scalar to the mathematical quotient between its current value and the specified value
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
SCALAR quotient(byte aValue)
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
SCALAR quotient(char aValue)
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Set the value of this scalar to the mathematical quotient between its current value and the specified value
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
SCALAR quotient(double aValue)
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
SCALAR quotient(float aValue)
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
SCALAR quotient(int aValue)
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
SCALAR quotient(long aValue)
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotient
```
SCALAR quotient(short aValue)
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotientOfNumber
```
SCALAR quotientOfNumber(Number aValue)
                                                      throws UnsupportedOperationException,
                                                             IllegalArgumentException,
                                                             ArithmeticException
```
    Set the value of this scalar to the mathematical quotient of its current value and the specified value
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - quotientOfScalar
```
SCALAR quotientOfScalar(SealedScalar<?> aValue)
                                                      throws UnsupportedOperationException,
                                                             IllegalArgumentException,
                                                             ArithmeticException
```
    Set the value of this scalar to the mathematical quotient between its current value and the specified value
    
    Parameters:
    aValue - a divisor
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - radians
```
SCALAR radians()
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Replace the current value, assumed to be an angle in degrees, to its equivalent angle in radians
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - random
```
SCALAR random()
                                            throws UnsupportedOperationException
```
    Replace the current value with an evenly-distributed random value between zero (inclusive) and unity (exclusive for floating point, inclusive for integrals)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
  - round
```
SCALAR round(RoundingStrategy aRoundingStrategy)
                                           throws UnsupportedOperationException,
                                                  IllegalArgumentException,
                                                  ArithmeticException,
                                                  NullPointerException
```
    Round the current value using the specified rounding strategy
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    
    NullPointerException
  - setE
```
SCALAR setE()
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Replace the current value with e, or Napier's constant
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
    See Also:
    e (Wikipedia)
  - setEnumeration
```
<E extends Enum<E>> SCALAR setEnumeration(E aValue)
                                                    throws UnsupportedOperationException,
                                                           ArithmeticException,
                                                           IllegalArgumentException,
                                                           NullPointerException
```
    Match the value of this object with the identity of the specified enumeration instance, then answer this object (facilitates chaining)
    
    Parameters:
    aValue - a system-supported enumeration
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setMaximum
```
SCALAR setMaximum()
                                                throws UnsupportedOperationException,
                                                       ArithmeticException,
                                                       IllegalArgumentException
```
    Replace the current value with maximum value available for the implementation's numeric precision. Unlimited values will be replaced with the maximum value available for the most precise system scalar appropriate for the implementation, that is unlimited integer primitives will set themselves to the maximum long value and unlimited decimal primitives will set themselves to the maximum double value.
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - setMinimum
```
SCALAR setMinimum()
                                                throws UnsupportedOperationException,
                                                       ArithmeticException,
                                                       IllegalArgumentException
```
    Replace the current value with minimum value available for the implementation's numeric precision. Unlimited values will be replaced with the minimum value available for the most precise system scalar appropriate for the implementation, that is unlimited integer primitives will set themselves to the minimum long value and unlimited decimal primitives will set themselves to the minimum double value.
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - setNegativeInfinity
```
SCALAR setNegativeInfinity()
                                                         throws UnsupportedOperationException,
                                                                ArithmeticException,
                                                                IllegalArgumentException
```
    Replace the current value with a representation of negative infinity, if available, otherwise replace with the implementation's minimum value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - setNumber
```
SCALAR setNumber(Number aValue)
                                               throws UnsupportedOperationException,
                                                      IllegalArgumentException,
                                                      ArithmeticException,
                                                      NullPointerException
```
    Set this object to the specified system-supported Number and answer this object (facilitates chaining)
    
    Parameters:
    aValue - a system-supported Number
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setPi
```
SCALAR setPi()
                                           throws UnsupportedOperationException,
                                                  IllegalArgumentException,
                                                  ArithmeticException
```
    Replace the current value with Pi
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - setPositiveInfinity
```
SCALAR setPositiveInfinity()
                                                         throws UnsupportedOperationException,
                                                                IllegalArgumentException,
                                                                ArithmeticException
```
    Replace the current value with a representation of positive infinity, if available, otherwise replace with the implementation's maximum value
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - setScalar
```
SCALAR setScalar(SealedScalar<?> aValue)
                                               throws UnsupportedOperationException,
                                                      IllegalArgumentException,
                                                      ArithmeticException,
                                                      NullPointerException
```
    Set this object to the specified scalar
    
    Parameters:
    aValue - a scalar
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the specified value was incommensurate with this object's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object
    
    NullPointerException - a null value was provided though this object does not accept null values
  - setUnity
```
SCALAR setUnity()
                                              throws UnsupportedOperationException,
                                                     IllegalArgumentException,
                                                     ArithmeticException
```
    Replace the current value with the multiplicative identity appropriate for the implementation (one)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - setZero
```
SCALAR setZero()
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Replace the current value with the additive identity appropriate for the implementation (zero)
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - shiftLeft
```
SCALAR shiftLeft(int count)
                                               throws UnsupportedOperationException,
                                                      IllegalArgumentException,
                                                      ArithmeticException
```
    Attempt to shift the elements of this tuple to the "left" the specified number of ordinal positions. In a bit sequence this functions resorts to the familiar "left shift" process (e.g., Java <<). In other sequences, the specified number of default values will be prepended to the beginning of the sequence, increasing the ordinal position of all existing elements by the specified count.
    
    Parameters:
    count - the number of default values to be prepended to this sequence
    
    Returns:
    this structure (facilitates chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed or if this structure is not an algebraic tuple
    
    IllegalArgumentException - if the specified value was incommensurate with this structure's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this structure
  - shiftRight
```
SCALAR shiftRight(int count)
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions. In a bit sequence this functions resorts to the familiar "right shift" process, with sign extension (e.g., the Java >> operator). In other sequences, the specified number of values will be removed from the beginning of the sequence, decreasing the ordinal position of all remaining elements by the specified count.
    
    Parameters:
    count - the number of values to be removed from the beginning of this sequence
    
    Returns:
    this structure (facilitates chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed or if this structure is not an algebraic tuple
    
    IllegalArgumentException - if the specified value was incommensurate with this structure's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this structure
  - shiftRightExtendZero
```
SCALAR shiftRightExtendZero(int count)
                                                          throws UnsupportedOperationException,
                                                                 IllegalArgumentException,
                                                                 ArithmeticException
```
    Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions without sign extension. In a bit sequence this functions resorts to the familiar "right shift" process, with zero extension (e.g., the Java >>> operator). In other sequences, the specified number of values will be removed from the beginning of the sequence, decreasing the ordinal position of all remaining elements by the specified count.
    
    Parameters:
    count - the number of values to be removed from the beginning of this sequence
    
    Returns:
    this structure (facilitates chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed or if this structure is not an algebraic tuple
    
    IllegalArgumentException - if the specified value was incommensurate with this structure's specification
    
    ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this structure
  - sine
```
SCALAR sine()
                                          throws UnsupportedOperationException,
                                                 IllegalArgumentException,
                                                 ArithmeticException
```
    Replace the current value, assumed to be an angle in radians, to its sine
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - square
```
SCALAR square()
                                            throws UnsupportedOperationException,
                                                   IllegalArgumentException,
                                                   ArithmeticException
```
    Replace the current value with the square of itself
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - squareRoot
```
SCALAR squareRoot()
                                                throws UnsupportedOperationException,
                                                       IllegalArgumentException,
                                                       ArithmeticException
```
    Replace the current value with the square root of itself
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
SCALAR sum(boolean aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
SCALAR sum(byte aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
SCALAR sum(char aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
SCALAR sum(double aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
SCALAR sum(float aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
SCALAR sum(int aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
SCALAR sum(long aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sum
```
SCALAR sum(short aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sumOfNumber
```
SCALAR sumOfNumber(Number aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - sumOfScalar
```
SCALAR sumOfScalar(SealedScalar<?> aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Set the value of this scalar to the mathematical sum of its current value and the specified value
    
    Parameters:
    aValue - an addend
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - tangent
```
SCALAR tangent()
                                             throws UnsupportedOperationException,
                                                    IllegalArgumentException,
                                                    ArithmeticException
```
    Replace the current value, assumed to be an angle in radians, to its tangent
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - up
```
SCALAR up()
                                        throws UnsupportedOperationException,
                                               IllegalArgumentException,
                                               ArithmeticException
```
    Round away from zero
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
SCALAR xor(boolean aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
SCALAR xor(byte aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
SCALAR xor(char aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
SCALAR xor(int aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
SCALAR xor(long aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xor
```
SCALAR xor(short aValue)
                                         throws UnsupportedOperationException,
                                                IllegalArgumentException,
                                                ArithmeticException
```
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xorOfNumber
```
SCALAR xorOfNumber(Number aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object
  - xorOfScalar
```
SCALAR xorOfScalar(SealedScalar<?> aValue)
                                                 throws UnsupportedOperationException,
                                                        IllegalArgumentException,
                                                        ArithmeticException
```
    Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector
    
    Parameters:
    aValue - an integral boolean vector
    
    Returns:
    this object (facilitates operation chaining)
    
    Throws:
    
    UnsupportedOperationException - if this object's value cannot be changed
    
    IllegalArgumentException - if the new value was incommensurate with this object's specification
    
    ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

Interface MutableScalar<SCALAR extends MutableScalar<SCALAR>>

Method Summary

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

Methods inherited from interface net.sf.jaccumulator.MutableAlgebraicStructure

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

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

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

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

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

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

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

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

Method Detail

absoluteValue

and

and

and

and

and

and

andOfNumber

andOfScalar

angleWith

angleWithNumber

angleWithScalar

arcCosine

arcSine

arcTangent

base10Log

ceiling

cosine

cube

cubeRoot

decrement

degrees

difference

difference

difference

difference

difference

difference

difference

difference

differenceOfNumber

differenceOfScalar

down

exponential

exponentialLessOne

floor

gcd

gcd

gcd

gcd

gcd

gcdOfNumber

gcdOfScalar

halfDown

halfEven

halfUp

hyperbolicCosine

hyperbolicSine

hyperbolicTangent

hypotenuseWith

hypotenuseWithNumber

hypotenuseWithScalar

increment

invalidate

inverse

milliseconds

mod

mod

mod

mod

mod

mod

mod

mod

modOfNumber

modOfScalar

nanoseconds