Vector functions
Functions over vectors are divided into:
- Numerical vector functions operate on numerical vectors.
- Vector aggregate functions operate on collections (bags) of vectors.
- PCA functions do principal component analyses over collections (bags) of vectors.
- Sequence functions operate on vectors whose elements can be of aritrary type and need not be numerical.
- Plot functions utilize an external plot system (GNU-plot) to visualize the contents of collections of vectors.
Notice that the vselect statement provide a powerful mechanism for constructing new vectors through queries in terms of functions.
Numerical vector functions
The following operators over vectors x
and y
and number lambda
are defined:
operation | description | implemented as function |
---|---|---|
x + y |
element-wise addition | plus |
lambda + x |
add number to elements | plus |
x + lambda |
-"- | plus |
x - y |
element-wise subtractions | minus |
-x |
negate elements | uminus |
x - lambda |
subtract number from elements | minus |
lambda - x |
subtract elements from number | minus |
x * y |
scalar product | times |
x .* y |
element-wise multiplications | elemtimes |
lambda * x |
multiply elements with number | times |
x * lambda |
-"- | times |
x ./ y |
element-wise divisions | elemdiv |
x / lambda |
divide elements with number | div |
lambda / x |
divide number with elements | div |
x .^ lambda |
make power of elements | elempower |
The following functions operate on vectors of numbers:
signature | description |
---|---|
dim(Vector v) -> Integer |
number of elements |
div(Number lambda, Vector of number x) -> Vector of Number |
same as lambda/x |
div(Vector of number x, Number lambda) -> Vector of Number |
same as x/lambda |
elemdiv(Vector x, Vector y) -> Vector of Number |
same as x./y |
elempower(Vector of Number x, Number exp) -> Vector of Number |
same as x.^exp |
elemtimes(Vector x, Vector y) -> Vector of Number |
same as x.*y |
euclid(Vector of Number p1, Vector of Number p2) -> Real |
Euclidean distance |
maxnorm(Vector of Number p1, Vector of Number p2) -> Real |
maxnorm distance |
median(Vector of Number v) -> Number |
median of elements |
minkowski(Vector of Number p1, Vector of Number p2, Real r) -> Real |
Minkowski distance |
minus(Vector of Number x, Vector of Number y) -> Vector of Number |
same as x-y |
minus(Number lambda, Vector of Number x) -> Vector of Number |
same as lambda-x |
minus(Vector of Number x, Number lambda) -> Vector of Number |
same as x-lambda |
ones(Number n) -> Vector of Number |
vector of n ones |
plus(Vector of Number x, Vector of Number y) -> Vector of Number |
same as x+y |
plus(Number lambda, Vector of Number x) -> Vector of Number |
same as lambda*x |
plus(Vector of Number x, Number lambda) -> Vector of Number |
same as x*lambda |
roundto(Vector of Number v, Integer d) -> Vector of Number |
round elements to d digits |
times(Vector x, Vector y) -> Number |
same as x*y |
times(Number lambda, Vector of Number x) -> Vector of Number |
same as lambda*x |
times(Vector of Number x, Number lambda) -> Vector of Number |
same as x*lambda |
vavg(Vector of Number v) -> Real |
average of elements |
vstdev(Vector of Number v) -> Real |
standard deviation of elements |
zeros(Number n) -> Vector of Number |
vector of n zeros |
Descriptions:
Compute the size of a vector:
dim(Vector v) -> Integer d
For example dim({1,2,3});
returns 3
.
Division between vector elements and number:
div(Vector of number x, Number lambda) -> Vector of Number
div(Number lambda, Vector of number x) -> Vector of Number
Same as x/lambda
and lambda/x
.
Examples:
{1,2,3}/2;
returns {0.5,1.0,1.5}
3/{1,2,3};
returns {3,1.5,1}
Divide vectors element by element:
elemdiv(Vector x, Vector y) -> Vector of Number r
Same as x./y
.
Example:
{1,2,3}./{4,5,6};
returns {0.25,0.4,0.5}
.
Raise each element to a given exponent:
elempower(Vector of Number x, Number exp) -> Vector of Number r
Same as x.^exp
.
Example:
{1,2,3}.^2;
returns {1,4,9}
.
Multiply vectors element by element:
elemtimes(Vector x, Vector y) -> Vector of Number r
Same as x.*y
.
Example:
{1,2,3}.*{4,5,6};
returns {4,10,18}
.
Compute the Euclidean distance between two points p1
and p2
:
euclid(Vector of Number p1, Vector of Number p2) -> Real d
Example:
euclid({1,10},{-1,2});
returns 8.24621125123532
.
Compute the maxnorm distance between two points:
maxnorm(Vector of Number p1, Vector of Number p2) -> Real d
Conceptually, this is the same as the Minkowski distance with r = infinity
.
Example:
maxnorm({1,10},{-1,2});
returns 8.0
.
Compute the median of a vector of numbers:
median(Vector of Number v) -> Number m
Example:
median({1,2,4});
returns 2.0
.
Compute the Minkowski distance between two points:
minkowski(Vector of Number p1, Vector of Number p2, Real r) -> Real d
Examples:
minkowski({1,10},{-1,2},2);
returns 8.24621125123532
, same as euclid({1,10},{-1,2});
.
minkowski({1,10},{-1,2},8);
returns 8.0000152586872
.
Subtract vectors and numbers:
minus(Vector of number x, Vector of number y) -> Vector of Number
minus(Number lambda, Vector of Number x) -> Vector of Number
minus(Vector of Number x, Number lambda) -> Vector of Number
Same as x-y
, lambda-x
, and x-lambda
.
Examples:
{1,2,3}-{4,5,6};
returns {-3,-3,-3}
.
5-{1,2,3};
returns {4,3,2}
.
{1,2,3}-5;
returns {-4,-3,-2}
.
Make vector of ones:
ones(Number dim)-> Vector of Number
Example:
ones(3);
returns {1,1,1}
.
Add vectors and numbers:
plus(Vector of Number x, Vector of Number y) -> Vector of Number
plus(Number lambda, Vector of Number x) -> Vector of Number
plus(Vector of Number x, Number lambda) -> Vector of Number
Same as x+y
, lambda+x
, and x+lambda
.
Examples:
{1,2,3}+{4,5,6};
returns {5,7,9}
.
4+{1,2,3};
returns {5,6,7}
.
{1,2,3}+4;
returns {5,6,7}
.
Round each element in a vector of numbers a number of decimals:
roundto(Vector of Number v, Integer d) -> Vector of Number r
Example:
roundto({3.14159,2.71828},2);
returns {3.14,2.72}
.
Multiply vectors and numbers:
times(Vector of Number x, Vector of Number y) -> Number
times(Number lambda, Vector of Number x) -> Vector of Number
times(Vector of Number x, Number lambda) -> Vector of Number
Same as x*y
, lambda*x
, and x*lambda
.
Examples:
{1,2,3}*{4,5,6};
returns 32
.
4*{1,2,3};
returns {4,8,12}
.
{1,2,3}*4;
returns {4,8,12}
.
Compute the average value a vector elements:
vavg(Vector of Number v) -> Real a
Example:
vavg({1,2,3});
returns 2.0
.
Compute the standard deviation vector elements:
vstdev(Vector of Number v) -> Real s
Example:
vstdev({1,2,3});
returns 1.0
.
Make vector of zeros:
zeros(Number dim)-> Vector of Number
Example:
zeros(3);
return {0,0,0}
.
Vector aggregate functions
The following functions group and compute aggregate values over collections of numerical vectors:
aggv(Bag of Vector v, Function aggfn) -> Vector Roll up
maxmin(Bag of Vector of Number b) -> Bag of Vector of Number
meansub(Bag of Vector of Number b) -> Bag of Vector of Number
zscore(Bag of Vector of Number b) -> Bag of Vector of Number
Dimension-wise aggregates over bags of vectors can be computed using the function aggv()
:
aggv(Bag of Vector, Function) -> Vector
Example:
aggv((select {i, i + 10}
from Integer i
where i in iota(1, 10)), #'avg');
returns {5.5, 15.5}
.
Each dimension in a bag of vector of number can be normalized using one of the normalization functions meansub()
, zscore()
, or maxmin()
:
meansub(Bag of Vector of Number b) -> Bag of Vector of Number
zscore(Bag of Vector of Number b) -> Bag of Vector of Number
maxmin(Bag of Vector of Number b) -> Bag of Vector of Number
meansub()
transforms each dimension to a N(0, s)
distribution
(assuming that the dimension was N(u, s)
distributed) by subtracting
the mean u of each dimension.
zscore()
transforms each dimension to a N(0, 1)
distribution by
also dividing by the standard deviation of each dimension.
maxmin()
transforms each dimension to be on the [0, 1]
interval by
applying the transformation (w - min) ./ (max - min)
to each vector
w in bag b where max and min are computed using aggv(b, #' maxagg')
and aggv(b, #'minagg')
respectively.
Example:
meansub((select {i, i/2 + 10}
from Integer i
where i in iota(1, 5)));
returns the bag:
{-2.0,-1.0}
{-1.0,-0.5}
{0.0,0.0}
{1.0,0.5}
{2.0,1.0}
Principal Component Analysis
Principal Component Analysis is performed using these functions:
lpcascore(Bag of (Vector of Number, Object label), Integer d)
-> (Vector of Number score, Object label)
pca(Bag of Vector data)
-> (Vector of Number eigval D, Vector of Vector of Number eigvec W)
pcascore(Bag of Vector of Number, Integer d) -> Vector of Number score
pca()
takes a bag of M-dimensional vectors in data and computes the
MxM covariance matrix C of the input vectors. Then, pca()
computes
the M eigenvalues D and the MxM eigenvector matrix W of the covariance
matrix. pca()
returns the eigenvalues D and their corresponding
eigenvectors W.
To use pca()
to reduce the dimensionality to the L most significant dimensions, each input vector must be projected onto the eigenvectors corresponding to the L greatest eigenvalues using the scalar product. This is done using the function pcascore()
:
pcascore(Bag of Vector of Number, Integer d) -> Vector of Number score
pcascore()
performs PCA on data, and projects each data vector in data onto the d first eigenvectors. Each projected vector in data is emitted.
The function lpcascore()
allows a label to be passed along with each vector:
lpcascore(Bag of (Vector of Number, Object label), Integer d) -> (Vector of Number score, Object label)
The label of each vector remains unchanged during projection.
Note that the input data might have to be pre-processed, using some vector normalization.
Non-numerical vector functions
The following functions work of vectors (i.e. sequences) containing any kinds of elements:
concat(Vector x, Vector y) -> Vector concatenate vectors
project(Vector v, Vector of Number pv) -> Vector project positions
Concatenate two vectors:
concat(Vector x, Vector y) -> Vector r
Example:
concat({1,2,3},{4,5,6});
returns {1,2,3,4,5,6}
.
Project vector elements:
project(Vector v, Vector of Number pv) -> Vector r
pv
is a vector of indices of the projected elements in v
.
Example:
project({10,20,30,40},{0,3,2});
returns {10,40,30}
.
Plotting numerical data
sa.amos can utilize GNU Plot (v 4.2 or above), to plot numerical
data. The plot()
function is used to plot a line connecting
two-dimensional points. Each vector in the vector v
is a data
point. plot(v)
will plot the points in the order they appear in v
.
Signature:
plot(Vector of Vector v) -> Integer
The return value is the exit code of the plot program. A nonzero value indicates error.
If the data points have a higher dimensionality than two, the optional argument projs is used to select the dimension to be plotted. Signature:
plot(Vector of Integer projs, Vector of Vector v) -> Integer
The projs
vector lists the dimensions onto which each data vector
v
is to be projected. The first dimension has number 0 (zero).
Scatter plots of bags of two-dimensional vectors are generated using scatter2()
.
scatter2p()
and scatter2l()
plots three-dimensional data in two dimensions. scatter2p()
assigns a color temperature of each point according to the value of its value in the third dimension. scatter2l()
labels each point in the two-dimensional plot with the its value of the third dimension. The value of the third dimension in scatter2l()
could be numerical or textual.
Three-dimensional scatter plots are generated using scatter3()
, scatter3l()
, and scatter3p()
. scatter3()
plots 3-dimensional data, whereas scatter3l()
and scatter3p()
plot 4-dimensional data in the same fashion as scatter2p()
and scatter2l()
.
Signatures
scatter2(Bag of Vector v) -> Integer
scatter2l(Bag of Vector v) -> Integer
scatter2p(Bag of Vector v) -> Integer
scatter3(Bag of Vector v) -> Integer
scatter3l(Bag of Vector v) -> Integer
scatter3p(Bag of Vector v) -> Integer
scatter2(Vector of Integer projs, Bag of Vector v) -> Integer
scatter2l(Vector of Integer projs, Bag of Vector v) -> Integer
scatter2p(Vector of Integer projs, Bag of Vector v) -> Integer
scatter3(Vector of Integer projs, Bag of Vector v) -> Integer
scatter3l(Vector of Integer projs, Bag of Vector v) -> Integer
scatter3p(Vector of Integer projs, Bag of Vector v) -> Integer