SYNOPSIS OF AVAILABLE PROG UNIT IMPORT LIBRARIES:

color.so
color conversion routines
eigen.so
eigenvalue routines
em.so
EM algorithm for completion of missing values
id3.so
decision tree from data
hmm.so
hidden markov models (simple version)
la.so
some lapack routines
lpc.so
linear prediction and spectral estimation
math.so
some math functions, including lgamma() and atan2()
matrix.so
diagonalization for symmetric matrices
mds.so
multidimensional scaling (PCA, MDS, Sammon)
sonify.so
sonification routines
sound.so
audio extensions
solid.so
solid rendering into GL window of view3d or camera unit
nst.so
access other nst units

EIGENVECTOR ROUTINES:

Based on numerical library by H.T. Lau

Class eigen_c:

eigen_c(void)
constructor
spectrum(float *pfMatrix)
compute eigenvalues
eigbasis(float *pfMatrix)
compute eigenvalues and eigenvectors
pfMatrix must be a square matrix. After a call of either of the above routines the arrays below are automatically redimensioned with iDim being the row and column dimension of pfMatrix.

Class variables:

float eigvals_re[iDim]
real parts of eigenvalues
float eigvals_im[iDim]
imaginary parts of eigenvalues
float eigvecs_re[iDim*iDim]
matrix of eigenvectors (real parts), (i-th row is eigenvector for eigval[i])
float eigvecs_im[iDim*iDim]
dito, imaginary parts
maxiters
max nr of allowed QR iterations
maxeps
max tolerance

EM ALGORITHM:

Class nem:

class nem(void):
constructor

Class methods:

void data(int dim, float *data)
specify data array
void step(void)
Do EM step
void impute(void)
impute missing values

Class variables:

float *mean
estimated data mean vector
float *sigma
estimated data autocorrelation

ID3 DECISITION TREE:

Class id3:

id3_c(void)
constructor
~id3_c()
int mktree(int iColumnOfClass, int iDim, int iNum, float *pfData)
void iterate(char *pcFmt, void (*)(float*))
iterate function over nodes of tree and return with each call data selected by pcFmt
void prune(float fPrune)
void zoom(float fX, float fY, float fSx=2, float fSy=2, float fSx1=0, float fSy1=0)
int nodes(void)
int depth(void)
void print(void)
void define_labels(char *pcLabels, int iLen1=99, int iLen2=99)
int label(char *acBuf, int iWhich)
float classify(float *pfRow)
float classify(float *pfData, float *pfClass)
float evaluate(int iNum, float *pfData, int *piErrors)
float evaluate(int iNum, float *pfData, int *piErrors, int *piCases)

HMM - HIDDEN MARKOV MODEL:

Class hmm:

hmm(int iStates, int iSymbols, int iRndSeed=1234567)
constructor
estimate(int *piSymbols)"
estimate model
float analyse(int *piSymbols, int *piStates)
find most probable state sequence and return probability
generate(int *piSymbols, int *piStates)
generate a state sequence
print(void)
print model
float *A
iStates x iStates state transition matrix
float *B
iStates x iSymbols emission probabilities

MDS - MULTIDIMENSIONAL SCALING:

Class pca:

constructor pca(int iDim, float *pfData):
return instance for PCA on data set of iDim dimensional vectors
float *spectrum(void):
return pointer to array of iDim eigenvalues of data correlation matrix
float *map(float *pfData):
return pointer to newly allocated array of PCA-projections obtained from data rows (each of iDim elements) in pfData.
float *map(float *pfData, int iDim1):
return pointer to newly allocated array of PCA-projections obtained from data rows (each of iDim elements) in pfData and projected onto iDim1 first eigenvectors.
float *map(float *pfData, int iDim1, int iDim2):
return pointer to newly allocated array of PCA-projections obtained from data rows (each of iDim elements) in pfData and projected onto eigenvectors i in index range i=iDim1..iDim2-1.
float *mean
pointer to array of data means (writeable).
float *corr
pointer to iDim x iDim autocorrelation matrix of data (writeable).
float *topc(iDim1,iDim2)
pointer to newly allocated array of eigenvectors as rows to project data onto eigenvectors
float *proj(iDim1,iDim2)
pointer to newly allocated projection matrix into eigensubspace

Class mds:

constructor mds(float *pfDist):
return instance for MDS on N x N distance matrix pfDist
float *spectrum(void):
return pointer to array of N eigenvalues of MDS
float *map(int *iDim):
return pointer to newly allocated array of MDS-projection into iDim space
float variance(void):
return value of mapped variance (normalized to [0,1])

Class sammon:

constructor sammon(float *pfDist):
return instance for sammon map on N x N distance matrix pfDist
constructor sammon(int iDim, float *pfData):
return instance for sammon map on data rows (each of dimension iDim ) provided in matrix pfData.
float *map(int *iDim, int iMaxSteps=100, float fMaxStress=0.01):
return pointer to newly allocated array of sammon projection into iDim space (N points, each of dim iDim). Remaining optional parameters specify iteration parameters.
int steps():
number of iteration steps actually used
int num():
number of points mapped.

Further functions:

float *dist_from_pnts(int iDim, float *pfData):
return pointer to newly allocated N x N distance matrix, with N=dimof(pfData)/iDim. The distance matrix is computed from the rows of pfData, assuming each row of length iDim.
@MANEND

FILE

/amnt/loge/users/nistaff02/nistaff/rhaschke/nst7/man/../o.linux//../nstsrc/nst_prog_libs.c