// Does vector=TRUE mean something sensible? Mixture of mixtures?
void state::init()
{
auto *oo = this;
auto *ms = this;
if (!oo->expectation) { mxThrow("%s requires an expectation", oo->fitType); }
oo->units = FIT_UNITS_MINUS2LL;
oo->canDuplicate = true;
omxState *currentState = oo->matrix->currentState;
const char *myex1 = "MxExpectationHiddenMarkov";
const char *myex2 = "MxExpectationMixture";
if (!expectation || !(strEQ(expectation->expType, myex1) ||
strEQ(expectation->expType, myex2)))
mxThrow("%s must be paired with %s or %s", oo->name(), myex1, myex2);
ProtectedSEXP Rverbose(R_do_slot(oo->rObj, Rf_install("verbose")));
ms->verbose = Rf_asInteger(Rverbose);
ProtectedSEXP Rcomponents(R_do_slot(oo->rObj, Rf_install("components")));
int nc = Rf_length(Rcomponents);
int *cvec = INTEGER(Rcomponents);
componentUnits = FIT_UNITS_UNINITIALIZED;
for (int cx=0; cx < nc; ++cx) {
omxMatrix *fmat = currentState->algebraList[ cvec[cx] ];
if (fmat->fitFunction) {
omxCompleteFitFunction(fmat);
auto ff = fmat->fitFunction;
if (ff->units != FIT_UNITS_PROBABILITY) {
omxRaiseErrorf("%s: component %s must be in probability units",
oo->name(), ff->name());
return;
}
if (componentUnits == FIT_UNITS_UNINITIALIZED) {
componentUnits = ff->units;
} else if (ff->units != componentUnits) {
omxRaiseErrorf("%s: components with heterogenous units %s and %s in same mixture",
oo->name(), fitUnitsToName(ff->units), fitUnitsToName(componentUnits));
}
}
ms->components.push_back(fmat);
}
if (componentUnits == FIT_UNITS_UNINITIALIZED) componentUnits = FIT_UNITS_PROBABILITY;
ms->initial = expectation->getComponent("initial");
ms->transition = expectation->getComponent("transition");
}
void MarkovExpectation::init()
{
ProtectedSEXP Rverbose(R_do_slot(rObj, Rf_install("verbose")));
verbose = Rf_asInteger(Rverbose);
ProtectedSEXP Rcomponents(R_do_slot(rObj, Rf_install("components")));
int *cvec = INTEGER(Rcomponents);
int nc = Rf_length(Rcomponents);
for (int cx=0; cx < nc; ++cx) {
components.push_back(omxExpectationFromIndex(cvec[cx], currentState));
}
if (isMixtureInterface) {
initial = omxNewMatrixFromSlot(rObj, currentState, "weights");
transition = 0;
} else {
initial = omxNewMatrixFromSlot(rObj, currentState, "initial");
transition = omxNewMatrixFromSlot(rObj, currentState, "transition");
}
ProtectedSEXP Rscale(R_do_slot(rObj, Rf_install("scale")));
auto scaleName = CHAR(STRING_ELT(Rscale, 0));
if (strEQ(scaleName, "softmax")) {
scale = SCALE_SOFTMAX;
} else if (strEQ(scaleName, "sum")) {
scale = SCALE_SUM;
} else if (strEQ(scaleName, "none")) {
scale = SCALE_NONE;
} else {
Rf_error("%s: unknown scale '%s'", name, scaleName);
}
scaledInitial = omxInitMatrix(1, 1, TRUE, currentState);
scaledTransition = 0;
if (transition) {
scaledTransition = omxInitMatrix(1, 1, TRUE, currentState);
}
}
void omxLISRELExpectation::init() {
if(OMX_DEBUG) { mxLog("Initializing LISREL Expectation."); }
slope = 0;
verbose = 0;
if (R_has_slot(rObj, Rf_install("verbose"))) {
ProtectedSEXP Rverbose(R_do_slot(rObj, Rf_install("verbose")));
verbose = Rf_asInteger(Rverbose);
}
int nx, nxi, ny, neta, ntotal;
SEXP slotValue;
/* Create and fill expectation */
omxLISRELExpectation *LISobj = this;
/* Set up expectation structures */
if(OMX_DEBUG) { mxLog("Initializing LISREL Meta Data for expectation."); }
if(OMX_DEBUG) { mxLog("Processing LX."); }
LISobj->LX = omxNewMatrixFromSlot(rObj, currentState, "LX");
if(OMX_DEBUG) { mxLog("Processing LY."); }
LISobj->LY = omxNewMatrixFromSlot(rObj, currentState, "LY");
if(OMX_DEBUG) { mxLog("Processing BE."); }
LISobj->BE = omxNewMatrixFromSlot(rObj, currentState, "BE");
if(OMX_DEBUG) { mxLog("Processing GA."); }
LISobj->GA = omxNewMatrixFromSlot(rObj, currentState, "GA");
if(OMX_DEBUG) { mxLog("Processing PH."); }
LISobj->PH = omxNewMatrixFromSlot(rObj, currentState, "PH");
if(OMX_DEBUG) { mxLog("Processing PS."); }
LISobj->PS = omxNewMatrixFromSlot(rObj, currentState, "PS");
if(OMX_DEBUG) { mxLog("Processing TD."); }
LISobj->TD = omxNewMatrixFromSlot(rObj, currentState, "TD");
if(OMX_DEBUG) { mxLog("Processing TE."); }
LISobj->TE = omxNewMatrixFromSlot(rObj, currentState, "TE");
if(OMX_DEBUG) { mxLog("Processing TH."); }
LISobj->TH = omxNewMatrixFromSlot(rObj, currentState, "TH");
if(OMX_DEBUG) { mxLog("Processing TX."); }
LISobj->TX = omxNewMatrixFromSlot(rObj, currentState, "TX");
if(OMX_DEBUG) { mxLog("Processing TY."); }
LISobj->TY = omxNewMatrixFromSlot(rObj, currentState, "TY");
if(OMX_DEBUG) { mxLog("Processing KA."); }
LISobj->KA = omxNewMatrixFromSlot(rObj, currentState, "KA");
if(OMX_DEBUG) { mxLog("Processing AL."); }
LISobj->AL = omxNewMatrixFromSlot(rObj, currentState, "AL");
LISobj->noLY = LISobj->LY == NULL;
if(LISobj->noLY) {
LISobj->LY = omxInitMatrix(0, 0, TRUE, currentState);
LISobj->PS = omxInitMatrix(0, 0, TRUE, currentState);
LISobj->BE = omxInitMatrix(0, 0, TRUE, currentState);
LISobj->TE = omxInitMatrix(0, 0, TRUE, currentState);
}
LISobj->noLX = LISobj->LX == NULL;
if(LISobj->noLX) {
LISobj->LX = omxInitMatrix(0, 0, TRUE, currentState);
LISobj->PH = omxInitMatrix(0, 0, TRUE, currentState);
LISobj->TD = omxInitMatrix(0, 0, TRUE, currentState);
}
LISobj->Lnocol = LISobj->LY->cols == 0 || LISobj->LX->cols == 0;
if(LISobj->Lnocol) {
LISobj->GA = omxInitMatrix(LISobj->LY->cols, LISobj->LX->cols, TRUE, currentState);
LISobj->TH = omxInitMatrix(LISobj->LX->rows, LISobj->LY->rows, TRUE, currentState);
}
/* Identity Matrix, Size Of BE */
if(OMX_DEBUG) { mxLog("Generating I."); }
LISobj->I = omxNewIdentityMatrix(LISobj->BE->rows, currentState);
/* Get the nilpotency index of the BE matrix for I-BE inverse speedup */
if(OMX_DEBUG) { mxLog("Processing expansion iteration depth."); }
{ScopedProtect p1(slotValue, R_do_slot(rObj, Rf_install("depth")));
LISobj->numIters = INTEGER(slotValue)[0];
if(OMX_DEBUG) { mxLog("Using %d iterations.", LISobj->numIters); }
}
/* Initialize the place holder matrices used in calculations */
nx = LISobj->LX->rows;
nxi = LISobj->LX->cols;
ny = LISobj->LY->rows;
neta = LISobj->LY->cols;
ntotal = nx + ny;
if(OMX_DEBUG) { mxLog("Generating internals for computation."); }
LISobj->A = omxInitMatrix(nx, nxi, TRUE, currentState);
LISobj->B = omxInitMatrix(nx, nx, TRUE, currentState);
LISobj->C = omxInitMatrix(neta, neta, TRUE, currentState);
LISobj->D = omxInitMatrix(ny, neta, TRUE, currentState);
LISobj->E = omxInitMatrix(nx, neta, TRUE, currentState);
LISobj->F = omxInitMatrix(nx, ny, TRUE, currentState);
LISobj->G = omxInitMatrix(neta, nxi, TRUE, currentState);
LISobj->H = omxInitMatrix(ny, neta, TRUE, currentState);
LISobj->J = omxInitMatrix(ny, ny, TRUE, currentState);
LISobj->K = omxInitMatrix(neta, 1, TRUE, currentState);
LISobj->L = omxInitMatrix(neta, neta, TRUE, currentState);
LISobj->TOP = omxInitMatrix(ny, ntotal, TRUE, currentState);
LISobj->BOT = omxInitMatrix(nx, ntotal, TRUE, currentState);
LISobj->MUX = omxInitMatrix(nx, 1, TRUE, currentState);
LISobj->MUY = omxInitMatrix(ny, 1, TRUE, currentState);
LISobj->cov = omxInitMatrix(ntotal, ntotal, TRUE, currentState);
LISobj->args = (omxMatrix**) R_alloc(2, sizeof(omxMatrix*));
/* Means */
if(LISobj->TX != NULL || LISobj->TY != NULL || LISobj->KA != NULL || LISobj->AL != NULL) {
LISobj->means = omxInitMatrix(1, ntotal, TRUE, currentState);
} else LISobj->means = NULL;
//TODO: Adjust means processing to allow only Xs or only Ys
}
