Value (uk.co.strangeskies)

java.lang.Object
- java.lang.Number
- - uk.co.strangeskies.mathematics.values.Value<S>

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<Value<?>>, CopyDecouplingExpression<S>, Expression<S>, SelfExpression<S>, Addable<S,Value<?>>, Incrementable<S>, Multipliable<S,Value<?>>, Negatable<S,S>, Scalable<S>, Subtractable<S,Value<?>>, Copyable<S>, Self<S>

Direct Known Subclasses:

ContinuousValue, Fraction, IntegralValue
```
public abstract class Value<S extends Value<S>>
extends java.lang.Number
implements Multipliable<S,Value<?>>, Subtractable<S,Value<?>>, Negatable<S,S>, Scalable<S>, Incrementable<S>, Self<S>, SelfExpression<S>, Copyable<S>, java.lang.Comparable<Value<?>>, CopyDecouplingExpression<S>
```
See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description

Value()

Value(java.lang.Number value)

Value(Value<?> value)

Constructors
Constructor and Description
`Value()`
`Value(java.lang.Number value)`
`Value(Value<?> value)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`compareTo(Value<?> other)`
`abstract int`	`compareToAtSupportedPrecision(Value<?> other)`
`abstract S`	`divide(Value<?> value)`
`abstract double`	`doubleValue()`
`abstract boolean`	`equals(double value)`
`abstract boolean`	`equals(float value)`
`abstract boolean`	`equals(int value)`
`abstract boolean`	`equals(long value)`
`abstract boolean`	`equals(java.lang.Object that)`
`protected abstract boolean`	`equals(Value<?> that)`
`abstract S`	`exponentiate(Value<?> exponential)`
`abstract float`	`floatValue()`
`abstract double`	`getDividedPrimitive(double value)`
`abstract float`	`getDividedPrimitive(float value)`
`abstract int`	`getDividedPrimitive(int value)`
`abstract long`	`getDividedPrimitive(long value)`
`S`	`getExponentiated(Value<?> exponential)`
`S`	`getModulus()`
`S`	`getMultiplied(Value<?> value)`
`abstract double`	`getMultipliedPrimitive(double value)`
`abstract float`	`getMultipliedPrimitive(float value)`
`abstract int`	`getMultipliedPrimitive(int value)`
`abstract long`	`getMultipliedPrimitive(long value)`
`S`	`getReciprocal()`
`S`	`getRoot(Value<?> root)`
`S`	`getSquared()`
`S`	`getSquareRoot()`
`S`	`getValue()` This should always return the correct current value for this Expression.
`abstract int`	`intValue()`
`Observable<Expression<? extends S>>`	`invalidations()`
`abstract long`	`longValue()`
`static <S extends Value<S>> S`	`maximum(S first, S second)`
`static <S extends Value<S>> S`	`minimum(S first, S second)`
`abstract S`	`modulus()`
`abstract S`	`multiply(Value<?> value)`
`abstract S`	`negate()`
`protected void`	`postUpdate()`
`abstract S`	`reciprocate()`
`abstract S`	`root(Value<?> root)`
`abstract S`	`setValue(java.lang.Number value)`
`abstract S`	`square()`
`abstract S`	`squareRoot()`
`abstract java.lang.String`	`toString()`
`abstract S`	`unitInTheLastPlaceAbove()`
`abstract S`	`unitInTheLastPlaceBelow()`
`S`	`unitInTheLastPlaceLarger()`
`S`	`unitInTheLastPlaceSmaller()`
`protected void`	`update()`

Methods inherited from class java.lang.Number
byteValue, shortValue

Methods inherited from class java.lang.Object
clone, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface uk.co.strangeskies.mathematics.operation.Subtractable
getSubtracted, subtract

Methods inherited from interface uk.co.strangeskies.mathematics.operation.Addable
add, getAdded

Methods inherited from interface uk.co.strangeskies.utility.Copyable
copy, deepCopy

Methods inherited from interface uk.co.strangeskies.utility.Self
getThis

Methods inherited from interface uk.co.strangeskies.mathematics.operation.Negatable
getNegated

Methods inherited from interface uk.co.strangeskies.mathematics.operation.Scalable
divide, divide, divide, divide, getDivided, getDivided, getDivided, getDivided, getDivided, getMultiplied, getMultiplied, getMultiplied, getMultiplied, multiply, multiply, multiply, multiply

Methods inherited from interface uk.co.strangeskies.mathematics.operation.Incrementable
decrement, getDecremented, getIncremented, increment

Methods inherited from interface uk.co.strangeskies.expression.CopyDecouplingExpression
decoupleValue

Methods inherited from interface uk.co.strangeskies.expression.Expression
anonymize, immutable, over, over

- Constructor Detail
  - Value
```
public Value()
```
  - Value
```
public Value(java.lang.Number value)
```
  - Value
```
public Value(Value<?> value)
```
- Method Detail
  - compareTo
```
public int compareTo(Value<?> other)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<Value<?>>
  - negate
