GDomNode* GWeightedModel::serialize(GDom* pDoc) const
{
GDomNode* pNode = pDoc->newObj();
pNode->addField(pDoc, "w", pDoc->newDouble(m_weight));
pNode->addField(pDoc, "m", m_pModel->serialize(pDoc));
return pNode;
}
GDomNode* GCategoricalDistribution::serialize(GDom* pDoc) const
{
GDomNode* pNode = pDoc->newList();
for(size_t i = 0; i < m_nValueCount; i++)
pNode->addItem(pDoc, pDoc->newDouble(m_pValues[i]));
return pNode;
}
// virtual
GDomNode* GBayesianModelAveraging::serialize(GDom* pDoc) const
{
GDomNode* pNode = baseDomNode(pDoc, "GBayesianModelAveraging");
serializeBase(pDoc, pNode);
pNode->addField(pDoc, "ts", pDoc->newDouble(m_trainSize));
return pNode;
}
GDomNode* serialize(GDom* pDoc)
{
GDomNode* pNode = pDoc->newList();
for(size_t i = 0; i < m_nValues; i++)
pNode->addItem(pDoc, pDoc->newInt(m_pValueCounts[i]));
return pNode;
}
GDomNode* toDom(GDom* pDoc)
{
GDomNode* pAccount = pDoc->newObj();
pAccount->addField(pDoc, "username", pDoc->newString(m_username.c_str()));
pAccount->addField(pDoc, "password", pDoc->newString(m_passwordHash.c_str()));
return pAccount;
}
GDomNode* GDistanceMetric::baseDomNode(GDom* pDoc, const char* szClassName) const
{
GDomNode* pNode = pDoc->newObj();
pNode->addField(pDoc, "class", pDoc->newString(szClassName));
pNode->addField(pDoc, "relation", m_pRelation->serialize(pDoc));
return pNode;
}
GDomNode* GSparseSimilarity::baseDomNode(GDom* pDoc, const char* szClassName) const
{
GDomNode* pNode = pDoc->newObj();
pNode->addField(pDoc, "class", pDoc->newString(szClassName));
pNode->addField(pDoc, "reg", pDoc->newDouble(m_regularizer));
return pNode;
}
// virtual
GDomNode* GLNormDistance::serialize(GDom* pDoc) const
{
GDomNode* pNode = baseDomNode(pDoc, "GLNormDistance");
pNode->addField(pDoc, "norm", pDoc->newDouble(m_norm));
pNode->addField(pDoc, "dwu", pDoc->newDouble(m_diffWithUnknown));
return pNode;
}
GDomNode* GPolicyLearner::baseDomNode(GDom* pDoc)
{
GDomNode* pNode = pDoc->newObj();
pNode->addField(pDoc, "actionDims", pDoc->newInt(m_actionDims));
pNode->addField(pDoc, "relation", m_pRelation->serialize(pDoc));
return pNode;
}
// virtual
GDomNode* GLinearRegressor::serialize(GDom* pDoc) const
{
GDomNode* pNode = baseDomNode(pDoc, "GLinearRegressor");
pNode->addField(pDoc, "beta", m_pBeta->serialize(pDoc));
pNode->addField(pDoc, "epsilon", GVec::serialize(pDoc, m_pEpsilon, m_pBeta->rows()));
return pNode;
}
GDomNode* serialize(GDom* pDoc)
{
GDomNode* pNode = pDoc->newList();
pNode->addItem(pDoc, pDoc->newInt(m_nCount));
for(size_t i = 0; i < m_featureDims; i++)
pNode->addItem(pDoc, m_pInputs[i]->serialize(pDoc));
return pNode;
}
// virtual
void GEnsemble::serializeBase(GDom* pDoc, GDomNode* pNode) const
{
pNode->addField(pDoc, "labelrel", m_pLabelRel->serialize(pDoc));
pNode->addField(pDoc, "accum", pDoc->newInt(m_nAccumulatorDims));
GDomNode* pModels = pNode->addField(pDoc, "models", pDoc->newList());
for(size_t i = 0; i < m_models.size(); i++)
pModels->addItem(pDoc, m_models[i]->serialize(pDoc));
}
// virtual
GDomNode* GBayesianModelCombination::serialize(GDom* pDoc) const
{
GDomNode* pNode = baseDomNode(pDoc, "GBayesianModelCombination");
serializeBase(pDoc, pNode);
pNode->addField(pDoc, "ts", pDoc->newDouble(m_trainSize));
pNode->addField(pDoc, "samps", pDoc->newInt(m_samples));
return pNode;
}
GDomNode* G3DMatrix::serialize(GDom* pDoc) const
{
GDomNode* pNode = pDoc->newList();
for(int r = 0; r < 3; r++)
for(int c = 0; c < 3; c++)
pNode->addItem(pDoc, pDoc->newDouble(m_rows[r].m_vals[c]));
return pNode;
}
// virtual
GDomNode* GLinearDistribution::serialize(GDom* pDoc) const
{
GDomNode* pNode = baseDomNode(pDoc, "GLinearDistribution");
pNode->addField(pDoc, "nd", pDoc->newDouble(m_noiseDev));
pNode->addField(pDoc, "w", m_pWBar->serialize(pDoc));
pNode->addField(pDoc, "a", m_pAInv->serialize(pDoc));
return pNode;
}
GDomNode* G3DVector::serialize(GDom* pDoc) const
{
GDomNode* pNode = pDoc->newObj();
pNode->addField(pDoc, "x", pDoc->newDouble(m_vals[0]));
pNode->addField(pDoc, "y", pDoc->newDouble(m_vals[1]));
pNode->addField(pDoc, "z", pDoc->newDouble(m_vals[2]));
return pNode;
}
// virtual
GDomNode* GBucket::serialize(GDom* pDoc) const
{
GDomNode* pNode = baseDomNode(pDoc, "GBucket");
GDomNode* pModels = pNode->addField(pDoc, "models", pDoc->newList());
pModels->addItem(pDoc, m_models[m_nBestLearner]->serialize(pDoc));
pNode->addField(pDoc, "best", pDoc->newInt(0));
return pNode;
}
// virtual
GDomNode* GWag::serialize(GDom* pDoc) const
{
GDomNode* pNode = baseDomNode(pDoc, "GWag");
pNode->addField(pDoc, "models", pDoc->newInt(m_models));
pNode->addField(pDoc, "nn", m_pNN->serialize(pDoc));
pNode->addField(pDoc, "na", pDoc->newBool(m_noAlign));
return pNode;
}
// virtual
GDomNode* GResamplingAdaBoost::serialize(GDom* pDoc) const
{
GDomNode* pNode = baseDomNode(pDoc, "GResamplingAdaBoost");
serializeBase(pDoc, pNode);
pNode->addField(pDoc, "es", pDoc->newInt(m_ensembleSize));
pNode->addField(pDoc, "ts", pDoc->newDouble(m_trainSize));
return pNode;
}
// virtual
GDomNode* GNaiveInstance::serialize(GDom* pDoc) const
{
GDomNode* pNode = baseDomNode(pDoc, "GNaiveInstance");
pNode->addField(pDoc, "neighbors", pDoc->newInt(m_nNeighbors));
GDomNode* pAttrs = pNode->addField(pDoc, "attrs", pDoc->newList());
for(size_t i = 0; i < m_pRelFeatures->size(); i++)
pAttrs->addItem(pDoc, m_pAttrs[i]->serialize(pDoc, m_pRelLabels->size()));
return pNode;
}
// virtual
GDomNode* GPolynomial::serialize(GDom* pDoc)
{
GDomNode* pNode = baseDomNode(pDoc, "GPolynomial");
pNode->addField(pDoc, "controlPoints", pDoc->newInt(m_controlPoints));
GDomNode* pPolys = pNode->addField(pDoc, "polys", pDoc->newList());
for(size_t i = 0; i < m_polys.size(); i++)
pPolys->addItem(pDoc, m_polys[i]->serialize(pDoc));
return pNode;
}
// virtual
GDomNode* GRowDistanceScaled::serialize(GDom* pDoc) const
{
GDomNode* pNode = baseDomNode(pDoc, "GRowDistance");
size_t dims = m_pRelation->size();
GDomNode* pScaleFactors = pNode->addField(pDoc, "scaleFactors", pDoc->newList());
for(size_t i = 0; i < dims; i++)
pScaleFactors->addItem(pDoc, pDoc->newDouble(m_pScaleFactors[i]));
return pNode;
}
// virtual
GDomNode* GPolynomialSingleLabel::serialize(GDom* pDoc)
{
if(m_featureDims == 0)
ThrowError("train has not been called");
GDomNode* pNode = pDoc->newObj();
pNode->addField(pDoc, "featureDims", pDoc->newInt(m_featureDims));
pNode->addField(pDoc, "controlPoints", pDoc->newInt(m_nControlPoints));
pNode->addField(pDoc, "coefficients", GVec::serialize(pDoc, m_pCoefficients, m_nCoefficients));
return pNode;
}
GDomNode* serialize(GDom* pDoc, size_t labelDims)
{
GDomNode* pList = pDoc->newList();
for(multimap<double,const double*>::iterator it = m_instances.begin(); it != m_instances.end(); it++)
{
pList->addItem(pDoc, pDoc->newDouble(it->first));
for(size_t i = 0; i < labelDims; i++)
pList->addItem(pDoc, pDoc->newDouble(it->second[i]));
}
return pList;
}
GDomNode* GKeyPair::serialize(GDom* pDoc, bool bIncludePrivateKey)
{
GDomNode* pNode = pDoc->newObj();
if(!n() || !publicKey())
throw Ex("No key has been made yet");
if(bIncludePrivateKey && !privateKey())
throw Ex("This key-pair doesn't include the private key");
pNode->addField(pDoc, "n", n()->serialize(pDoc));
pNode->addField(pDoc, "public", publicKey()->serialize(pDoc));
if(bIncludePrivateKey)
pNode->addField(pDoc, "private", privateKey()->serialize(pDoc));
return pNode;
}
/// Marshals this model to a JSON DOM.
GDomNode* TransitionModel::marshal(GDom* pDoc)
{
GDomNode* pNode = pDoc->newObj();
pNode->addField(pDoc, "model", model.serialize(pDoc));
pNode->addField(pDoc, "trainPos", pDoc->newInt(trainPos));
pNode->addField(pDoc, "trainSize", pDoc->newInt(trainSize));
pNode->addField(pDoc, "trainIters", pDoc->newInt(trainIters));
pNode->addField(pDoc, "trainInput", trainInput.serialize(pDoc));
pNode->addField(pDoc, "trainOutput", trainOutput.serialize(pDoc));
pNode->addField(pDoc, "trainProgress", pDoc->newInt(trainProgress));
pNode->addField(pDoc, "err", pDoc->newDouble(err));
pNode->addField(pDoc, "prevErr", pDoc->newDouble(prevErr));
return pNode;
}
/// Marshals this model to a JSON DOM.
GDomNode* PlanningSystem::marshal(GDom* pDoc)
{
GDomNode* pNode = pDoc->newObj();
GDomNode* pPlans = pNode->addField(pDoc, "plans", pDoc->newList());
for(size_t i = 0; i < plans.size(); i++)
pPlans->addItem(pDoc, plans[i]->serialize(pDoc));
pNode->addField(pDoc, "maxPlanLength", pDoc->newInt(maxPlanLength));
pNode->addField(pDoc, "discount", pDoc->newDouble(discountFactor));
pNode->addField(pDoc, "explore", pDoc->newDouble(explorationRate));
pNode->addField(pDoc, "refinementIters", pDoc->newInt(refinementIters));
pNode->addField(pDoc, "burnIn", pDoc->newInt(burnIn));
pNode->addField(pDoc, "actionDims", pDoc->newInt(actionDims));
return pNode;
}
GDomNode* Server::serializeState(GDom* pDoc)
{
GDomNode* pNode = pDoc->newObj();
// Captcha salt
pNode->addField(pDoc, "daemonSalt", pDoc->newString(daemonSalt()));
// Save the accounts
GDomNode* pAccounts = pNode->addField(pDoc, "accounts", pDoc->newList());
size_t i = 0;
for(map<string,Account*>::iterator it = m_accounts.begin(); it != m_accounts.end(); it++)
{
Account* pAccount = it->second;
pAccounts->addItem(pDoc, pAccount->toDom(pDoc));
i++;
}
return pNode;
}
// virtual
GDomNode* GGaussianProcess::serialize(GDom* pDoc) const
{
GDomNode* pNode = baseDomNode(pDoc, "GGaussianProcess");
pNode->addField(pDoc, "wv", pDoc->newDouble(m_weightsPriorVar));
pNode->addField(pDoc, "nv", pDoc->newDouble(m_noiseVar));
pNode->addField(pDoc, "ms", pDoc->newInt(m_maxSamples));
pNode->addField(pDoc, "l", m_pLInv->serialize(pDoc));
pNode->addField(pDoc, "a", m_pAlpha->serialize(pDoc));
pNode->addField(pDoc, "feat", m_pStoredFeatures->serialize(pDoc));
pNode->addField(pDoc, "kernel", m_pKernel->serialize(pDoc));
return pNode;
}
// virtual
GDomNode* GCamera::serialize(GDom* pDoc) const
{
GDomNode* pNode = pDoc->newObj();
pNode->addField(pDoc, "from", m_lookFromPoint.serialize(pDoc));
pNode->addField(pDoc, "dir", m_lookDirection.serialize(pDoc));
pNode->addField(pDoc, "up", m_viewUpVector.serialize(pDoc));
pNode->addField(pDoc, "hvh", pDoc->newDouble(m_halfViewHeight));
pNode->addField(pDoc, "width", pDoc->newInt(m_nWidth));
pNode->addField(pDoc, "height", pDoc->newInt(m_nHeight));
return pNode;
}
