operation on Vector More...
#include <stdio.h>
#include <s3types.h>
#include <logmath.h>
Go to the source code of this file.
Classes | |
struct | arraysize_t |
wrapper of array size More... | |
struct | point_t |
wrapper of a point in integer More... | |
struct | fpoint_t |
struct | vector_gautbl_t |
Typedefs | |
typedef float32 * | vector_t |
Functions | |
void | vector_floor (vector_t v, int32 dim, float64 f) |
void | vector_nz_floor (vector_t v, int32 dim, float64 f) |
int32 | vector_normalize (vector_t v, uint32 dim) |
float64 | vector_sum_norm (vector_t v, int32 dim) |
S3DECODER_EXPORT void | vector_print (FILE *fp, vector_t v, int32 dim) |
S3DECODER_EXPORT int32 | vector_is_zero (float32 *vec, int32 len) |
int32 | vector_is_nan (float32 *vec, int32 len) |
int32 | vector_maxcomp_int32 (int32 *val, int32 len) |
int32 | vector_mincomp_int32 (int32 *val, int32 len) |
int32 | vector_maxcomp_float32 (float32 *val, int32 len) |
int32 | vector_mincomp_float32 (float32 *val, int32 len) |
void | vector_accum (float32 *dst, float32 *src, int32 len) |
int32 | vector_cmp (float32 *v1, float32 *v2, int32 len) |
int32 | vector_mean (float32 *mean, float32 **data, int32 n_vec, int32 n_dim) |
float64 | vector_dist_eucl (float32 *v1, float32 *v2, int32 len) |
float64 | vector_maha_precomp (float32 *var, int32 len) |
float64 | vector_dist_maha (float32 *vec, float32 *mean, float32 *varinv, float64 norm, int32 len) |
S3DECODER_EXPORT float64 | vector_vqgen (float32 **data, int32 rows, int32 cols, int32 vqrows, float64 epsilon, int32 maxiter, float32 **mean, int32 *map, int32 seed) |
int32 | vector_vqlabel (float32 *vec, float32 **mean, int32 rows, int32 cols, float64 *sqerr) |
float64 | vector_pdf_entropy (float32 *p, int32 len) |
float64 | vector_pdf_cross_entropy (float32 *p1, float32 *p2, int32 len) |
void | vector_gautbl_alloc (vector_gautbl_t *gautbl, int32 n_gau, int32 veclen, logmath_t *logmath) |
void | vector_gautbl_free (vector_gautbl_t *gautbl) |
void | vector_gautbl_var_floor (vector_gautbl_t *gautbl, float64 floor) |
void | vector_gautbl_maha_precomp (vector_gautbl_t *gau) |
void | vector_gautbl_eval_logs3 (vector_gautbl_t *gau, int32 offset, int32 count, float32 *x, int32 *scr, logmath_t *logmath) |
operation on Vector
typedef float32* vector_t |
void vector_accum | ( | float32 * | dst, | |
float32 * | src, | |||
int32 | len | |||
) |
Accumulate src into dst
dst | In/Out: dst[i] += src[i] | |
src | In: See above | |
len | In: Length of above vectors |
int32 vector_cmp | ( | float32 * | v1, | |
float32 * | v2, | |||
int32 | len | |||
) |
Compare the two given vectors.
v2 | In: Vectors to be compared | |
len | In: Length of each vector |
float64 vector_dist_eucl | ( | float32 * | v1, | |
float32 * | v2, | |||
int32 | len | |||
) |
Return the Euclidean distance (actually, distance^2) between the two given vectors.
v2 | In: The two input vectors | |
len | In: Length of each vector |
float64 vector_dist_maha | ( | float32 * | vec, | |
float32 * | mean, | |||
float32 * | varinv, | |||
float64 | norm, | |||
int32 | len | |||
) |
Mahalanobis distance, using some precomputed portions of variance and determinant. (Actually not "distance" at all, but Gaussian density value.) Computed in log domain. Return value: logbase-e(likelihood value).
vec | In: Vector for which distance from mean being computed | |
mean | In: Mean vector | |
varinv | In: Variance vector, modified according to vector_maha_precomp() | |
norm | In: Normalization factor computed by vector_maha_precomp() | |
len | In: Length of each vector involved |
void vector_floor | ( | vector_t | v, | |
int32 | dim, | |||
float64 | f | |||
) |
The reason for some of the "trivial" routines below is that they could be OPTIMIZED for SPEED at some point. Floor all elements of v[0..dim-1] to min value of f
v | The vector | |
dim | The dimension of the vector | |
f | The floor value |
void vector_gautbl_alloc | ( | vector_gautbl_t * | gautbl, | |
int32 | n_gau, | |||
int32 | veclen, | |||
logmath_t * | logmath | |||
) |
The obvious allocation and free routines for vector_gautbl_t.{mean,var,lrd}. Also sets gautbl->{n_mgau, veclen, distfloor}; the last to the equivalent of S3_LOGPROB_ZERO.
void vector_gautbl_eval_logs3 | ( | vector_gautbl_t * | gau, | |
int32 | offset, | |||
int32 | count, | |||
float32 * | x, | |||
int32 * | scr, | |||
logmath_t * | logmath | |||
) |
Compare the input vector to the given range of subvector codewords in the given codebook, Enter the computed Mahalanobis distances, converted into logs3 values, into the given score array. (Why bother with the {offset,count} range?? For "blocking" such computation so that cache behaviour is improved.)
gau | In: Table of Gaussians | |
offset | In: First VQ codeword in the range to be evaluated | |
count | In: #Codewords to be evaluated (range size) | |
x | In: Input vector being compared to codewords | |
scr | Out: Mahalanobis distance scores (logs3 values). Caller must allocate this array. Note that only score[offset..offset+count-1] are updated. |
void vector_gautbl_free | ( | vector_gautbl_t * | gautbl | ) |
void vector_gautbl_maha_precomp | ( | vector_gautbl_t * | gau | ) |
Carry out the vector_maha_precomp, above, over all the Gaussians in the given table, updating gau->lrd[] as a result. The needed memory must have been already allocated by the caller.
void vector_gautbl_var_floor | ( | vector_gautbl_t * | gautbl, | |
float64 | floor | |||
) |
Floor all the variance values in the given Gaussians table.
gautbl | In/Out: Table to be updated | |
floor | In: Floor value |
int32 vector_is_nan | ( | float32 * | vec, | |
int32 | len | |||
) |
Return TRUE iff one of the component of the vector is nan
vec | In: Vector to be checked | |
len | In: Length of above vector |
S3DECODER_EXPORT int32 vector_is_zero | ( | float32 * | vec, | |
int32 | len | |||
) |
Return TRUE iff given vector is all 0.0
vec | In: Vector to be checked | |
len | In: Length of above vector |
Referenced by main(), and mgau_var_nzvec_floor().
float64 vector_maha_precomp | ( | float32 * | var, | |
int32 | len | |||
) |
Given a Gaussian density with mean vector m and diagonal variance vector v, and some input vector x, all of length n, the Mahalanobis distance of x from the Gaussian mean m is given by: {1/sqrt((2pi)^n * det(v))} * exp{-Sum((x[i] - m[i])^2 / (2v[i]))} To speed up this evaluation, the first sub-expression ({1/sqrt...}) can be precomputed at initialization, and so can 1/2v[i] in the second sub-expression. Secondly, recognition systems work with log-likelihood values, so these distances or likelihood values are computed in log-domain.
Carry out the above precomputations on the given variance vector; update var with 1/2var IN PLACE, and return the value of the first sub-expression as a log value. (The variance values are assumed to be strictly > 0.0.
var | In/Out: Variance vector, modified to 1/2var | |
len | In: Length of the above vector |
int32 vector_maxcomp_float32 | ( | float32 * | val, | |
int32 | len | |||
) |
int32 vector_maxcomp_int32 | ( | int32 * | val, | |
int32 | len | |||
) |
Search for the max or min valued component in the given vector. The vector length must be strictly > 0 (val[] must have at least one valid value). If more than one component qualifies, the first one is chosen. Return value: the INDEX of the selected val[] component (not the value itself).
int32 vector_mean | ( | float32 * | mean, | |
float32 ** | data, | |||
int32 | n_vec, | |||
int32 | n_dim | |||
) |
Compute the mean vector from the given set of vector data.
mean | Out: Computed mean; caller should allocate this memory | |
data | In: Set of data over which mean is computed | |
n_vec | In: #Vectors in data | |
n_dim | In: Dimensionality of each vector (and mean) |
int32 vector_mincomp_float32 | ( | float32 * | val, | |
int32 | len | |||
) |
int32 vector_mincomp_int32 | ( | int32 * | val, | |
int32 | len | |||
) |
int32 vector_normalize | ( | vector_t | v, | |
uint32 | dim | |||
) |
Normalize the vector.
v | The vector | |
dim | The dimension of the vector |
void vector_nz_floor | ( | vector_t | v, | |
int32 | dim, | |||
float64 | f | |||
) |
Floor all non-0 elements of v[0..dim-1] to min value of f
float64 vector_pdf_cross_entropy | ( | float32 * | p1, | |
float32 * | p2, | |||
int32 | len | |||
) |
Return cross-entropy of two PDFs; like vector_entropy, but (-sum(p1 * log2(p2))). (The PDF values must be >= 0.0, of course.) The zero elements of p2 are skipped.
p2 | In: Zero elements of p2 are skipped |
float64 vector_pdf_entropy | ( | float32 * | p, | |
int32 | len | |||
) |
Treat the given vector as a PDF and compute its entropy (-sum(p * log2(p))). (The PDF values must be >= 0.0, of course.) The zero elements of the PDF are skipped.
p | In: Vector (PDF) whose entropy is to be computed | |
len | In: Length of p[] |
S3DECODER_EXPORT void vector_print | ( | FILE * | fp, | |
vector_t | v, | |||
int32 | dim | |||
) |
Print vector in one line, in 11.4e format, terminated by newline
Referenced by main().
float64 vector_sum_norm | ( | vector_t | v, | |
int32 | dim | |||
) |
Normalize the elements of the given vector so that they sum to 1.0. If the sum is 0.0 to begin with, the vector is left untouched. @ The normalization factor.
S3DECODER_EXPORT float64 vector_vqgen | ( | float32 ** | data, | |
int32 | rows, | |||
int32 | cols, | |||
int32 | vqrows, | |||
float64 | epsilon, | |||
int32 | maxiter, | |||
float32 ** | mean, | |||
int32 * | map, | |||
int32 | seed | |||
) |
Generate a vector quantized table for the input data, using the K-means algorithm, and the Euclidean distance measure. Return value: The squared quantization error of the final result.
data | In: Input Data to be quantized | |
rows | In: #Rows in input data | |
cols | In: #Cols in input data (and output VQ table) | |
vqrows | In: #Rows in vector quantized result | |
epsilon | In: Convergence limit; stop k-means iterations when the relative reduction in total squared error in successive iterations ((sqerr[t]-sqerr[t+1])/sqerr[t]) is below this value. | |
maxiter | In: Max #iterations, regardless of convlimit | |
mean | Out: Vector quantized array of centroids. Caller must allocate this array | |
map | Out: data->mean mapping; mean[map[i]] is the closest quantized vector corresponding to the input vector data[i]. Caller must allocate this array | |
seed | In : The seed for a random generator if it is smaller than 0, use the internal mechanism to generate seed. else use the seed to seed the random generator. |
Referenced by main().
int32 vector_vqlabel | ( | float32 * | vec, | |
float32 ** | mean, | |||
int32 | rows, | |||
int32 | cols, | |||
float64 * | sqerr | |||
) |
Find the entry (row) of mean that is closest (according to Euclidean distance) to vec. Return value: index of the selected row.
vec | In: Vector to be compared against VQ table | |
mean | In: Table of centroids | |
rows | In: #Rows in mean | |
cols | In: #Cols in mean (and vec) | |
sqerr | Out: Squared error (distance) between vec and the selected codeword. May be NULL if not needed. |