```
public abstract S negate()
```
    Specified by:
    
    negate in interface Negatable<S extends Value<S>,S extends Value<S>>
  - reciprocate
```
public abstract S reciprocate()
```
  - getReciprocal
```
public S getReciprocal()
```
  - getMultiplied
```
public final S getMultiplied(Value<?> value)
```
    Specified by:
    
    getMultiplied in interface Multipliable<S extends Value<S>,Value<?>>
    
    Specified by:
    
    getMultiplied in interface Scalable<S extends Value<S>>
  - toString
```
public abstract java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - setValue
```
public abstract S setValue(java.lang.Number value)
```
  - equals
```
public abstract boolean equals(java.lang.Object that)
```
    Overrides:
    
    equals in class java.lang.Object
  - equals
```
protected abstract boolean equals(Value<?> that)
```
  - unitInTheLastPlaceAbove
```
public abstract S unitInTheLastPlaceAbove()
```
  - unitInTheLastPlaceBelow
```
public abstract S unitInTheLastPlaceBelow()
```
  - unitInTheLastPlaceLarger
```
public final S unitInTheLastPlaceLarger()
```
  - unitInTheLastPlaceSmaller
```
public final S unitInTheLastPlaceSmaller()
```
  - maximum
```
public static <S extends Value<S>> S maximum(S first,
                                             S second)
```
  - minimum
```
public static <S extends Value<S>> S minimum(S first,
                                             S second)
