ret_ CXMLLoaderActions::LoadNetworkVarialbe(const CData &Data,
const DOMElement *pElement,
CVariable *&pOV,
const CPDUInfo *pPDU)
{
#ifdef _DEBUG_
if (!pElement)
return PARAMETER_NULL | PARAMETER_2;
if (pOV)
return PARAMETER_NOT_NULL | PARAMETER_3;
if (!pPDU)
return PARAMETER_NULL | PARAMETER_4;
#endif
//
auto_xerces_str wsGroupName ("group_name");
auto_xerces_str wsFieldName ("field_name");
auto_xerces_str wsIndex ("index");
auto_xerces_str sGroupName (pElement->getAttribute(wsGroupName));
auto_xerces_str sFieldName (pElement->getAttribute(wsFieldName));
auto_xerces_str sIndex (pElement->getAttribute(wsIndex));
ch_1 szName[VARIABLE_NAME_LENGTH * 2];
memset(szName, 0, VARIABLE_NAME_LENGTH * 2);
if (0 < strlen(sGroupName))
{
sprintf(szName,
"%s.%s",
(const ch_1 *)sGroupName,
(const ch_1 *)sFieldName);
}
else
{
sprintf(szName, "%s", (const ch_1 *)sFieldName);
}
CField *pField = null_v;
if (SUCCESS != (((CPDUInfo *)pPDU)->GetField(szName, pField)))
return XML_LOADER_ERROR;
if (0 == strcmp(sIndex, SIGN_UNBOUNDED))
pOV = new CVarNetwork(pField);
else
pOV = new CVarNetwork(pField, sIndex);
return SUCCESS;
}
ret_ CXMLLoaderActions::LoadGroupVariable(const CData &Data,
const DOMElement *pElement,
CVariable *&pOV)
{
#ifdef _DEBUG_
if (!pElement)
return (PARAMETER_NULL | PARAMETER_2);
if (pOV)
return (PARAMETER_NOT_NULL | PARAMETER_3);
#endif
auto_xerces_str wsGroupName ("group_name");
auto_xerces_str wsFieldName ("field_name");
auto_xerces_str wsIndex ("index");
auto_xerces_str sGroupName (pElement->getAttribute(wsGroupName));
auto_xerces_str sFieldName (pElement->getAttribute(wsFieldName));
auto_xerces_str sIndex (pElement->getAttribute(wsIndex));
ch_1 szName[VARIABLE_NAME_LENGTH * 2];
const char *pszSubName = null_v;
const char *pszIndexName = null_v;
memset(szName, 0, VARIABLE_NAME_LENGTH * 2);
if (0 < strlen(sFieldName))
{
sprintf(szName,
"%s.%s",
(const ch_1 *)sGroupName,
(const ch_1 *)sFieldName);
pszSubName = sFieldName;
}
else
{
sprintf(szName, "%s", (const ch_1 *)sGroupName);
}
v_ *pV = Data.Value(szName);
if (!pV)
return XML_LOADER_ERROR; // There is no variable defined above
if (0 != strcmp(sIndex, SIGN_UNBOUNDED))
pszIndexName = sIndex;
pOV = new CVarGroupDefined(sGroupName, pszSubName, pszIndexName);
return SUCCESS;
}
RTWrite::~RTWrite()
{
if (m_pFile != NULL)
{
fclose(m_pFile);
sprintf(m_fileTemp, m_file, m_curFileChains, m_curFile);
if (rename("temp.rt", m_fileTemp) != 0)
{
perror(m_fileTemp);
exit(1);
}
printf("writing index before closing file...\n");
printf("Covering %u - %u\n", m_prefixStart, (m_prefixStart + m_curFileChains - m_prefixStart));
unsigned char index[11] = {0}; // [0 - 10]
// The 5 byte prefix of the endingpoint [0 - 4]
uint64 *prefix = (uint64 *)index;
*prefix = m_curPrefix;
printf("value is %02x%02x%02x%02x%02x%02x%02x%02x (%llu)\n", index[0], index[1], index[2], index[3], index[4], index[5], index[6], index[7], m_curPrefix);
int *iprefix;
// The 4 bytes index where to look in the file for the chains [5 - 8]
iprefix = (int*)&index[5];
*iprefix = m_prefixStart;
short *iprefixs = (short*)&index[9]; // The number of chains (2 bytes, max 65535 chains) with this prefix [9 - 10]
*iprefixs = (short)(m_curFileChains - m_prefixStart);
fwrite(&index, 1, 11, m_pFileIndex); // Position of these chains is: First chain: FILESTART + (iprefix * 8)
// Last chain: FILESTART + (iprefix * 8) + (iprefixs * 8)
std::string sIndex(m_fileTemp);
sIndex.append(".index");
if (rename("temp.rt.index", sIndex.c_str()) != 0)
{
perror(sIndex.c_str());
exit(1);
}
/*
if(m_pFileCont != NULL)
fclose(m_pFileCont);
*/
}
if (m_file != NULL)
{
delete [] m_file;
}
if (m_fileTemp != NULL)
{
delete [] m_fileTemp;
}
}
STDMETHODIMP CDocumentRiskLevel::get_Item(VARIANT vIndex, IDocumentRiskLevel** ppItem)
{
try
{
_variant_t var(vIndex);
DocumentRiskLevelImpl* pTheItem = 0;
if (VT_BSTR == var.vt)
{
_bstr_t bstr(var.bstrVal, true);
std::tstring sIndex((const TCHAR*)bstr);
pTheItem = m_pRiskLevel->GetItem(sIndex);
}
else if(VT_I4 == vIndex.vt)
{
long index = vIndex.lVal;
if(0 >= index)
throw Workshare::ArgumentException(_T("vIndex"), _T("The index is one based"));
pTheItem = m_pRiskLevel->GetItem(--index);
}
else if(VT_INT == vIndex.vt)
{
long index = static_cast<long>(vIndex.intVal);
if(0 >= index)
throw Workshare::ArgumentException(_T("vIndex"), _T("The index is one based"));
pTheItem = m_pRiskLevel->GetItem(--index);
}
else
{
return E_INVALIDARG;
}
AddChildRiskLevel(pTheItem, ppItem);
}
catch(const Workshare::Exception& e)
{
return Error(e.Message, __uuidof(this), e.ErrorCode);
}
catch(...)
{
return ProcessUnhandledException();
}
return S_OK;
}
void ba81NormalQuad::setup(double Qwidth, int Qpoints, double *means,
Eigen::MatrixXd &priCov, Eigen::VectorXd &sVar)
{
quadGridSize = Qpoints;
numSpecific = sVar.rows() * sVar.cols();
primaryDims = priCov.rows();
maxDims = primaryDims + (numSpecific? 1 : 0);
maxAbilities = primaryDims + numSpecific;
if (maxAbilities == 0) {
setup0();
return;
}
totalQuadPoints = 1;
for (int dx=0; dx < maxDims; dx++) {
totalQuadPoints *= quadGridSize;
}
if (int(Qpoint.size()) != quadGridSize) {
Qpoint.clear();
Qpoint.reserve(quadGridSize);
double qgs = quadGridSize-1;
for (int px=0; px < quadGridSize; ++px) {
Qpoint.push_back(px * 2 * Qwidth / qgs - Qwidth);
}
}
std::vector<double> tmpWherePrep(totalQuadPoints * maxDims);
Eigen::VectorXi quad(maxDims);
for (int qx=0; qx < totalQuadPoints; qx++) {
double *wh = tmpWherePrep.data() + qx * maxDims;
decodeLocation(qx, maxDims, quad.data());
pointToWhere(quad.data(), wh, maxDims);
}
totalPrimaryPoints = totalQuadPoints;
weightTableSize = totalQuadPoints;
if (numSpecific) {
totalPrimaryPoints /= quadGridSize;
speQarea.resize(quadGridSize * numSpecific);
weightTableSize *= numSpecific;
}
std::vector<double> tmpPriQarea;
tmpPriQarea.reserve(totalPrimaryPoints);
{
Eigen::VectorXd where(primaryDims);
for (int qx=0; qx < totalPrimaryPoints; qx++) {
decodeLocation(qx, primaryDims, quad.data());
pointToWhere(quad.data(), where.data(), primaryDims);
double den = exp(dmvnorm(primaryDims, where.data(), means, priCov.data()));
tmpPriQarea.push_back(den);
}
}
std::vector<int> priOrder;
priOrder.reserve(totalPrimaryPoints);
for (int qx=0; qx < totalPrimaryPoints; qx++) {
priOrder.push_back(qx);
}
if (0) {
sortAreaHelper priCmp(tmpPriQarea);
std::sort(priOrder.begin(), priOrder.end(), priCmp);
}
priQarea.clear();
priQarea.reserve(totalPrimaryPoints);
double totalArea = 0;
for (int qx=0; qx < totalPrimaryPoints; qx++) {
double den = tmpPriQarea[priOrder[qx]];
priQarea.push_back(den);
//double prevTotalArea = totalArea;
totalArea += den;
// if (totalArea == prevTotalArea) {
// mxLog("%.4g / %.4g = %.4g", den, totalArea, den / totalArea);
// }
}
for (int qx=0; qx < totalPrimaryPoints; qx++) {
priQarea[qx] *= One;
priQarea[qx] /= totalArea;
//mxLog("%.5g,", priQarea[qx]);
}
for (int sgroup=0; sgroup < numSpecific; sgroup++) {
totalArea = 0;
double mean = means[primaryDims + sgroup];
double var = sVar(sgroup);
for (int qx=0; qx < quadGridSize; qx++) {
double den = exp(dmvnorm(1, &Qpoint[qx], &mean, &var));
speQarea[sIndex(sgroup, qx)] = den;
totalArea += den;
}
for (int qx=0; qx < quadGridSize; qx++) {
speQarea[sIndex(sgroup, qx)] /= totalArea;
}
}
//pda(speQarea.data(), numSpecific, quadGridSize);
for (int sx=0; sx < int(speQarea.size()); ++sx) {
speQarea[sx] *= One;
}
//pda(speQarea.data(), numSpecific, quadGridSize);
wherePrep.clear();
wherePrep.reserve(totalQuadPoints * maxDims);
if (numSpecific == 0) {
for (int qx=0; qx < totalPrimaryPoints; qx++) {
int sortq = priOrder[qx] * maxDims;
for (int dx=0; dx < maxDims; ++dx) {
wherePrep.push_back(tmpWherePrep[sortq + dx]);
}
}
} else {
for (int qx=0; qx < totalPrimaryPoints; ++qx) {
int sortq = priOrder[qx] * quadGridSize;
for (int sx=0; sx < quadGridSize; ++sx) {
int base = (sortq + sx) * maxDims;
for (int dx=0; dx < maxDims; ++dx) {
wherePrep.push_back(tmpWherePrep[base + dx]);
}
}
}
}
// recompute whereGram because the order might have changed
whereGram.resize(triangleLoc1(maxDims), totalQuadPoints);
for (int qx=0; qx < totalQuadPoints; qx++) {
double *wh = wherePrep.data() + qx * maxDims;
gramProduct(wh, maxDims, &whereGram.coeffRef(0, qx));
}
}
void RTWrite::writeChain(RTChain *chain)
{
bool bIndexWritten = false;
if (m_pFile == NULL)
{
m_pFile = fopen("temp.rt", "wb");
if (m_pFile == NULL)
{
perror(m_fileTemp);
exit(1);
}
m_pFileIndex = fopen("temp.rt.index", "wb");
if (m_pFileIndex == NULL)
{
perror(m_fileTemp);
exit(1);
}
/*
m_pFileCont = fopen("temp.rt.cont", "wb");
if (m_pFileCont == NULL)
{
perror(m_fileTemp);
exit(1);
}*/
}
// int cp = 0;
// if (cwc.GetIndex() == chain->endpt)
// {
if(chain->startpt == 0)
return;
if (m_prevEndpt >= chain->endpt && chain->endpt != 0)
{
fprintf(stderr, "**** Error writeChain() in %i: Tring to write unsorted data. %llu >= %llu****\n", m_curFileChains, m_prevEndpt, chain->endpt);
// exit(1);
return;
}
#ifdef _WIN32
if(chain->startpt > 0x0000FFFFFFFFFFFFI64)
#else
if(chain->startpt > 0x0000FFFFFFFFFFFFllu)
#endif
{
fprintf(stderr, "**** Error writeChain() in %i: Startpoint is bigger than 6 bytes. (%llx) ****\n", m_curFileChains, chain->startpt);
// exit(1);
return;
}
#ifdef _WIN32
if(chain->endpt > 0x00FFFFFFFFFFFFFFI64)
#else
if(chain->endpt > 0x00FFFFFFFFFFFFFFllu)
#endif
{
fprintf(stderr, "**** Error writeChain() in %i: Endpoint is bigger than 7 bytes. (%llx) ****\n", m_curFileChains, chain->endpt);
// exit(1);
return;
}
// Disable checkpoints in this version
// cp = cp >> 24;
fwrite(&chain->startpt, 1, 6, m_pFile); // Prefix increased to 6 bytes in this version
fwrite(&chain->endpt, 1, 2, m_pFile);
m_prevEndpt = chain->endpt;
// fwrite(&cp, 1, 1, m_pFile);
uint64 nPrefix = chain->endpt >> 16;
if(nPrefix != m_curPrefix) // Next index. Write the current one down
{
// nPrefix should NOT be smaller. If it is *something* is wrong
if(nPrefix < m_curPrefix)
{
fprintf(stderr, "**** Error writeChain() in %i of file %i: Prefix is smaller than previous prefix. %llu < %llu**** \n", m_curFileChains, m_curFile, nPrefix, m_curPrefix);
exit(1);
}
unsigned char index[11] = {0}; // [0 - 10]
// The 5 byte prefix of the endingpoint [0 - 4]
uint64 *prefix = (uint64 *)index;
*prefix = m_curPrefix;
int *iprefix;
// The 4 bytes index where to look in the file for the chains [5 - 8]
iprefix = (int*)&index[5];
*iprefix = m_prefixStart;
short *iprefixs = (short*)&index[9]; // The number of chains (2 bytes, max 65535 chains) with this prefix [9 - 10]
*iprefixs = (short)(m_curFileChains - m_prefixStart);
fwrite(&index, 1, 11, m_pFileIndex); // Position of these chains is: First chain: FILESTART + (iprefix * 8)
// Last chain: FILESTART + (iprefix * 8) + (iprefixs * 8)
m_numIndexRows++;
// fflush(m_pFileIndex);
m_prefixStart = m_curFileChains;
m_curPrefix = nPrefix;
bIndexWritten = true;
/*fseek(m_pFileCont, 0, SEEK_SET);
fwrite(m_curFileChains, 0, sizeof(int), m_pFileCont);
fflush(m_curFileChains);
*/
}
m_curFileChains++;
//nChainNum++;
//return 3;
// }
/* else
{
// nFailed++;
}
*/
/* if (fwrite((void*)chain, 16, 1, m_pFile) != 1)
{
perror("temp.rt");
exit(1);
}*/
if (m_curFileChains >= m_chainsPerFile)
{
fclose(m_pFile);
m_pFile = NULL;
sprintf(m_fileTemp, m_file, m_curFileChains, m_curFile);
if (rename("temp.rt", m_fileTemp) != 0)
{
perror(m_fileTemp);
exit(1);
}
/* if(bIndexWritten == false) // If we haven't written the index in this round, its time to do it before we close the file
{*/
printf("writing index before closing file...\n");
printf("Covering %u - %u\n", m_prefixStart, (m_prefixStart + m_curFileChains - m_prefixStart));
unsigned char index[11] = {0}; // [0 - 10]
// The 5 byte prefix of the endingpoint [0 - 4]
uint64 *prefix = (uint64 *)index;
*prefix = m_curPrefix;
printf("value is %02x%02x%02x%02x%02x%02x%02x%02x (%llu)\n", index[0], index[1], index[2], index[3], index[4], index[5], index[6], index[7], m_curPrefix);
int *iprefix;
// The 4 bytes index where to look in the file for the chains [5 - 8]
iprefix = (int*)&index[5];
*iprefix = m_prefixStart;
short *iprefixs = (short*)&index[9]; // The number of chains (2 bytes, max 65535 chains) with this prefix [9 - 10]
*iprefixs = (short)(m_curFileChains - m_prefixStart);
fwrite(&index, 1, 11, m_pFileIndex); // Position of these chains is: First chain: FILESTART + (iprefix * 8)
// Last chain: FILESTART + (iprefix * 8) + (iprefixs * 8)
m_numIndexRows++;
/*
}
else
{
printf("Index already written in this round.. skipping!\n");
}
*/
fclose(m_pFileIndex);
std::string sIndex(m_fileTemp);
sIndex.append(".index");
printf("%s: %u index rows\n\n", sIndex.c_str(), m_numIndexRows);
if (rename("temp.rt.index", sIndex.c_str()) != 0)
{
perror(m_fileTemp);
exit(1);
}
m_curFile++;
m_curFileChains = 0;
m_prefixStart = 0;
m_numIndexRows = 0;
}
}