Value

java.lang.Object
- la.la.Value

All Implemented Interfaces:

java.lang.Comparable<Value>

Direct Known Subclasses:

Function, Graph, Model, Value.Atomic, Value.Defer, Value.Structured
```
public abstract class Value
extends java.lang.Object
implements java.lang.Comparable<Value>
```
Value = int + bool + char + triv + ... + (Value × Value) + (Value → Value), that is, first class Values. Also see Type.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Value.Atomic` The abstract class of atomic, non-`structured` Values, notably `Discrete` and `Cts`.
`static class`	`Value.Bool` Bool = false \| true; also see `Type.BOOL`.
`static class`	`Value.Char` A Char Value; also see `Type.CHAR`.
`static class`	`Value.Chars` A Chars (String) Value; also see `Type.CHARS`.
`static class`	`Value.Cts` Continuous Values, x()+/-(`AoM()`/2); see `Type.CTS` and `Value.Real`.
`static class`	`Value.Defer` The class of lazy, that is, not yet computed, Deferred Values, `Value.Defer.Exp` and `Value.Defer.App`.
`static class`	`Value.Discrete` Discrete Values, such as `Value.Bool`, are subclasses of Discrete.
`static class`	`Value.Enum` Enum Values, for example, A:DNA; also see `Type.Enum`.
`static class`	`Value.Inc_Or` Inc_Or t0 t1 = Left t0 \| Right t1 \| Both t0 t1, for where one, or both, of v0:t0 and v1:t1 can be present.
`static class`	`Value.Int` Also see `Type.INT`.
`static class`	`Value.Lambda` Function produced from a `Expression.LambdaExp` and an `Environment`.
`static class`	`Value.List` Linked Lists, a special implementation of the abstract `Value.Option`.
`static class`	`Value.Maybe` Maybe t = None \| Just t, for where a Value may be missing (`None`), or present (`Just v`).
`static class`	`Value.Option` An Option Value has a "tag", `Value.Option.n()`, and zero or more sub-Values, `Value.Structured.elt(int)` depending on the tag.
`static class`	`Value.Real` A class of exact `Value.Cts` Values -- those having `Value.Real.AoM() = 0` .
`static interface`	`Value.Scannable` A class that implements Scannable can produce (by toSeries()) a `Series` of Values.
`static class`	`Value.Structured` The super-class of Values, such as `Tuples` and `Vectors`, having zero or more elements (components, fields), `elt(i)`.
`static class`	`Value.Triv` `() : TRIV` .
`static class`	`Value.Tuple` The class of heterogeneous k-Tuples, that is pairs, triples, and so on; also see `Type.Tuple` and `Vector`.

Field Summary

Fields
Modifier and Type	Field and Description
`static Value.Int`	`C`
`static java.util.Comparator<Value>`	`comparator` `comparator.compare(v1, v2)` returns `v1.compareTo(v2)`.
`static Value.Real`	`CR`
`static Value.Real`	`E`
`static Value.Int`	`eight`
`static Value.Bool`	`ffalse`
`static Value.Int`	`five`
`static Value.Real`	`fiveR`
`static Value.Int`	`four`
`static Value.Real`	`fourR`
`static Value.Real`	`half`
`static Value.Real`	`negCR`
`static Value.Int`	`negOne`
`static Value.Real`	`negOneR`
`static Value.Real`	`negTenR`
`static Value.List`	`nilVal`
`static Value.Int`	`nine`
`static Value.Maybe`	`None` Equal to Maybe.None
`static Value.Int`	`one`
`static Value.Real`	`oneR`
`static Value.Real`	`PI`
`static Value.Real`	`PIby2`
`static Value.Real`	`point01`
`static Value.Real`	`point1`
`static Value.Real`	`point5`
`static Value.Real`	`point9`
`static Value.Real`	`quarter`
`static Value.Int`	`seven`
`static Value.Int`	`six`
`static Value.Int`	`ten`
`static Value.Real`	`tenR`
`static Value.Int`	`three`
`static Value.Real`	`threeR`
`static Value.Triv`	`triv`
`static Value.Bool`	`ttrue`
`static Value.Int`	`two`
`static Value.Real`	`twoR`
`static Value.Int`	`zero`
`static Value.Real`	`zeroR`

Constructor Summary

Constructors
Constructor and Description

Value()

Constructors
Constructor and Description
`Value()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`AoM()` See `Value.Cts.AoM()`.
`Value`	`apply(Value v)` This default throws an exception but see `Function.apply(la.la.Value)`.
`Value`	`bOp(int op, Value rgt)` Apply binary Operator 'op' to Values 'this' and 'rgt', if implemented (this default throws an Exception).
`int`	`compareTo(Value v2)` Note, not all Values are actually Comparable.
`static Value.List.Cell`	`cons(Value h, Value t)` Convenience function returning the List h::t.
`static Value.Cts`	`cts(double x, double AoM)` Return a `Cts` Value representing x±AoM/2.
`Value`	`elt(int i)` See `Value.Structured.elt(int)`.
`protected java.lang.String`	`errMsg(java.lang.String msg)` It has all gone pear-shaped; identify 'this' and 'msg'.
`protected void`	`error(java.lang.String msg)` Throws `RTE(msg)`.
`Value`	`force()` This default implementation returns 'this' Value, but the real interest is in `Value.Defer.force()`.
`Value.Tuple`	`isTuple(int k)` Check that 'this' Value really is a k-Tuple and, if it is, return it as a Tuple.
`static Value.Maybe.Just`	`just(Value v)` Convenience function, returns new Maybe.Just(v).
`static void`	`main(java.lang.String[] argv)` main() allows Value to be (very slightly) tested in isolation.
`int`	`n()` n() corresponds to an `Int.n()` or an `Option.n()` etc.; this default throws a RuntimeException but see `Bool.n()`, say.
`int`	`nElts()` This default throws an exception but see `Value.Structured.nElts()`.
`double`	`nlAoM()` See `Value.Cts.nlAoM()`.
`static Value.Tuple.GP`	`pair(Value e0, Value e1)` pair, a convenience function to make a `2-Tuple`.
`void`	`print(java.io.PrintStream ps)` Note, evaluation is print driven; this default print(ps) calls `ps.print(toString())` and is only used by small, atomic values; other sub-classes must override it.
`static Value.Tuple.GP`	`quad(Value e0, Value e1, Value e2, Value e3)` quad, a convenience function to make a `4-Tuple`.
`static Value.Real`	`real(double x)` Return an exact `Real` Value corresponding to the double x.
`protected java.lang.RuntimeException`	`RTE(java.lang.String msg)` Short for RuntimeException(`errMsg(msg)`)
`java.lang.String`	`toString()` Used, for example, in `printing` of `constants`, and in calls to `error(java.lang.String)`.
`static Value.Tuple.GP`	`triple(Value e0, Value e1, Value e2)` triple, a convenience function to make a `3-Tuples`.
`static Value.Tuple.GP`	`tuple(Value[] vs)` tuple, a convenience function to make a `k-Tuple`.
`abstract Type`	`type()` Return the `Type` of 'this' Value.
`protected java.lang.UnsupportedOperationException`	`UOE(java.lang.String msg)` Short for UnsupportedOperationException(`errMsg(msg)`)
`Value`	`uOp(int op)` Apply unary Operator 'op' to 'this' Value, if implemented (this default throws an Exception).
`double`	`x()` x() returns a `Cts.x()`, and also see `Int.x()`, but this default throws a RuntimeException (see `n()`).

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

