void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
char *pOption = mxArrayToString( prhs[0] );
if ( pOption )
{
std::string option = pOption;
if ( option == "newRx" )
{
createMxArray(plhs[0], 1);
createMxArray(plhs[1], reinterpret_cast<long int>( new usrplib::Rx() ));
} else {
char *error;
sprintf(error, "Unrecognized option: %s", pOption);
}
} else {
mexErrMsgTxt("Invalid option type! Must be a string.");
}
}
/* pääfunktio ****************************/
void mexFunction(int nlhs, mxArray *plhs[],int nrhs, const mxArray *prhs[]) {
doubleMatrix trainingData, A, means, variances, weights;
double noiseLevel;
int numberOfIterations, updateDistributions;
int n, k, i, j, l;
/* parametrit */
trainingData = createDoubleMatrixMx(TRAININGDATA_IN);
A = createDoubleMatrixMx(A_IN);
means = createDoubleMatrixMx(MEANS_IN);
variances = createDoubleMatrixMx(VARIANCES_IN);
weights = createDoubleMatrixMx(WEIGHTS_IN);
noiseLevel = mxGetScalar(NOISELEVEL_IN);
numberOfIterations = (int)mxGetScalar(MAX_ITERATIONS_IN);
updateDistributions = (int)mxGetScalar(UPDATE_DISTRIBUTIONS);
/* globaaleiden muuttujien alustus */
numberOfGaussians = mxGetM(MEANS_IN);
dimensions = mxGetN(MEANS_IN);
numberOfObserved = mxGetM(TRAININGDATA_IN);
numberOfDataRows = mxGetN(TRAININGDATA_IN);
numberOfLatent = dimensions - numberOfObserved;
states = statelist();
numberOfStates = pow(numberOfGaussians,dimensions);
/* skaalaus */
doubleMatrix dummyA = createDoubleMatrix(numberOfObserved,dimensions);
rescaleModel(dummyA,means,variances,weights);
freeDoubleMatrix(dummyA);
/* virhefunktion arvot */
doubleMatrix objMatrix = createDoubleMatrix(2,numberOfIterations / RANGE);
l = 0;
n = dimensions*dimensions;
/* alustetaan globaalit matriisit */
matrixInitialize();
/* EM-algoritmin pääsilmukka */
for (k = 0;k < numberOfIterations;k++) {
/* painojen päivitys */
if (updateDistributions)
meanMarginalpstategivenx(weights, trainingData, A, means, variances, weights, noiseLevel);
/* A:n päivitys */
meanssgivenx(mgssx, mgsx, trainingData, A, means, variances, weights, noiseLevel);
multiplyABt(trainingData, mgsx, XmgsxTran);
multiplyConst(XmgsxTran,1.0 / numberOfDataRows, XmgsxTranDiv);
for (i = 0;i < n;i++)
IND(meanMgssx,i,0) = 0;
for (i = 0;i < n;i++)
for (j = 0;j < numberOfDataRows;j++)
IND(meanMgssx,i,0) += IND(mgssx,i,j) / numberOfDataRows;
for (i = 0;i < dimensions;i++)
for (j = 0;j < dimensions;j++)
IND(meanMgssx2,j,i) = IND(meanMgssx,i*dimensions+j,0);
inverse(meanMgssx2, invMeanMgssx);
multiply(XmgsxTranDiv, invMeanMgssx, A);
/* varianssien ja keskiarvojen päivitys */
if (updateDistributions) {
meanMarginalpstategivenx(mmpgx, trainingData, A, means, variances, weights, noiseLevel);
a11meanx2(ax2, ax, trainingData, A, means, variances, weights, noiseLevel);
for (i = 0;i < numberOfGaussians;i++)
for (j = 0;j < dimensions;j++)
IND(means,i,j) = IND(ax,i,j) / IND(mmpgx,i,j);
for (i = 0;i < numberOfGaussians;i++)
for (j = 0;j < dimensions;j++)
IND(variances,i,j) = IND(ax2,i,j) / IND(mmpgx,i,j)
- pow(IND(means,i,j),2);
}
/* skaalataan IF-malli */
rescaleModel(A,means,variances,weights);
if (k % RANGE == 0) {
/* tarkistetaan A:n validisuus (ei sisällä pelkästään nollia) */
/* if (!isValid(variances)) { */
if (IND(A,0,0) - NAN < EPSILON) {
/* jos ei enää validi, niin laitetaan tästä eteenpäin virhefunktiolle
vain Inf -arvoa */
while (l < numberOfIterations / RANGE) {
IND(objMatrix,0,l) = FLT_MAX;
IND(objMatrix,1,l++) = k;
}
/* tulostetaan varianssit ja häivytään silmukasta */
printDoubleMatrix(variances);
break;
} else {
IND(objMatrix,0,l) = evaluateObj(trainingData, A, means, variances, weights, noiseLevel);
IND(objMatrix,1,l++) = k;
}
}
}
/* vapautetaan globaaleiden matriisien varaama muisti*/
matrixFinalize();
/* ulostulot */
A_OUT = createMxArray(A);
MEANS_OUT = createMxArray(means);
VARIANCES_OUT = createMxArray(variances);
WEIGHTS_OUT = createMxArray(weights);
OBJ_OUT = createMxArray(objMatrix);
free2d(states,dimensions);
freeDoubleMatrix(trainingData);
freeDoubleMatrix(A);
freeDoubleMatrix(means);
freeDoubleMatrix(variances);
freeDoubleMatrix(weights);
freeDoubleMatrix(objMatrix);
return;
}
