static MLPGPARA xmlpgpara_init(int dim, int dim2, int dnum,
int clsnum)
{
MLPGPARA param;
// memory allocation
param = mlpg_alloc(1,struct MLPGPARA_STRUCT);
param->ov = xdvalloc(dim);
param->iuv = NODATA;
param->iumv = NODATA;
param->flkv = xdvalloc(dnum);
param->stm = NODATA;
param->dltm = xdmalloc(dnum, dim2);
param->pdf = NODATA;
param->detvec = NODATA;
param->wght = xdmalloc(clsnum, 1);
param->mean = xdmalloc(clsnum, dim);
param->cov = NODATA;
param->clsidxv = NODATA;
/* dia_flag */
param->clsdetv = xdvalloc(1);
param->clscov = xdmalloc(1, dim);
param->vdet = 1.0;
param->vm = NODATA;
param->vv = NODATA;
param->var = NODATA;
return param;
}
static void sm_mvav(DMATRIX mat, long hlen)
{
long k, l, m, p;
double d, sd;
DVECTOR vec = NODATA;
DVECTOR win = NODATA;
vec = xdvalloc(mat->row);
// smoothing window
win = xdvalloc(hlen * 2 + 1);
for (k = 0, d = 1.0, sd = 0.0; k < hlen; k++, d += 1.0) {
win->data[k] = d; win->data[win->length - k - 1] = d;
sd += d + d;
}
win->data[k] = d; sd += d;
for (k = 0; k < win->length; k++) win->data[k] /= sd;
for (l = 0; l < mat->col; l++) {
for (k = 0; k < mat->row; k++) {
for (m = 0, vec->data[k] = 0.0; m < win->length; m++) {
p = k - hlen + m;
if (p >= 0 && p < mat->row)
vec->data[k] += mat->data[p][l] * win->data[m];
}
}
for (k = 0; k < mat->row; k++) mat->data[k][l] = vec->data[k];
}
xdvfree(win);
xdvfree(vec);
return;
}
// diagonal covariance
static DVECTOR xget_detvec_diamat2inv(DMATRIX covmat) // [num class][dim]
{
long dim, clsnum;
long i, j;
double det;
DVECTOR detvec = NODATA;
clsnum = covmat->row;
dim = covmat->col;
// memory allocation
detvec = xdvalloc(clsnum);
for (i = 0; i < clsnum; i++) {
for (j = 0, det = 1.0; j < dim; j++) {
det *= covmat->data[i][j];
if (det > 0.0) {
covmat->data[i][j] = 1.0 / covmat->data[i][j];
} else {
cst_errmsg("error:(class %ld) determinant <= 0, det = %f\n", i, det);
xdvfree(detvec);
return NODATA;
}
}
detvec->data[i] = det;
}
return detvec;
}
DVECTOR xdvinit(double j, double incr, double n)
{
long k;
long num;
DVECTOR x;
if ((incr > 0.0 && j > n) || (incr < 0.0 && j < n)) {
x = xdvnull();
return x;
}
if (incr == 0.0) {
num = (long)n;
if (num <= 0) {
x = xdvnull();
return x;
}
} else {
num = LABS((long)((n - j) / incr)) + 1;
}
/* memory allocate */
x = xdvalloc(num);
/* initailize data */
for (k = 0; k < x->length; k++) {
x->data[k] = j + (k * incr);
}
return x;
}
DVECTOR xdvcut(DVECTOR x, long offset, long length)
{
long k;
long pos;
DVECTOR y;
y = xdvalloc(length);
if (x->imag != NULL) {
dvialloc(y);
}
for (k = 0; k < y->length; k++) {
pos = k + offset;
if (pos >= 0 && pos < x->length) {
y->data[k] = x->data[pos];
if (y->imag != NULL) {
y->imag[k] = x->imag[pos];
}
} else {
y->data[k] = 0.0;
if (y->imag != NULL) {
y->imag[k] = 0.0;
}
}
}
return y;
}