Field Detail

triv
```
public static final Value.Triv triv
```

nilVal
```
public static final Value.List nilVal
```

ffalse
```
public static final Value.Bool ffalse
```

ttrue
```
public static final Value.Bool ttrue
```

negOne
```
public static final Value.Int negOne
```

zero
```
public static final Value.Int zero
```

one
```
public static final Value.Int one
```

two
```
public static final Value.Int two
```

three
```
public static final Value.Int three
```

four
```
public static final Value.Int four
```

five
```
public static final Value.Int five
```

six
```
public static final Value.Int six
```

seven
```
public static final Value.Int seven
```

eight
```
public static final Value.Int eight
```

nine
```
public static final Value.Int nine
```

ten
```
public static final Value.Int ten
```

C
```
public static final Value.Int C
```

negTenR
```
public static final Value.Real negTenR
```

negOneR
```
public static final Value.Real negOneR
```

zeroR
```
public static final Value.Real zeroR
```

point1
```
public static final Value.Real point1
```

point5
```
public static final Value.Real point5
```

point01
```
public static final Value.Real point01
```

quarter
```
public static final Value.Real quarter
```

half
```
public static final Value.Real half
```

point9
```
public static final Value.Real point9
```

oneR
```
public static final Value.Real oneR
```

twoR
```
public static final Value.Real twoR
```

threeR
```
public static final Value.Real threeR
```

fourR
```
public static final Value.Real fourR
```

fiveR
```
public static final Value.Real fiveR
```

tenR
```
public static final Value.Real tenR
```

CR
```
public static final Value.Real CR
```

negCR
```
public static final Value.Real negCR
```

E
```
public static final Value.Real E
```

PI
```
public static final Value.Real PI
```

PIby2
```
public static final Value.Real PIby2
```

comparator
```
public static java.util.Comparator<Value> comparator
```
comparator.compare(v1, v2) returns v1.compareTo(v2). Note, not all Values are actually Comparable.

None
```
public static final Value.Maybe None
```
Equal to Maybe.None

Constructor Detail
- Value
```
public Value()
```

Method Detail
- type
```
public abstract Type type()
```
  Return the Type of 'this' Value.
- compareTo
```
public int compareTo(Value v2)
```
  Note, not all Values are actually Comparable. If ok it returns '-1', '0', '+1' for '<', '=', '>'.
  
  Specified by:
  
  compareTo in interface java.lang.Comparable<Value>
