Vector

java.lang.Object
- la.la.Value
- - la.la.Value.Structured
  - - la.maths.Vector

All Implemented Interfaces:

java.lang.Comparable<Value>, Value.Scannable

Direct Known Subclasses:

Alignment, Matrix, Value.Chars, Vector.Derived, Vector.Doubles, Vector.GP, Vector.Ints, Vector.Slice, Vector.Strings, Vector.Weighted
```
public abstract class Vector
extends Value.Structured
implements Value.Scannable
```
The class of homogeneous Vectors of arbitrary length. The principal operations are nElts() the number of top-level elements, elt(i), and wt(i) the weight of elt(i). The default assumptions are that ∀ i wt(i)=1 (see constWt()), and that, if applicable, elt(i).AoM() may vary with i (see constAoM(). Also see Type.VECTOR, Value.Tuple and Matrix.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`Vector.Derived` Class Derived can be useful when making a modified Vector.
`static class`	`Vector.Doubles` A Vector containing doubles (`Cts` Values) can probably arrange efficient storage and operations.
`static class`	`Vector.GP` A simple, general purpose (GP) implementation of class `Vector`.
`static class`	`Vector.Ints` A Vector containing `Int` Values can probably arrange efficient storage and operations.
`class`	`Vector.Slice` Vector.Slice, a subVector of 'this' Vector; see `slice`.
`static class`	`Vector.Strings` A Vector containing Strings, that is, having `Chars` elements.
`class`	`Vector.Weighted` 'This' Vector (data-set?) of elements, each element explicitly `weighted`, somehow.

Nested classes/interfaces inherited from class la.la.Value
Value.Atomic, Value.Bool, Value.Char, Value.Chars, Value.Cts, Value.Defer, Value.Discrete, Value.Enum, Value.Inc_Or, Value.Int, Value.Lambda, Value.List, Value.Maybe, Value.Option, Value.Real, Value.Scannable, Value.Structured, Value.Triv, Value.Tuple

Field Summary

Fields
Modifier and Type Field and Description

static Vector empty
The empty Vector with no elements at all.
- Fields inherited from class la.la.Value
  C, comparator, CR, E, eight, ffalse, five, fiveR, four, fourR, half, negCR, negOne, negOneR, negTenR, nilVal, nine, None, one, oneR, PI, PIby2, point01, point1, point5, point9, quarter, seven, six, ten, tenR, three, threeR, triv, ttrue, two, twoR, zero, zeroR

Fields
Modifier and Type	Field and Description
`static Vector`	`empty` The empty Vector with no elements at all.

Constructor Summary

Constructors
Constructor and Description

Vector()

Constructors
Constructor and Description
`Vector()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`Vector`	`addMore(Vector.Slice s)` `addMore(s,0,s.nElts())`.
`Vector`	`addMore(Vector v, int lo, int hi)` It is impossible, an error, to add more than zero elements (of 'v'==this) to 'this' Vector as they are all already there, but to a `Slice` is possible.
`double`	`AoM(int i)` Return this.elt(i).AoM() — assuming this is a Vector of Cts.
`Vector`	`append()` For 'this' non-empty Vector (data-set?) of Vectors, `append` them all, that is flatten k dimensions to (k-1) dimensions.
`Vector`	`append(Vector v2)` Append Vectors 'this' and 'v2', of the same type!
`Matrix`	`as_1xn()` Make a "row-Vector", i.e., a 1×n-`Matrix`, of 'this' Vector (regardless of the element type).
`Matrix`	`as_nx1()` Make a "column Vector", i.e., a n×1-`Matrix`, of 'this' Vector (regardless of the element type).
`Matrix`	`asDiagonal(Value z)` Make a square, diagonal `Matrix` of 'this' Vector, using 'z' for all off-diagonal elements.
`Matrix`	`asMatrix()` Provided 'this' is a rectangular Vector of Vectors, return it as the equivalent `Matrix`; also see `Matrix.asMatrix()`.
`Q`	`asQ()` Make 'this' 4D Vector of Cts a `quaternion` in the obvious way.
`Q`	`asQrotn()` Make 'this' 3D Vector of Cts, (x, y, z), a `quaternion` (0.0, x, y, z). Note, asQrotn() is used in `rotate(q)`.
`Value`	`bOp(int op, Value v)` Binary operator, 'op', on 'this' Vector, and 'v', that is apply `op` element-wise returning a Vector of results.
`protected java.lang.String`	`closes()` "]"; see `Value.Structured.print(java.io.PrintStream)` and `Value.Structured.toString()`.
`Vector`	`col(int c)` Provided 'this' is a Vector of `Value.Structured`, return the c-th column, as a Vector.
`Vector`	`cols(int[] cs)` Provided 'this' is a Vector of `Value.Tuple`, return the Vector of Tuples made up of the columns specified by cs.
`Vector`	`combine(boolean add, Vector.Slice v)` Either `addMore` (add=true) Vector 'v' to this or `delete` (add=false) v from this Vector.
`int`	`compareTo(Value v)` Compare 'this' Vector to v, returning -ve (<), 0 (=), or +ve (>).
`double`	`constAoM()` By default, return −1 (any negative) indicating the elements' AoMs (if appropriate) may vary from element to element.
`double`	`constNlAoM()` If `constAoM()` is >0, return its negative log, otherwise an error.
`double`	`constWt()` By default, return 1.0 indicating that every element has that `weight`.
`static Vector`	`csv(boolean trimHead, boolean trimTail, char separator, Type.Tuple rowType, int skipLines, java.io.InputStream inp)` Input a data-set of "comma-"separated values from a given InputStream (often a `FileInputStream`).
`static Vector`	`csv(Type.Tuple rowType, java.io.InputStream inp)` `csv(...)` using some common default parameter values.
`Vector`	`delete(Vector.Slice s)` `delete(s.parent(),s.lo,s.hi)`.
`Vector`	`delete(Vector v, int lo, int hi)` Delete elements [lo, hi) of 'v' from 'this'; it requires (and checks) that v == this.
`double`	`dot(Vector v)` The dot- (inner-) product of Vectors of Cts, 'this' and 'v'.
`static Vector.Doubles`	`doubles(double[] xs)` Convenience function `: double[] → Vector`; note AoM=0.
`static Vector.Doubles`	`doubles(double[] xs, double AoM)` Convenience function `: double[] × AoM → Vector`, where every element of the Vector has the same `AoM` (do not confuse it with `doubles(double,double[])`.
`static Vector.Doubles`	`doubles(double nlAoM, double[] xs)` Convenience function `: nlAoM × double[] → Vector`, where we know the nlAoM of the Vector as a whole, but not of each elt(i).
`Vector`	`drop(int m)` Return all but the first 'm' elements of 'this' Vector; see `take(int)` and `slice(int, int)`.
`Vector`	`drop(int lo, int hi)` Drop elements [lo,hi) of 'this' Vector, lo inclusive, hi exclusive.
`Vector`	`dropLast(int m)` Return all but the last 'm' elements of 'this' Vector; see `slice(int, int)`.
`abstract Value`	`elt(int i)` Element 'i' of 'this' Vector.
`Value`	`elt(int r, int c)` Provided 'this' is a Vector of `Value.Structured`, return the element at row 'r', column 'c'.
`Vector.Derived`	`elts(int[] ps)` Return a sub-Vector of 'this', being made up of the positions, ps.
`Type`	`eltType()` The type of all(!) elements of 'this' Vector.
`Value`	`foldl(Function fc)` `drop`(1) .`foldl`(fc,elt(0))
`Value`	`foldl(Function fc, Value z)` foldl (fold-left, reduce) 'this' Vector with curried Function 'fc' and zero (identity) 'z', in effect ((((z fc e₀) fc e₁) ... ) fc e_n-1).
`Value`	`foldr(Function fc)` `take`(n_1) .`foldr`(fc,elt(n_1)), where n_1 = nElts() - 1.
`Value`	`foldr(Function fc, Value z)` foldr (fold-right, reduce) 'this' Vector with curried Function 'fc' and zero (identity) 'z', in effect (e₀ fc ( ... (e_n-2 fc (e_n-1 fc z)))).
`static Vector`	`fromScannable(Value.Scannable sv)` Make a Vector from the given Scannable Value sv.
`static Vector`	`ints(int[] ns)` Convenience function, `ints : int[] → Vector`.
`static Vector`	`ints(Type.Discrete et, int[] ns)` Convenience function to make a Vector with elements of `Discrete Type` et, and integer codes, ns.
`boolean`	`isRectangular()` Provided 'this' is a Vector of Vectors, is it rectangular? That is, is it non-"jagged"? Also see `isSquare()`, and `Matrix`.
`boolean`	`isSquare()` Provided 'this' is a Vector of Vectors, is it square? Also see `isRectangular()`.
`static void`	`main(java.lang.String[] argv)` main() allows Vector to be (slightly) tested, in isolation.
`Vector`	`map(Function f)` Apply Function 'f' to each element of 'this' Vector, returning a Vector of results.
`Q`	`match(Vector t)` Find the rotation (as a `quaternion`), by some angle about some axis through the origin, that minimises the sum of squared errors between the Vectors of 3D Vectors of Cts, 'this' and 't'.
`protected void`	`merge(int lo, int hi, int[] src, int[] tgt, java.util.Comparator<Value> cmp)` MergeSort tgt[lo,hi) on the basis of cmp(elt(tgt[.]), elt(tgt[.])),, possibly using src[lo,mid) and src[mid,hi) where mid = (lo + hi)÷2.
`int`	`n(int i)` Return this.elt(i).n() — assuming this is a Vector of Int.
`int`	`nCols()` Provided 'this' is a rectangular Vector of `Structured`, which property is checked within, return its number of columns, otherwise throw an error.
`boolean`	`nearlySymmetric()` Provided 'this' is a Vector of Vectors of Cts, return `nearlySymmetric`(`Maths.epsilon`).
`boolean`	`nearlySymmetric(double epsilon)` Provided 'this' is a Vector of Vectors of Cts, is it square && (nearly-)symmetric? That is, are x[r][c] and x[c][r] `nearlyEqual` for all r and c?
`abstract int`	`nElts()` The number of elements (rows) in 'this' Vector.
`int`	`nElts(int row)` Provided 'this' is a Vector of `Value.Structured`, return `nElts()` of `elt(row)`.
`double`	`nlAoM()` The total -ve log AoM of the whole Vector (if appropriate); it looks at `constAoM()` and acts accordingly.
`double`	`nlAoM(int i)` Return this.elt(i).nlAoM() — assuming this is a Vector of Cts.
`double`	`nlAoM(int lo, int hi)` Return the sum `nlAoM` of elements [lo, hi).
`Value.Cts`	`norm_Cts()` 'This' Vector's Euclidean `norm` as a `Value.Cts` with nlAoM() being the Vector's divided by nElts().
`double`	`norm()` The Euclidean norm, \|\|v\|\|=√(v.v), of 'this' Vector of Cts, that is, √`sumSq()`.
`Vector`	`normalised()` Return 'this' Vector of Cts normalised to 1.0, which has implications for `AoM(int)` and `nlAoM()`.
`protected Vector`	`normalised1()` Return 'this' Vector of Cts `normalised` by making a Vector of new (scaled) elements.
`protected Vector`	`normalised2()` Return 'this' Vector of Cts `normalised` but without copying the (scaled) elements.
`protected java.lang.String`	`opens()` "["; see `Value.Structured.print(java.io.PrintStream)` and `Value.Structured.toString()`.
`static Vector`	`repeat(Value v, int n)` The Vector {v, v, ..., v}, n times.
`Vector`	`rotate(double t, Vector n)` Given an angle, 't', in radians, and an axis, 'n', rotate 'this' 3D Vector by t about n.
`Vector`	`rotate(Q q)` As specified by the `quaternion`, 'q', rotate 'this' 3D Vector by an angle about an axis.
`int`	`rowLength()` Provided this is a Vector of Vectors, if it is rectangular return its row length, else a negative int.
`Vector`	`scaled(double s)` Return 'this' Vector scaled by a factor, s.
`int[]`	`shape()` For a Vector of Vector of Vec..., return the "nElts()" of the leading (hyper-)rectangular dimensions, e.g., a simple Vector would give [m], an m×n `Matrix` [m,n], etc., and a jagged Vector of Vectors [m].
`static Vector`	`singleton(Value e)` Return a Vector consisting of a single element, 'e'.
`Vector`	`slice(int lo, int hi)` Return a `Slice` (section), [lo, hi), of 'this' Vector, that is, the elements between lo inclusive, and hi exclusive.
`Vector.Derived`	`sorted()` Return 'this' Vector, sorted on `Value.comparator`.
`Vector.Derived`	`sorted(java.util.Comparator<Value> cmp)` Return 'this' Vector sorted on 'cmp'.
`Vector.Derived`	`sorted(int col)` Return 'this' Vector sorted on column 'col'.
`static Vector.Strings`	`strings(java.lang.String[] ss)` Convenience function `: String[] → Vector`.
`double`	`sumSq()` Provided 'this' is a Vector of Cts, return the sum of squares, ∑_i elt(i).x()².
`Vector`	`take(int m)` Return the first 'm' elements of 'this' Vector; see `drop(int)` and `slice(int, int)`.
`Vector`	`takeLast(int m)` Return the last 'm' elements of 'this' Vector; see `slice(int, int)`.
`Vector`	`times(Matrix M)` 'this' Vector of Cts, v, as a row-Vector, times `Matrix` M, as in v M.
`Series`	`toSeries()` Make a `Series`, the elements of 'this' `Vector`, one at a time.
`Type`	`type()` `Type`.`VECTOR`.
`Value[]`	`uniqueElts()` Return an array containing the unique elements of 'this' Vector in ascending order.
`Value.Tuple`	`unzip()` `unzip` 'this' Vector of Tuples into a Tuple of Vectors.
`Value.Tuple`	`unzip(int nCol)` unzip 'this' Vector of Tuples each of (must be) nCol elements.
`Value`	`uOp(int op)` Unary operator, 'op', on 'this' Vector, that is apply `op` element-wise, returning a new Vector of results.
`static Vector.GP`	`values(Value[] vs)` Convenience function, `values : Value[] → GP`.
`Vector.Weighted`	`weight(double wt)` Return a Vector, based on the data in 'this' Vector, but with weights adjusted × 'wt' ≥ 0.
`Vector.Weighted`	`weight(double[] wts)` Return a Vector, based on the data in 'this' Vector, but with weights adjusted × wts[i].
`Vector`	`weight(Vector v)` Re-weight 'this' Vector adjusting weights by × v.elt(i).x().
`Vector`	`weightLike(double w)` Re-weight 'this' Vector setting all weights equal to w ≥ 0.
`Vector`	`weightLike(Vector v)` Re-weight 'this' Vector setting weights, wt(i), equal to v.wt(i).
`double`	`wt(int i)` `wt(i)`, the weight, of `elt(i)` in 'this' data-set (Vector); this default is 1.0.
`int`	`wtMedian()` Return the index, m, of the median element on the basis of `weights`.
`double`	`wtNlAoM()` The total -ve log AoM of the whole Vector (if appropriate), taking into account element `weights`.
`double`	`wtNlAoM(int lo, int hi)` Return the total weighted `nlAoM` of elements [lo, hi).
`double`	`wts()` Return ∑_i `wt(i)`. It looks at `constWt()` and acts accordingly.
`double`	`wts(int lo, int hi)` Return the total `weights` of elements [lo, hi).
`double`	`x(int i)` Return this.elt(i).x() — assuming this is a Vector of Cts.
`Vector`	`zip(Vector v)` `zip` 'this' Vector with another Vector 'v', of the same length, to produce a Vector of pairs as in, `zip(new Vector [] {this, v}`.
`static Vector`	`zip(Vector[] cols)` `zip several Vectors to make a Vector of Tuples.`

Methods inherited from class la.la.Value.Structured
AoM, elts, frth, fst, print, separator, snd, thrd, toString

Methods inherited from class la.la.Value
apply, cons, cts, errMsg, error, force, isTuple, just, n, pair, quad, real, RTE, triple, tuple, UOE, x

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

- Field Detail
  - empty
```
public static final Vector empty
```
    The empty Vector with no elements at all.
- Constructor Detail
  - Vector
```
public Vector()
```
- Method Detail
  - opens
```
protected java.lang.String opens()
```
    "["; see Value.Structured.print(java.io.PrintStream) and Value.Structured.toString().
    
    Overrides:
    
    opens in class Value.Structured
  - closes
```
protected java.lang.String closes()
```
    "]"; see Value.Structured.print(java.io.PrintStream) and Value.Structured.toString().
    
    Overrides:
    
    closes in class Value.Structured
  - type
```
public Type type()
```
    Type.VECTOR.
    
    Specified by:
    
    type in class Value
  - nElts
```
public abstract int nElts()
```
    The number of elements (rows) in 'this' Vector. Also see wts().
    
    Specified by:
    
    nElts in class Value.Structured
  - elt
```
public abstract Value elt(int i)
```
    Element 'i' of 'this' Vector. Also see n(i), x(i), and wt(int).
    
    Specified by:
    
    elt in class Value.Structured
  - n
```
public int n(int i)
```
    Return this.elt(i).n() — assuming this is a Vector of Int. A subclass might have a faster way to do this.
  - x
```
public double x(int i)
```
    Return this.elt(i).x() — assuming this is a Vector of Cts. A subclass might have a faster way to do this.
  - eltType
```
public Type eltType()
```
    The type of all(!) elements of 'this' Vector. Note that a Vector must be homogeneous.
  - wt
```
public double wt(int i)
```
    wt(i), the weight, of elt(i) in 'this' data-set (Vector); this default is 1.0. We may have fractional weights for mixture-modelling, say, >1 for multiple copies of a datum, and zero to turn a datum "off". Note that wt(i), and constWt() must be consistent! For some operations on Vector, such as append, it is pretty clear what wt(i) should be in the result, but not for some others, such as zip, in which case you get something plausible. Also see wts().
  - constWt
```
public double constWt()
```
    By default, return 1.0 indicating that every element has that weight. Return a negative to indicate that weights may vary. Used by wts(), wtNlAoM(), etc.. (Also see constAoM().)
  - constAoM
```
public double constAoM()
```
    By default, return −1 (any negative) indicating the elements' AoMs (if appropriate) may vary from element to element. If they all equal aom≥0, return that value. If the elements are precise, return zero. Used by nlAoM() and wtNlAoM(). Also see constNlAoM() and constWt().
  - constNlAoM
```
public double constNlAoM()
```
    If constAoM() is >0, return its negative log, otherwise an error.
  - nlAoM
```
public double nlAoM()
```
    The total -ve log AoM of the whole Vector (if appropriate); it looks at constAoM() and acts accordingly. This is particularly for pr(v) and nlPr(v) where v is a Cts Vector. Also see wtNlAoM().
    
    Overrides:
    
    nlAoM in class Value.Structured
  - nlAoM
```
public double nlAoM(int lo,
                    int hi)
```
    Return the sum nlAoM of elements [lo, hi). Also see nlAoM(i).
  - AoM
```
public double AoM(int i)
```
    Return this.elt(i).AoM() — assuming this is a Vector of Cts. A subclass might have a faster way to do this.
  - nlAoM
```
public double nlAoM(int i)
```
    Return this.elt(i).nlAoM() — assuming this is a Vector of Cts. A subclass might have a faster way to do this.
  - wts
```
public double wts()
```
    Return ∑_i wt(i). It looks at constWt() and acts accordingly. wts() is the real 'N' of a data-set. Many Vectors can do wts() in O(1)-time, but not all!
  - wts
```
public double wts(int lo,
                  int hi)
```
    Return the total weights of elements [lo, hi).
  - wtMedian
```
public int wtMedian()
```
    Return the index, m, of the median element on the basis of weights. If constWt()≥0 m = nElts()÷2. Otherwise it is the smallest 'm' s.t. 2×∑_0..m wt(m) ≥ wts(). It assumes the Vector is sorted somehow and does not check this.
  - wtNlAoM
```
public double wtNlAoM()
```
    The total -ve log AoM of the whole Vector (if appropriate), taking into account element weights. This is particularly for nlLH(ss) of a Cts data-set and so on. It looks at constWt() and at constAoM() and acts accordingly. Also see nlAoM().
  - wtNlAoM
```
public double wtNlAoM(int lo,
                      int hi)
```
    Return the total weighted nlAoM of elements [lo, hi).
  - elts
```
public Vector.Derived elts(int[] ps)
```
    Return a sub-Vector of 'this', being made up of the positions, ps. Also see cols(cs) and Value.Tuple.elts(int[]).
  - uniqueElts
```
public Value[] uniqueElts()
```
    Return an array containing the unique elements of 'this' Vector in ascending order.
  - singleton
```
public static Vector singleton(Value e)
```
    Return a Vector consisting of a single element, 'e'.
  - toSeries
```
public Series toSeries()
```
    Make a Series, the elements of 'this' Vector, one at a time.
    
    Specified by:
    
    toSeries in interface Value.Scannable
  - fromScannable
```
public static Vector fromScannable(Value.Scannable sv)
```
    Make a Vector from the given Scannable Value sv. (If sv is a Vector, return sv.) In general the returned Vector is inefficient for non-sequential random access. The length of sv.toSeries() must be deterministic!
    Why do we have fromScannable(sv) and not 'fromSeries(s)' – well a Series is used up and cannot be "rewound" but a Scannable can be "re- toSeries() -ed".
  - sorted
```
public Vector.Derived sorted()
```
    Return 'this' Vector, sorted on Value.comparator. Also see sorted(Comparator).
  - sorted
```
public Vector.Derived sorted(int col)
```
    Return 'this' Vector sorted on column 'col'.
  - sorted
```
public Vector.Derived sorted(java.util.Comparator<Value> cmp)
```
    Return 'this' Vector sorted on 'cmp'. Also see sorted().
  - merge
```
protected void merge(int lo,
                     int hi,
                     int[] src,
                     int[] tgt,
                     java.util.Comparator<Value> cmp)
```
    MergeSort tgt[lo,hi) on the basis of cmp(elt(tgt[.]), elt(tgt[.])),, possibly using src[lo,mid) and src[mid,hi) where mid = (lo + hi)÷2.
  - weight
```
public Vector.Weighted weight(double[] wts)
```
    Return a Vector, based on the data in 'this' Vector, but with weights adjusted × wts[i]. Also see weight(double).
  - weight
```
public Vector.Weighted weight(double wt)
```
    Return a Vector, based on the data in 'this' Vector, but with weights adjusted × 'wt' ≥ 0. Also see weight(Vector).
  - weight
```
public Vector weight(Vector v)
```
    Re-weight 'this' Vector adjusting weights by × v.elt(i).x(). Also see weight(double[]).
  - weightLike
```
public Vector weightLike(double w)
```
    Re-weight 'this' Vector setting all weights equal to w ≥ 0.
  - weightLike
```
public Vector weightLike(Vector v)
```
    Re-weight 'this' Vector setting weights, wt(i), equal to v.wt(i). Also see weight(double[]).
  - compareTo
```
public int compareTo(Value v)
```
    Compare 'this' Vector to v, returning -ve (<), 0 (=), or +ve (>).
    
    Specified by:
    
    compareTo in interface java.lang.Comparable<Value>
    
    Overrides:
    
    compareTo in class Value
  - norm
```
public double norm()
```
    The Euclidean norm, ||v||=√(v.v), of 'this' Vector of Cts, that is, √sumSq().
  - norm_Cts
```
public Value.Cts norm_Cts()
```
    'This' Vector's Euclidean norm as a Value.Cts with nlAoM() being the Vector's divided by nElts(). Also see normalised.
  - sumSq
```
public double sumSq()
```
    Provided 'this' is a Vector of Cts, return the sum of squares, ∑_i elt(i).x()². This default iterates over the elements. Also see norm().
  - dot
```
public double dot(Vector v)
```
    The dot- (inner-) product of Vectors of Cts, 'this' and 'v'.
  - times
```
public Vector times(Matrix M)
```
    'this' Vector of Cts, v, as a row-Vector, times Matrix M, as in v M.
  - scaled
```
public Vector scaled(double s)
```
    Return 'this' Vector scaled by a factor, s. Note, AoM changes by ×s per element, e.g., if v.elt(i).x() is known to 0.001, v.scaled(10).elt(i).x() is known to 0.01.
  - normalised
```
public Vector normalised()
```
    Return 'this' Vector of Cts normalised to 1.0, which has implications for AoM(int) and nlAoM(). Note (i) AoM changes by ×1/norm() per element, and (ii) degrees of freedom reduce by one and hence nlAoM() reduces by a factor of (nElts-1)/nElts.
  - normalised1
```
protected Vector normalised1()
```
    Return 'this' Vector of Cts normalised by making a Vector of new (scaled) elements.
  - normalised2
```
protected Vector normalised2()
```
    Return 'this' Vector of Cts normalised but without copying the (scaled) elements.
  - repeat
```
public static Vector repeat(Value v,
                            int n)
```
    The Vector {v, v, ..., v}, n times.
  - slice
```
public Vector slice(int lo,
                    int hi)
```
    Return a Slice (section), [lo, hi), of 'this' Vector, that is, the elements between lo inclusive, and hi exclusive. Note that a copy is not made. Also see take, drop and Vector.Slice.slice(int, int).
  - take
```
public Vector take(int m)
```
    Return the first 'm' elements of 'this' Vector; see drop(int) and slice(int, int).
  - takeLast
```
public Vector takeLast(int m)
```
    Return the last 'm' elements of 'this' Vector; see slice(int, int).
  - drop
```
public Vector drop(int m)
```
    Return all but the first 'm' elements of 'this' Vector; see take(int) and slice(int, int).
  - drop
```
public Vector drop(int lo,
                   int hi)
```
    Drop elements [lo,hi) of 'this' Vector, lo inclusive, hi exclusive. Return take(lo).append(drop(hi)), e.g., [0,1,2,3,4].drop[1,3) → [0,3,4].
  - dropLast
```
public Vector dropLast(int m)
```
    Return all but the last 'm' elements of 'this' Vector; see slice(int, int).
  - combine
```
public Vector combine(boolean add,
                      Vector.Slice v)
```
    Either addMore (add=true) Vector 'v' to this or delete (add=false) v from this Vector.
  - delete
```
public Vector delete(Vector.Slice s)
```
    delete(s.parent(),s.lo,s.hi).
  - delete
```
public Vector delete(Vector v,
                     int lo,
                     int hi)
```
    Delete elements [lo, hi) of 'v' from 'this'; it requires (and checks) that v == this. The elements being deleted must in fact be in 'this' Vector. Also see Vector.Slice.delete(Vector,int,int). delete(v,lo,hi) and addMore(v,lo,hi) are used to create subsets of the elements of a Vector, e.g., sub-data-sets.
  - addMore
```
public Vector addMore(Vector.Slice s)
```
    addMore(s,0,s.nElts()).
  - addMore
```
public Vector addMore(Vector v,
                      int lo,
                      int hi)
```
    It is impossible, an error, to add more than zero elements (of 'v'==this) to 'this' Vector as they are all already there, but to a Slice is possible. Requires (and checks) that v == this. addMore(v,lo,hi) and delete(v,lo,hi) are used to create subsets of the elements of a Vector, e.g., sub-data-sets.
  - append
```
public Vector append(Vector v2)
```
    Append Vectors 'this' and 'v2', of the same type!
  - append
```
public Vector append()
```
    For 'this' non-empty Vector (data-set?) of Vectors, append them all, that is flatten k dimensions to (k-1) dimensions.
  - uOp
```
public Value uOp(int op)
```
    Unary operator, 'op', on 'this' Vector, that is apply op element-wise, returning a new Vector of results.
    
    Overrides:
    
    uOp in class Value
  - bOp
```
public Value bOp(int op,
                 Value v)
```
    Binary operator, 'op', on 'this' Vector, and 'v', that is apply op element-wise returning a Vector of results.
    
    Overrides:
    
    bOp in class Value
  - zip
```
public Vector zip(Vector v)
```
    zip 'this' Vector with another Vector 'v', of the same length, to produce a Vector of pairs as in, zip(new Vector [] {this, v}. Also see zip(cols) and unzip().
  - zip
```
public static Vector zip(Vector[] cols)
```
    zip several Vectors to make a Vector of Tuples. Elements are weighted as in cols[0]. Used by Value.Tuple.zip(). Also see zip(v) and unzip.
  unzip public Value.Tuple unzip() unzip 'this' Vector of Tuples into a Tuple of Vectors. Also see zip(v), zip(cols) and Tuple.zip(). unzip public Value.Tuple unzip(int nCol) unzip 'this' Vector of Tuples each of (must be) nCol elements. This variation on unzip() allows for 'this'=empty. map public Vector map(Function f) Apply Function 'f' to each element of 'this' Vector, returning a Vector of results. foldl public Value foldl(Function fc, Value z) foldl (fold-left, reduce) 'this' Vector with curried Function 'fc' and zero (identity) 'z', in effect ((((z fc e₀) fc e₁) ... ) fc e_n-1). Also see foldr(fx,z). foldl public Value foldl(Function fc) drop(1) .foldl(fc,elt(0)) foldr public Value foldr(Function fc, Value z) foldr (fold-right, reduce) 'this' Vector with curried Function 'fc' and zero (identity) 'z', in effect (e₀ fc ( ... (e_n-2 fc (e_n-1 fc z)))). Also see foldl(fc,z). foldr public Value foldr(Function fc) take(n_1) .foldr(fc,elt(n_1)), where n_1 = nElts() - 1. shape public int[] shape() For a Vector of Vector of Vec..., return the "nElts()" of the leading (hyper-)rectangular dimensions, e.g., a simple Vector would give [m], an m×n Matrix [m,n], etc., and a jagged Vector of Vectors [m]. nElts public int nElts(int row) Provided 'this' is a Vector of Value.Structured, return nElts() of elt(row). Also see nCols(). elt public Value elt(int r, int c) Provided 'this' is a Vector of Value.Structured, return the element at row 'r', column 'c'. col public Vector col(int c) Provided 'this' is a Vector of Value.Structured, return the c-th column, as a Vector. E.g., col(c) is used by Independent to select a column of a multivariate data-set. Also see cols(cs), columns plural. cols public Vector cols(int[] cs) Provided 'this' is a Vector of Value.Tuple, return the Vector of Tuples made up of the columns specified by cs. Also see col(c) and elts(ps). nCols public int nCols() Provided 'this' is a rectangular Vector of Structured, which property is checked within, return its number of columns, otherwise throw an error. Also see Matrix.nCols() and Matrix.nElts(int). asMatrix public Matrix asMatrix() Provided 'this' is a rectangular Vector of Vectors, return it as the equivalent Matrix; also see Matrix.asMatrix(). (Just a "type" change and no significant extra space is consumed.) as_1xn public Matrix as_1xn() Make a "row-Vector", i.e., a 1×n-Matrix, of 'this' Vector (regardless of the element type). Note that wt(0), for the single row, is 1.0. as_nx1 public Matrix as_nx1() Make a "column Vector", i.e., a n×1-Matrix, of 'this' Vector (regardless of the element type). asDiagonal public Matrix asDiagonal(Value z) Make a square, diagonal Matrix of 'this' Vector, using 'z' for all off-diagonal elements. isRectangular public boolean isRectangular() Provided 'this' is a Vector of Vectors, is it rectangular? That is, is it non-"jagged"? Also see isSquare(), and Matrix. rowLength public int rowLength() Provided this is a Vector of Vectors, if it is rectangular return its row length, else a negative int. isSquare public boolean isSquare() Provided 'this' is a Vector of Vectors, is it square? Also see isRectangular(). nearlySymmetric public boolean nearlySymmetric(double epsilon) Provided 'this' is a Vector of Vectors of Cts, is it square && (nearly-)symmetric? That is, are x[r][c] and x[c][r] nearlyEqual for all r and c? nearlySymmetric public boolean nearlySymmetric() Provided 'this' is a Vector of Vectors of Cts, return nearlySymmetric(Maths.epsilon). values public static Vector.GP values(Value[] vs) Convenience function, values : Value[] → GP. Also see the 2D Matrix.values(Value[][]). ints public static Vector ints(int[] ns) Convenience function, ints : int[] → Vector. Also see the 2D Matrix.ints(int[][]). ints public static Vector ints(Type.Discrete et, int[] ns) Convenience function to make a Vector with elements of Discrete Type et, and integer codes, ns. doubles public static Vector.Doubles doubles(double nlAoM, double[] xs) Convenience function : nlAoM × double[] → Vector, where we know the nlAoM of the Vector as a whole, but not of each elt(i). This may well be the case in estimating a Model's (Vector of) parameters, say. (And do not confuse it with doubles(double[],double). doubles public static Vector.Doubles doubles(double[] xs, double AoM) Convenience function : double[] × AoM → Vector, where every element of the Vector has the same AoM (do not confuse it with doubles(double,double[]). Also see the 2D Matrix.doubles(double[][],double). doubles public static Vector.Doubles doubles(double[] xs) Convenience function : double[] → Vector; note AoM=0. Also see the 2-D Matrix.doubles(double[][]). strings public static Vector.Strings strings(java.lang.String[] ss) Convenience function : String[] → Vector. rotate public Vector rotate(double t, Vector n) Given an angle, 't', in radians, and an axis, 'n', rotate 'this' 3D Vector by t about n. Calls rotate(q). rotate public Vector rotate(Q q) As specified by the quaternion, 'q', rotate 'this' 3D Vector by an angle about an axis. (Is called by rotate(t,n).) asQrotn public Q asQrotn() Make 'this' 3D Vector of Cts, (x, y, z), a quaternion (0.0, x, y, z). Note, asQrotn() is used in rotate(q). Also see asQ(). asQ public Q asQ() Make 'this' 4D Vector of Cts a quaternion in the obvious way. match public Q match(Vector t) Find the rotation (as a quaternion), by some angle about some axis through the origin, that minimises the sum of squared errors between the Vectors of 3D Vectors of Cts, 'this' and 't'. Also see [www]. csv public static Vector csv(boolean trimHead, boolean trimTail, char separator, Type.Tuple rowType, int skipLines, java.io.InputStream inp) Input a data-set of "comma-"separated values from a given InputStream (often a FileInputStream). Tuple Type 'rowType' gives the Type of one row, that is each Variable (column). Presently, allowed Variable Types are Discrete (Int, Bool, Enum, ...), Cts and CHARS (String). The separator is often ',' but can be (almost) any character. Leading and/or trailing white space can be trimmed from values. Zero or more leading lines can be skipped, e.g., a title or a comment. Values, and rows, may not be split across input lines. Makes use of Series.Lines and Series.Separator. csv public static Vector csv(Type.Tuple rowType, java.io.InputStream inp) csv(...) using some common default parameter values. 'inp' may be a FileInputStream. main public static void main(java.lang.String[] argv) main() allows Vector to be (slightly) tested, in isolation.

Class Vector

Nested Class Summary

Nested classes/interfaces inherited from class la.la.Value

Field Summary

Fields inherited from class la.la.Value

Constructor Summary

Method Summary

Methods inherited from class la.la.Value.Structured

Methods inherited from class la.la.Value

Methods inherited from class java.lang.Object

Field Detail

empty

Constructor Detail

Vector

Method Detail

opens

closes

type

nElts

elt

n

x

eltType

wt

constWt

constAoM

constNlAoM

nlAoM

nlAoM

AoM

nlAoM

wts

wts

wtMedian

wtNlAoM

wtNlAoM

elts

uniqueElts

singleton

toSeries

fromScannable

sorted

sorted

sorted

merge

weight

weight

weight

weightLike

weightLike

compareTo

norm

norm_Cts

sumSq

dot

times

scaled

normalised

normalised1

normalised2

repeat

slice

take

takeLast

drop

drop

dropLast

combine

delete

delete

addMore

addMore

append

append

uOp

bOp

zip

zip

unzip

unzip