```
  - getValue
```
public final S getValue()
```
    Description copied from interface: Expression
    
    This should always return the correct current value for this Expression. Be careful to remember that the reference returned should not be able to mutate this Expression, i.e. it should be either an immutable class, a const reference, or a copy of the underlying value. This is important, but conversely it does not mean that the return value can necessarily be relied upon not to not mutate when this expression is updated, unless a read lock is held.
    Once a value has been returned, it is up to the implementing Expression as to whether the value will be reliable such that it will remain the same even if the conceptual value of this expression subsequently changes, or whether it will update automatically with the expression. Please only rely on either behavior if it is explicitly documented, otherwise use Expression.decoupleValue() if you need a persistent reference which is safe to mutate and/or safe from external mutation.
    The observers should only ever be notified of an update from the thread which has the write lock on an Expression, and Expressions should be careful to only notify observers when they are in a state where their value can be fetched. Immediate fetch is discouraged, though. Expressions should generally update lazily, not eagerly.
    
    Specified by:
    
    getValue in interface Expression<S extends Value<S>>
    
    Returns:
    
    The fully evaluated value of this Expression at the time of method invocation.
  - update
```
protected final void update()
```
  - postUpdate
```
protected final void postUpdate()
```
  - invalidations
```
public Observable<Expression<? extends S>> invalidations()
```
    Specified by:
    
    invalidations in interface Expression<S extends Value<S>>
  - multiply
```
public abstract S multiply(Value<?> value)
```
    Specified by:
    
    multiply in interface Multipliable<S extends Value<S>,Value<?>>
    
    Specified by:
    
    multiply in interface Scalable<S extends Value<S>>
  - divide
```
public abstract S divide(Value<?> value)
```
    Specified by:
    
    divide in interface Scalable<S extends Value<S>>
  - equals
```
public abstract boolean equals(double value)
```
  - equals
```
public abstract boolean equals(float value)
```
  - equals
```
public abstract boolean equals(int value)
```
  - equals
```
public abstract boolean equals(long value)
```
  - compareToAtSupportedPrecision
```
public abstract int compareToAtSupportedPrecision(Value<?> other)
```
  - getMultipliedPrimitive
```
public abstract int getMultipliedPrimitive(int value)
```
  - getMultipliedPrimitive
```
public abstract long getMultipliedPrimitive(long value)
```
  - getMultipliedPrimitive
```
public abstract float getMultipliedPrimitive(float value)
```
  - getMultipliedPrimitive
```
public abstract double getMultipliedPrimitive(double value)
```
  - getDividedPrimitive
```
public abstract int getDividedPrimitive(int value)
```
  - getDividedPrimitive
```
public abstract long getDividedPrimitive(long value)
```
  - getDividedPrimitive
```
public abstract float getDividedPrimitive(float value)
```
  - getDividedPrimitive
```
public abstract double getDividedPrimitive(double value)
```
  - intValue
```
public abstract int intValue()
```
    Specified by:
    
    intValue in class java.lang.Number
  - longValue
```
public abstract long longValue()
```
    Specified by:
    
    longValue in class java.lang.Number
  - floatValue
```
public abstract float floatValue()
```
    Specified by:
    
    floatValue in class java.lang.Number
  - doubleValue
```
public abstract double doubleValue()
```
    Specified by:
    
    doubleValue in class java.lang.Number
  - square
```
public abstract S square()
```
  - getSquared
```
public S getSquared()
```
  - squareRoot
```
public abstract S squareRoot()
```
  - getSquareRoot
```
public S getSquareRoot()
```
  - exponentiate
```
public abstract S exponentiate(Value<?> exponential)
```
  - getExponentiated
```
public S getExponentiated(Value<?> exponential)
```
  - root
```
public abstract S root(Value<?> root)
```
  - getRoot
```
public S getRoot(Value<?> root)
```
  - modulus
```
public abstract S modulus()
```
  - getModulus
```
public S getModulus()
```

Class Value<S extends Value<S>>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

Methods inherited from interface uk.co.strangeskies.mathematics.operation.Subtractable

Methods inherited from interface uk.co.strangeskies.mathematics.operation.Addable

Methods inherited from interface uk.co.strangeskies.utility.Copyable

Methods inherited from interface uk.co.strangeskies.utility.Self

Methods inherited from interface uk.co.strangeskies.mathematics.operation.Negatable

Methods inherited from interface uk.co.strangeskies.mathematics.operation.Scalable

Methods inherited from interface uk.co.strangeskies.mathematics.operation.Incrementable

Methods inherited from interface uk.co.strangeskies.expression.CopyDecouplingExpression

Methods inherited from interface uk.co.strangeskies.expression.Expression

Constructor Detail

Value

Value

Value

Method Detail

compareTo

negate

reciprocate

getReciprocal

getMultiplied

toString

setValue

equals

equals

unitInTheLastPlaceAbove

unitInTheLastPlaceBelow

unitInTheLastPlaceLarger

unitInTheLastPlaceSmaller

maximum

minimum

getValue

update

postUpdate

invalidations

multiply

divide

equals

equals

equals

equals

compareToAtSupportedPrecision

getMultipliedPrimitive

getMultipliedPrimitive

getMultipliedPrimitive

getMultipliedPrimitive

getDividedPrimitive

getDividedPrimitive

getDividedPrimitive

getDividedPrimitive

intValue

longValue

floatValue

doubleValue

square

getSquared

squareRoot

getSquareRoot

exponentiate

getExponentiated

root

getRoot

modulus

getModulus