- uOp
```
public Value uOp(int op)
```
  Apply unary Operator 'op' to 'this' Value, if implemented (this default throws an Exception). The int codes for op come from Lexical. Also see bOp(int,Value).
- bOp
```
public Value bOp(int op,
                 Value rgt)
```
  Apply binary Operator 'op' to Values 'this' and 'rgt', if implemented (this default throws an Exception). The int codes for op come from Lexical. Also see uOp(int).
- force
```
public Value force()
```
  This default implementation returns 'this' Value, but the real interest is in Value.Defer.force().
- print
```
public void print(java.io.PrintStream ps)
```
  Note, evaluation is print driven; this default print(ps) calls ps.print(toString()) and is only used by small, atomic values; other sub-classes must override it.
- toString
```
public java.lang.String toString()
```
  Used, for example, in printing of constants, and in calls to error(java.lang.String). The result does not necessarily fully specify a large, or infinite(!), Value. (This default returns the Class Name of 'this'.) Also see print(ps).
  
  Overrides:
  
  toString in class java.lang.Object
- n
```
public int n()
```
  n() corresponds to an Int.n() or an Option.n() etc.; this default throws a RuntimeException but see Bool.n(), say. The inclusion of n(), and others, for all Values reduces the need for casts and also works nicely with Value.Defer.
- x
```
public double x()
```
  x() returns a Cts.x(), and also see Int.x(), but this default throws a RuntimeException (see n()).
- AoM
```
public double AoM()
```
  See Value.Cts.AoM(). (This default throws a RuntimeException.)
- nlAoM
```
public double nlAoM()
```
  See Value.Cts.nlAoM(). (This default throws a RuntimeException.)
- nElts
```
public int nElts()
```
  This default throws an exception but see Value.Structured.nElts().
- elt
```
public Value elt(int i)
```
  See Value.Structured.elt(int).
- apply
```
public Value apply(Value v)
```
  This default throws an exception but see Function.apply(la.la.Value).
- cts
```
public static Value.Cts cts(double x,
                            double AoM)
```
  Return a Cts Value representing x±AoM/2. Also see real(x).
- real
```
public static Value.Real real(double x)
```
  Return an exact Real Value corresponding to the double x. Continuous data (experimental or observational) cannot be exact Real, of course. Also see cts(x,aom).
- isTuple
```
public Value.Tuple isTuple(int k)
```
  Check that 'this' Value really is a k-Tuple and, if it is, return it as a Tuple. E.g., useful in a Function (method) that has a Pair as a parameter, e.g., Tuple tv=v.isTuple(2).
- tuple
```
public static Value.Tuple.GP tuple(Value[] vs)
```
  tuple, a convenience function to make a k-Tuple.
- pair
```
public static Value.Tuple.GP pair(Value e0,
                                  Value e1)
```
  pair, a convenience function to make a 2-Tuple.
- triple
```
public static Value.Tuple.GP triple(Value e0,
                                    Value e1,
                                    Value e2)
```
  triple, a convenience function to make a 3-Tuples.
- quad
```
public static Value.Tuple.GP quad(Value e0,
                                  Value e1,
                                  Value e2,
                                  Value e3)
```
  quad, a convenience function to make a 4-Tuple.
- cons
```
public static Value.List.Cell cons(Value h,
                                   Value t)
```
  Convenience function returning the List h::t. Note, t must be a List.
- just
```
public static Value.Maybe.Just just(Value v)
```
  Convenience function, returns new Maybe.Just(v).
- errMsg
```
protected java.lang.String errMsg(java.lang.String msg)
```
  It has all gone pear-shaped; identify 'this' and 'msg'. See, e.g., error(str), RTE(str), and UOE(str).
- RTE
```
protected java.lang.RuntimeException RTE(java.lang.String msg)
```
  Short for RuntimeException(errMsg(msg))
- UOE
```
protected java.lang.UnsupportedOperationException UOE(java.lang.String msg)
```
  Short for UnsupportedOperationException(errMsg(msg))
- error
```
protected void error(java.lang.String msg)
```
  Throws RTE(msg).
- main
```
public static void main(java.lang.String[] argv)
```
  main() allows Value to be (very slightly) tested in isolation.

Class Value

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

triv

nilVal

ffalse

ttrue

negOne

zero

one

two

three

four

five

six

seven

eight

nine

ten

C

negTenR

negOneR

zeroR

point1

point5

point01

quarter

half

point9

oneR

twoR

threeR

fourR

fiveR

tenR

CR

negCR

E

PI

PIby2

comparator

None

Constructor Detail

Value

Method Detail

type

compareTo

uOp

bOp

force

print

toString

n

x

AoM

nlAoM

nElts

elt

apply

cts

real

isTuple

tuple

pair

triple

quad

cons

just

errMsg

RTE

UOE

error

main