void lle(GArgReader& args)
{
// Load the file and params
GMatrix* pData = loadData(args.pop_string());
Holder<GMatrix> hData(pData);
unsigned int nSeed = getpid() * (unsigned int)time(NULL);
GRand prng(nSeed);
GNeighborFinder* pNF = instantiateNeighborFinder(pData, &prng, args);
Holder<GNeighborFinder> hNF(pNF);
int targetDims = args.pop_uint();
// Parse Options
while(args.size() > 0)
{
if(args.if_pop("-seed"))
prng.setSeed(args.pop_uint());
else
throw Ex("Invalid option: ", args.peek());
}
// Transform the data
GLLE transform(pNF->neighborCount(), targetDims, &prng);
transform.setNeighborFinder(pNF);
GMatrix* pDataAfter = transform.doit(*pData);
Holder<GMatrix> hDataAfter(pDataAfter);
pDataAfter->print(cout);
}
void plot_it(const char* filename, GNeuralNet& nn, GMatrix& trainFeat, GMatrix& trainLab, GMatrix& testFeat, GMatrix& testLab)
{
GSVG svg(1000, 500);
double xmin = trainFeat[0][0];
double xmax = testFeat[testFeat.rows() - 1][0];
svg.newChart(xmin, std::min(trainLab.columnMin(0), testLab.columnMin(0)), xmax, std::max(trainLab.columnMax(0), testLab.columnMax(0)));
svg.horizMarks(20);
svg.vertMarks(20);
double prevx = xmin;
double prevy = 0.0;
double step = (xmax - xmin) / 500.0;
GVec x(1);
GVec y(1);
for(x[0] = prevx; x[0] < xmax; x[0] += step)
{
nn.predict(x, y);
if(prevx != x[0])
svg.line(prevx, prevy, x[0], y[0], 0.3);
prevx = x[0];
prevy = y[0];
}
for(size_t i = 0; i < trainLab.rows(); i++)
svg.dot(trainFeat[i][0], trainLab[i][0], 0.4, 0xff000080);
for(size_t i = 0; i < testLab.rows(); i++)
svg.dot(testFeat[i][0], testLab[i][0], 0.4, 0xff800000);
std::ofstream ofs;
ofs.open(filename);
svg.print(ofs);
}
void addNoise(GArgReader& args)
{
GMatrix* pData = loadData(args.pop_string());
Holder<GMatrix> hData(pData);
double dev = args.pop_double();
// Parse the options
unsigned int seed = getpid() * (unsigned int)time(NULL);
int excludeLast = 0;
while(args.next_is_flag())
{
if(args.if_pop("-seed"))
seed = args.pop_uint();
else if(args.if_pop("-excludelast"))
excludeLast = args.pop_uint();
else
ThrowError("Invalid neighbor finder option: ", args.peek());
}
GRand prng(seed);
size_t cols = pData->cols() - excludeLast;
for(size_t r = 0; r < pData->rows(); r++)
{
double* pRow = pData->row(r);
for(size_t c = 0; c < cols; c++)
*(pRow++) += dev * prng.normal();
}
pData->print(cout);
}
// virtual
void GLinearRegressor::trainInner(GMatrix& features, GMatrix& labels)
{
// Use a fast, but not-very-numerically-stable technique to compute an initial approximation for beta and epsilon
clear();
GMatrix* pAll = GMatrix::mergeHoriz(&features, &labels);
Holder<GMatrix> hAll(pAll);
GPCA pca(features.cols(), &m_rand);
pca.train(*pAll);
size_t inputs = features.cols();
size_t outputs = labels.cols();
GMatrix f(inputs, inputs);
GMatrix l(inputs, outputs);
for(size_t i = 0; i < inputs; i++)
{
GVec::copy(f[i], pca.basis(i), inputs);
double sqmag = GVec::squaredMagnitude(f[i], inputs);
if(sqmag > 1e-10)
GVec::multiply(f[i], 1.0 / sqmag, inputs);
GVec::copy(l[i], pca.basis(i) + inputs, outputs);
}
m_pBeta = GMatrix::multiply(l, f, true, false);
m_pEpsilon = new double[outputs];
m_pBeta->multiply(pca.mean(), m_pEpsilon, false);
GVec::multiply(m_pEpsilon, -1.0, outputs);
GVec::add(m_pEpsilon, pca.mean() + inputs, outputs);
// Refine the results using gradient descent
refine(features, labels, 0.06, 20, 0.75);
}
void precisionRecall(GArgReader& args)
{
// Parse options
unsigned int seed = getpid() * (unsigned int)time(NULL);
bool ideal = false;
while(args.next_is_flag())
{
if(args.if_pop("-seed"))
seed = args.pop_uint();
else if(args.if_pop("-ideal"))
ideal = true;
else
ThrowError("Invalid option: ", args.peek());
}
// Load the data
if(args.size() < 1)
ThrowError("No dataset specified.");
GMatrix* pData = loadData(args.pop_string());
Holder<GMatrix> hData(pData);
// Instantiate the recommender
GRand prng(seed);
GCollaborativeFilter* pModel = InstantiateAlgorithm(prng, args);
Holder<GCollaborativeFilter> hModel(pModel);
if(args.size() > 0)
ThrowError("Superfluous argument: ", args.peek());
// Generate precision-recall data
GMatrix* pResults = pModel->precisionRecall(*pData, ideal);
Holder<GMatrix> hResults(pResults);
pResults->deleteColumn(2); // we don't need the false-positive rate column
pResults->print(cout);
}
void GRecommenderLib::loadData(GMatrix& data, const char* szFilename)
{
PathData pd;
GFile::parsePath(szFilename, &pd);
if(_stricmp(szFilename + pd.extStart, ".sparse") == 0)
{
GDom doc;
doc.loadJson(szFilename);
GSparseMatrix sm(doc.root());
data.resize(0, 3);
for(size_t i = 0; i < sm.rows(); i++)
{
GSparseMatrix::Iter rowEnd = sm.rowEnd(i);
for(GSparseMatrix::Iter it = sm.rowBegin(i); it != rowEnd; it++)
{
GVec& vec = data.newRow();
vec[0] = (double)i;
vec[1] = (double)it->first;
vec[2] = it->second;
}
}
}
else if(_stricmp(szFilename + pd.extStart, ".arff") == 0)
data.loadArff(szFilename);
else
throw Ex("Unsupported file format: ", szFilename + pd.extStart);
}
void OdeImplicitEuler<Real>::Update (Real fTIn, Real* afXIn, Real& rfTOut,
Real* afXOut)
{
m_oFunction(fTIn,afXIn,m_pvData,m_kF);
m_oDFunction(fTIn,afXIn,m_pvData,m_kDF);
GMatrix<Real> kDG = m_kIdentity - m_fStep*m_kDF;
GMatrix<Real> kDGInverse(m_iDim,m_iDim);
bool bInvertible = kDG.GetInverse(kDGInverse);
if (bInvertible)
{
m_kF = kDGInverse*m_kF;
for (int i = 0; i < m_iDim; i++)
{
afXOut[i] = afXIn[i] + m_fStep*m_kF[i];
}
}
else
{
size_t uiSize = m_iDim*sizeof(Real);
System::Memcpy(afXOut,uiSize,afXIn,uiSize);
}
rfTOut = fTIn + m_fStep;
}
void kmeans(GArgReader& args)
{
// Load the file and params
GMatrix data;
loadData(data, args.pop_string());
int clusters = args.pop_uint();
// Parse Options
unsigned int nSeed = getpid() * (unsigned int)time(NULL);
size_t reps = 1;
while(args.size() > 0)
{
if(args.if_pop("-seed"))
nSeed = args.pop_uint();
else if(args.if_pop("-reps"))
reps = args.pop_uint();
else
throw Ex("Invalid option: ", args.peek());
}
// Do the clustering
GRand prng(nSeed);
GKMeans clusterer(clusters, &prng);
clusterer.setReps(reps);
GMatrix* pOut = clusterer.reduce(data);
std::unique_ptr<GMatrix> hOut(pOut);
pOut->print(cout);
}
// virtual
void GLinearRegressor::trainInner(const GMatrix& features, const GMatrix& labels)
{
if(!features.relation().areContinuous())
throw Ex("GLinearRegressor only supports continuous features. Perhaps you should wrap it in a GAutoFilter.");
if(!labels.relation().areContinuous())
throw Ex("GLinearRegressor only supports continuous labels. Perhaps you should wrap it in a GAutoFilter.");
// Use a fast, but not-very-numerically-stable technique to compute an initial approximation for beta and epsilon
clear();
GMatrix* pAll = GMatrix::mergeHoriz(&features, &labels);
Holder<GMatrix> hAll(pAll);
GPCA pca(features.cols());
pca.train(*pAll);
size_t inputs = features.cols();
size_t outputs = labels.cols();
GMatrix f(inputs, inputs);
GMatrix l(inputs, outputs);
for(size_t i = 0; i < inputs; i++)
{
GVec::copy(f[i].data(), pca.basis()->row(i).data(), inputs);
double sqmag = f[i].squaredMagnitude();
if(sqmag > 1e-10)
f[i] *= 1.0 / sqmag;
l[i].set(pca.basis()->row(i).data() + inputs, outputs);
}
m_pBeta = GMatrix::multiply(l, f, true, false);
m_epsilon.resize(outputs);
GVecWrapper vw(pca.centroid().data(), m_pBeta->cols());
m_pBeta->multiply(vw.vec(), m_epsilon, false);
m_epsilon *= -1.0;
GVec::add(m_epsilon.data(), pca.centroid().data() + inputs, outputs);
// Refine the results using gradient descent
refine(features, labels, 0.06, 20, 0.75);
}
void Loader::loadTest04(GMatrix &trainFeat, GMatrix &trainLab, GMatrix &testFeat, GMatrix &testLab)
{
size_t train_size = 128;
size_t test_size = 256;
trainFeat.resize(train_size, 1);
trainLab.resize(train_size, 1);
testFeat.resize(test_size, 1);
testLab.resize(test_size, 1);
size_t sines = 2;
double *x, *y;
for(size_t i = 0; i < train_size + test_size; i++)
{
if(i < train_size)
{
x = trainFeat[i];
y = trainLab[i];
}
else
{
x = testFeat[i - train_size];
y = testLab[i - train_size];
}
*x = i / double(train_size);
*y = 16.0 - 5 * *x;
for(size_t k = 0; k < sines; k++)
{
*y -= sin((4.25 * M_PI * (k + 1)) * *x);
}
}
}
static GMatrix matrix_rotate(int w, int h) {
GMatrix matrix;
matrix.setTranslate(w/2, h/2);
matrix.preRotate(M_PI / 6);
matrix.preTranslate(-w/2, -h/2);
return matrix;
}
void nominalToCat(GArgReader& args)
{
// Load the file
GMatrix* pData = loadData(args.pop_string());
Holder<GMatrix> hData(pData);
// Parse Options
int maxValues = 12;
while(args.size() > 0)
{
if(args.if_pop("-maxvalues"))
maxValues = args.pop_uint();
else
ThrowError("Invalid option: ", args.peek());
}
// Transform the data
GNominalToCat transform(maxValues);
transform.train(*pData);
GMatrix* pDataNew = transform.transformBatch(*pData);
Holder<GMatrix> hDataNew(pDataNew);
// Print results
pDataNew->print(cout);
}
void reducedRowEchelonForm(GArgReader& args)
{
GMatrix* pA = loadData(args.pop_string());
Holder<GMatrix> hA(pA);
pA->toReducedRowEchelonForm();
pA->print(cout);
}
/**
* @brief
* Returns position, rotation and scale from a matrix
*/
void PLTools::GetPosRotScale(const GMatrix &mTransform, Point3 &vPos, Quat &qRot, Point3 &vScale, bool bFlip)
{
// Get the position
vPos = mTransform.Translation();
// Get the rotation of the node as quaternion
qRot = mTransform.Rotation();
// Flip 180 degree around the y-axis? (true for camera and spot lights)
if (bFlip) {
Quat qRotationOffset;
// We have to add a rotation about the x-axis of -90 degree... is this a IGame transform bug or something other odd??
float fAngles[] = {static_cast<float>(HALFPI), 0.0f, 0.0f};
EulerToQuat(fAngles, qRotationOffset);
qRot = qRotationOffset*qRot;
// We have to 'invert the z-axis', this is no PixelLight bug or so, we decided to do so to make things more universal
fAngles[0] = 0.0f;
fAngles[2] = static_cast<float>(PI);
EulerToQuat(fAngles, qRotationOffset);
qRot = qRotationOffset*qRot;
}
// Look out! We REALLY need to take the parity of the transform matrix into account!
vScale = mTransform.Scaling()*static_cast<float>(mTransform.Parity());
}
void neighbors(GArgReader& args)
{
// Load the data
GMatrix* pData = loadData(args.pop_string());
Holder<GMatrix> hData(pData);
int neighborCount = args.pop_uint();
// Find the neighbors
GKdTree neighborFinder(pData, neighborCount, NULL, true);
GTEMPBUF(size_t, neighbors, neighborCount);
GTEMPBUF(double, distances, neighborCount);
double sumClosest = 0;
double sumAll = 0;
for(size_t i = 0; i < pData->rows(); i++)
{
neighborFinder.neighbors(neighbors, distances, i);
neighborFinder.sortNeighbors(neighbors, distances);
sumClosest += sqrt(distances[0]);
for(int j = 0; j < neighborCount; j++)
sumAll += sqrt(distances[j]);
}
cout.precision(14);
cout << "average closest neighbor distance = " << (sumClosest / pData->rows()) << "\n";
cout << "average neighbor distance = " << (sumAll / (pData->rows() * neighborCount)) << "\n";
}
/***********************************************************************//**
* @brief Rotate sky direction by zenith and azimuth angle
*
* @param[in] phi Azimuth angle (deg).
* @param[in] theta Zenith angle (deg).
*
* Rotate sky direction by a zenith and azimuth angle given in the system
* of the sky direction and aligned in celestial coordinates.
* The azimuth angle is counted counter clockwise from celestial north
* (this is identical to the astronomical definition of a position angle).
***************************************************************************/
void GSkyDir::rotate_deg(const double& phi, const double& theta)
{
// If we have no equatorial coordinates then get them now
if (!m_has_radec && m_has_lb)
gal2equ();
// Allocate Euler and rotation matrices
GMatrix ry;
GMatrix rz;
GMatrix rot;
// Set up rotation matrix to rotate from native coordinates to
// celestial coordinates
ry.eulery(m_dec*rad2deg - 90.0);
rz.eulerz(-m_ra*rad2deg);
rot = transpose(ry * rz);
// Set up native coordinate vector
double phi_rad = phi * deg2rad;
double theta_rad = theta * deg2rad;
double cos_phi = std::cos(phi_rad);
double sin_phi = std::sin(phi_rad);
double cos_theta = std::cos(theta_rad);
double sin_theta = std::sin(theta_rad);
GVector native(-cos_phi*sin_theta, sin_phi*sin_theta, cos_theta);
// Rotate vector into celestial coordinates
GVector dir = rot * native;
// Convert vector into sky position
celvector(dir);
// Return
return;
}
void GRecommenderLib::precisionRecall(GArgReader& args)
{
// Parse options
unsigned int seed = getpid() * (unsigned int)time(NULL);
bool ideal = false;
while(args.next_is_flag())
{
if(args.if_pop("-seed"))
seed = args.pop_uint();
else if(args.if_pop("-ideal"))
ideal = true;
else
throw Ex("Invalid option: ", args.peek());
}
// Load the data
if(args.size() < 1)
throw Ex("No dataset specified.");
GMatrix data;
loadData(data, args.pop_string());
// Instantiate the recommender
GCollaborativeFilter* pModel = InstantiateAlgorithm(args);
std::unique_ptr<GCollaborativeFilter> hModel(pModel);
if(args.size() > 0)
throw Ex("Superfluous argument: ", args.peek());
pModel->rand().setSeed(seed);
// Generate precision-recall data
GMatrix* pResults = pModel->precisionRecall(data, ideal);
std::unique_ptr<GMatrix> hResults(pResults);
pResults->deleteColumns(2, 1); // we don't need the false-positive rate column
pResults->print(cout);
}
GMatrixFactorization* GRecommenderLib::InstantiateMatrixFactorization(GArgReader& args)
{
if(args.size() < 1)
throw Ex("The number of intrinsic dims must be specified for this algorithm");
size_t intrinsicDims = args.pop_uint();
GMatrixFactorization* pModel = new GMatrixFactorization(intrinsicDims);
while(args.next_is_flag())
{
if(args.if_pop("-regularize"))
pModel->setRegularizer(args.pop_double());
else if(args.if_pop("-miniters"))
pModel->setMinIters(args.pop_uint());
else if(args.if_pop("-decayrate"))
pModel->setDecayRate(args.pop_double());
else if(args.if_pop("-nonneg"))
pModel->nonNegative();
else if(args.if_pop("-clampusers"))
{
GMatrix tmp;
tmp.loadArff(args.pop_string());
size_t offset = args.pop_uint();
pModel->clampUsers(tmp, offset);
}
else if(args.if_pop("-clampitems"))
{
GMatrix tmp;
tmp.loadArff(args.pop_string());
size_t offset = args.pop_uint();
pModel->clampItems(tmp, offset);
}
else
throw Ex("Invalid option: ", args.peek());
}
return pModel;
}
GMatrix* loadData(const char* szFilename)
{
PathData pd;
GFile::parsePath(szFilename, &pd);
if(_stricmp(szFilename + pd.extStart, ".sparse") == 0)
{
GDom doc;
doc.loadJson(szFilename);
GSparseMatrix sm(doc.root());
GMatrix* pData = new GMatrix(0, 3);
for(size_t i = 0; i < sm.rows(); i++)
{
GSparseMatrix::Iter rowEnd = sm.rowEnd(i);
for(GSparseMatrix::Iter it = sm.rowBegin(i); it != rowEnd; it++)
{
double* pVec = pData->newRow();
pVec[0] = i;
pVec[1] = it->first;
pVec[2] = it->second;
}
}
return pData;
}
else if(_stricmp(szFilename + pd.extStart, ".arff") == 0)
return GMatrix::loadArff(szFilename);
else
{
ThrowError("Unsupported file format: ", szFilename + pd.extStart);
return NULL;
}
}
void aggregateCols(GArgReader& args)
{
size_t c = args.pop_uint();
vector<string> files;
GFile::fileList(files);
GMatrix* pResults = NULL;
Holder<GMatrix> hResults;
size_t i = 0;
for(vector<string>::iterator it = files.begin(); it != files.end(); it++)
{
PathData pd;
GFile::parsePath(it->c_str(), &pd);
if(strcmp(it->c_str() + pd.extStart, ".arff") != 0)
continue;
GMatrix* pData = loadData(it->c_str());
Holder<GMatrix> hData(pData);
if(!pResults)
{
pResults = new GMatrix(pData->rows(), files.size());
hResults.reset(pResults);
}
pResults->copyColumns(i, pData, c, 1);
i++;
}
pResults->print(cout);
}
void Loader::loadToyData2(GMatrix &trainFeat, GMatrix &trainLab, GMatrix &testFeat, GMatrix &testLab)
{
size_t dims = 1;
size_t train_size = 300;
size_t test_size = 300;
trainFeat.resize(train_size, 1);
trainLab.resize(train_size, dims);
testFeat.resize(test_size, 1);
testLab.resize(test_size, dims);
double *x, *y;
for(size_t i = 0; i < train_size + test_size; i++)
{
if(i < train_size)
{
x = trainFeat[i];
y = trainLab[i];
}
else
{
x = testFeat[i - train_size];
y = testLab[i - train_size];
}
*x = i / double(train_size);
*y = 2.0 * *x + 0.5 * sin(10.0 * M_PI * *x + tanh(60 * (*x - 0.5)) + 1);
}
}
void AddIndexAttribute(GArgReader& args)
{
// Parse args
const char* filename = args.pop_string();
double nStartValue = 0.0;
double nIncrement = 1.0;
while(args.size() > 0)
{
if(args.if_pop("-start"))
nStartValue = args.pop_double();
else if(args.if_pop("-increment"))
nIncrement = args.pop_double();
else
ThrowError("Invalid option: ", args.peek());
}
GMatrix* pData = loadData(filename);
Holder<GMatrix> hData(pData);
GArffRelation* pIndexRelation = new GArffRelation();
pIndexRelation->addAttribute("index", 0, NULL);
sp_relation pIndexRel = pIndexRelation;
GMatrix indexes(pIndexRel);
indexes.newRows(pData->rows());
for(size_t i = 0; i < pData->rows(); i++)
indexes.row(i)[0] = nStartValue + i * nIncrement;
GMatrix* pUnified = GMatrix::mergeHoriz(&indexes, pData);
Holder<GMatrix> hUnified(pUnified);
pUnified->print(cout);
}
void Loader::loadNASDAQ(GMatrix &trainFeat, GMatrix &trainLab, GMatrix &testFeat, GMatrix &testLab)
{
GMatrix rawTrain, rawTest;
rawTrain.loadArff("data/nasdaq_train.arff");
rawTest.loadArff("data/nasdaq_test.arff");
double *x, *y;
trainFeat.resize(rawTrain.rows(), 1);
trainLab.resize(rawTrain.rows(), 1);
testFeat.resize(rawTest.rows(), 1);
testLab.resize(rawTest.rows(), 1);
for(size_t i = 0; i < rawTrain.rows() + rawTest.rows(); i++)
{
if(i < rawTrain.rows())
{
x = trainFeat[i];
y = trainLab[i];
}
else
{
x = testFeat[i - rawTrain.rows()];
y = testLab[i - rawTrain.rows()];
}
*x = double(i) / rawTrain.rows();
*y = i < rawTrain.rows() ? rawTrain[i][0] : rawTest[i - rawTrain.rows()][0];
*y = *y - 3.25;
*y = *y * 15;
}
}
void isomap(GArgReader& args)
{
// Load the file and params
GMatrix* pData = loadData(args.pop_string());
Holder<GMatrix> hData(pData);
unsigned int nSeed = getpid() * (unsigned int)time(NULL);
GRand prng(nSeed);
GNeighborFinder* pNF = instantiateNeighborFinder(pData, &prng, args);
Holder<GNeighborFinder> hNF(pNF);
int targetDims = args.pop_uint();
// Parse Options
bool tolerant = false;
while(args.size() > 0)
{
if(args.if_pop("-seed"))
prng.setSeed(args.pop_uint());
else if(args.if_pop("-tolerant"))
tolerant = true;
else
throw Ex("Invalid option: ", args.peek());
}
// Transform the data
GIsomap transform(pNF->neighborCount(), targetDims, &prng);
transform.setNeighborFinder(pNF);
if(tolerant)
transform.dropDisconnectedPoints();
GMatrix* pDataAfter = transform.reduce(*pData);
Holder<GMatrix> hDataAfter(pDataAfter);
pDataAfter->print(cout);
}
// General-purpose constructor
PlanningSystem::PlanningSystem(Agent& agent, TransitionModel& transition, ObservationModel& observation, ContentmentModel& contentment, Mentor* oracle,
size_t actionDimensions, size_t populationSize, size_t planRefinementIters, size_t burnInIters, size_t maxPlanLen, double discount, double explore, GRand& r)
: self(agent),
transitionModel(transition),
observationModel(observation),
contentmentModel(contentment),
mentor(oracle),
tutor(nullptr),
actionDims(actionDimensions),
burnIn(burnInIters),
discountFactor(discount),
explorationRate(explore),
rand(r),
randomPlan(1, actionDims)
{
GAssert(randomPlan[0].size() == actionDims);
if(populationSize < 2)
throw Ex("The population size must be at least 2");
refinementIters = populationSize * planRefinementIters;
maxPlanLength = maxPlanLen;
for(size_t i = 0; i < populationSize; i++) {
GMatrix* p = new GMatrix(0, actionDims);
plans.push_back(p);
for(size_t j = std::min(maxPlanLen, rand.next(maxPlanLen) + 2); j > 0; j--) {
// Add a random action vector to the end
GVec& newActions = p->newRow();
newActions.fillUniform(rand);
}
}
}
void cholesky(GArgReader& args)
{
GMatrix* pA = loadData(args.pop_string());
Holder<GMatrix> hA(pA);
pA->cholesky();
pA->print(cout);
}
void loadData(GMatrix& m, const char* szFilename)
{
// Load the dataset by extension
PathData pd;
GFile::parsePath(szFilename, &pd);
if(_stricmp(szFilename + pd.extStart, ".arff") == 0)
m.loadArff(szFilename);
else if(_stricmp(szFilename + pd.extStart, ".csv") == 0)
{
GCSVParser parser;
parser.parse(m, szFilename);
cerr << "\nParsing Report:\n";
for(size_t i = 0; i < m.cols(); i++)
cerr << to_str(i) << ") " << parser.report(i) << "\n";
}
else if(_stricmp(szFilename + pd.extStart, ".dat") == 0)
{
GCSVParser parser;
parser.setSeparator('\0');
parser.parse(m, szFilename);
cerr << "\nParsing Report:\n";
for(size_t i = 0; i < m.cols(); i++)
cerr << to_str(i) << ") " << parser.report(i) << "\n";
}
else
throw Ex("Unsupported file format: ", szFilename + pd.extStart);
}
void correlation(GArgReader& args)
{
GMatrix* pA = loadData(args.pop_string());
Holder<GMatrix> hA(pA);
int attr1 = args.pop_uint();
int attr2 = args.pop_uint();
// Parse Options
bool aboutorigin = false;
while(args.size() > 0)
{
if(args.if_pop("-aboutorigin"))
aboutorigin = true;
else
ThrowError("Invalid option: ", args.peek());
}
double m1, m2;
if(aboutorigin)
{
m1 = 0;
m2 = 0;
}
else
{
m1 = pA->mean(attr1);
m2 = pA->mean(attr2);
}
double corr = pA->linearCorrelationCoefficient(attr1, m1, attr2, m2);
cout.precision(14);
cout << corr << "\n";
}
void breadthFirstUnfolding(GArgReader& args)
{
// Load the file and params
GMatrix* pData = loadData(args.pop_string());
Holder<GMatrix> hData(pData);
size_t nSeed = getpid() * (unsigned int)time(NULL);
GRand prng(nSeed);
GNeighborFinder* pNF = instantiateNeighborFinder(pData, &prng, args);
Holder<GNeighborFinder> hNF(pNF);
int targetDims = args.pop_uint();
// Parse Options
size_t reps = 1;
Holder<GMatrix> hControlData(NULL);
while(args.size() > 0)
{
if(args.if_pop("-seed"))
nSeed = args.pop_uint();
else if(args.if_pop("-reps"))
reps = args.pop_uint();
else
throw Ex("Invalid option: ", args.peek());
}
// Transform the data
GBreadthFirstUnfolding transform(reps, pNF->neighborCount(), targetDims);
transform.rand().setSeed(nSeed);
transform.setNeighborFinder(pNF);
GMatrix* pDataAfter = transform.reduce(*pData);
Holder<GMatrix> hDataAfter(pDataAfter);
pDataAfter->print(cout);
}
void MeshExporter::_dumpJoint(IGameNode * node)
{
IGameObject * obj = node->GetIGameObject();
IGameObject::MaxType T = obj->GetMaxType();
IGameObject::ObjectTypes type = obj->GetIGameType();
const char * name = node->GetName();
switch(type)
{
case IGameObject::IGAME_BONE:
case IGameObject::IGAME_HELPER:
{
joint * bone = mMeshSource->NewJoint(node->GetName());
int parent = -1;
if (node->GetNodeParent())
{
parent = _getJointId(node->GetNodeParent()->GetName());
mMeshSource->SetJointLink(parent, mMeshSource->GetJointCount() - 1);
}
else
{
INode* pNode = node->GetMaxNode()->GetParentNode();
if (pNode)
parent = _getJointId(pNode->GetName());
}
IGameControl * pGameControl = node->GetIGameControl();
// base matrix
{
GMatrix matWorld = node->GetLocalTM();
bone->position = Utility::ToFloat3(matWorld.Translation());
bone->rotation = Utility::ToQuat(matWorld.Rotation());
bone->scale = Utility::ToFloat3(matWorld.Scaling());
/*
if (node->GetNodeParent())
{
int parentId = _getBoneId(node->GetNodeParent()->GetName());
if (parentId != -1)
{
xBone * parentBn = GetBone(parentId);
bone->position = bone->position - parentBn->position;
bone->orientation = parentBn->orientation.Inverse() * bone->orientation;
bone->scale = bone->scale / parentBn->scale;
}
}
*/
}
_dumpAnimation(pGameControl, mMeshSource->GetJointCount() - 1);
}
break;
}
}
