static void
eval_root(void)
{
oast_t *ast;
oword_t offset;
orecord_t *record;
ofunction_t *function;
assert(current_record == root_record);
assert(current_function == root_record->function);
oeval_ast(root_record->function->ast->c.ast);
odata(root_record->function->ast->c.ast);
for (offset = type_vector->offset - 1; offset > t_root; --offset) {
record = type_vector->v.ptr[offset];
if (otype(record) == t_prototype &&
likely(record->function && ofunction_p(record->function))) {
function = record->function;
current_record = record;
current_function = function;
/* Error later if function is actually called but never defined */
if ((ast = function->ast)) {
oeval_ast(ast->l.ast);
eval_ast_declexpr(ast->r.ast->r.ast);
oeval_ast(ast->c.ast);
odata(function->ast->c.ast);
}
}
}
current_function = root_record->function;
current_record = root_record;
}
////////////////////////////////////////////////////////////////////////////////
// Test boost::simd::output_iterator behavior with std::vector
////////////////////////////////////////////////////////////////////////////////
NT2_TEST_CASE_TPL(simd_vector_output_iterator, BOOST_SIMD_SIMD_TYPES )
{
typedef typename boost::simd::output_iterator<T> oit_;
typedef typename boost::simd::input_iterator<T> iit_;
typedef typename boost::simd::pack<T> p_t;
static const std::size_t card = boost::simd::meta::cardinal_of<p_t>::value;
// static const std::size_t at_ = card - 1;
std::vector<T, boost::simd::memory::allocator<T> > idata(3*card);
std::vector<T, boost::simd::memory::allocator<T> > odata(3*card);
for(int i=0; i<3*card; ++i) idata[i] = i;
oit_ obegin = boost::simd::output_begin(odata.begin());
oit_ oend = boost::simd::output_end(odata.end());
iit_ ibegin = boost::simd::input_begin(idata.begin());
iit_ iend = boost::simd::input_end(idata.end());
for(; obegin != oend; ++obegin) *obegin = *ibegin++;
iit_ rbegin = boost::simd::input_begin(&odata[0]);
iit_ rend = boost::simd::input_end(&odata[0]+3*card);
for(int c = 0; rbegin != rend; ++rbegin, c++)
{
for(int i=0;i<card;++i)
NT2_TEST_EQUAL( (*rbegin)[i], idata[i + c*card]);
}
}
void encode(const std::vector<boost::shared_ptr<std::vector<double> > >& input,
const Model& model, std::vector<boost::shared_ptr<std::vector<double> > >& output)
{
assert(input.size());
const size_t rows = input.size(), cols = input[0]->size();
assert(cols == (size_t)model.getModel()->high_dim());
const int lowdim = model.getModel()->low_dim();
std::vector<double> idata(rows * cols);
std::vector<double> odata(rows * lowdim);
for (size_t i = 0; i < input.size(); ++i) {
std::copy(input[i]->begin(), input[i]->end(), idata.begin() + cols * i);
}
YA_WRAP_RM(double) input_w(&idata[0], rows, cols);
YA_WRAP_RM(double) output_w(&odata[0], rows, lowdim);
model.getModel()->forward_t(input_w, output_w);
output.clear();
for (size_t i = 0; i < rows; ++i) {
output.push_back(boost::make_shared<std::vector<double> >(odata.begin() + i * lowdim, odata.begin() + (i+1) * lowdim));
}
}
// ---
tERROR pr_call _MemoryRealloc( tPO* po, tHANDLE* handle, tDWORD size ) {
tOBJECT* obj;
tERROR error;
PR_TRACE_A0( MakeObject(handle), "Enter _MemoryRealloc" );
if ( handle->obj == NULL ) { // alloc new memory
error = PrAlloc( (tPTR*)&obj, sizeof(tOBJECT) + size );
if ( PR_SUCC(error) ) {
wlock(po);
handle->obj = obj;
_ObjectInit0( handle );
wunlock(po);
}
}
else {
wlock(po);
if ( PR_SUCC(error=PrRealloc((tPTR*)&handle->obj,handle->obj,sizeof(tOBJECT)+size)) ) {
*odata(handle->obj) = handle->obj + 1;
}
wunlock(po);
}
PR_TRACE_A1( MakeObject(handle), "Leave _MemoryRealloc ret %terr", error );
return error;
}
void trainModel(std::vector<boost::shared_ptr<std::vector<double> > >& input,
DimensionalityReductionMethod method, int lowdim, int neighbors, Model& model)
{
assert(input.size());
const size_t rows = input.size(), cols = input[0]->size();
std::vector<double> idata(rows * cols);
std::vector<double> odata(rows * lowdim);
for (size_t i = 0; i < input.size(); ++i) {
std::copy(input[i]->begin(), input[i]->end(), idata.begin() + cols * i);
}
YA_WRAP_RM(double) input_w(&idata[0], rows, cols);
YA_WRAP_RM(double) output_w(&odata[0], rows, lowdim);
boost::shared_ptr<YADimReduce<double> > reductionMethod;
switch(method) {
case DimensionalityReductionMethod::PCA:
reductionMethod = boost::make_shared<YAPCAReduce<double> >();
break;
case DimensionalityReductionMethod::LLE:
reductionMethod = boost::make_shared<YALLEReduce<double> >();
reductionMethod->neighbor_weight_mode(1);
reductionMethod->neighbors(neighbors);
reductionMethod->neighbor_mode(0);
break;
case DimensionalityReductionMethod::Isomap:
reductionMethod = boost::make_shared<YAIsoReduce<double> >();
reductionMethod->neighbor_weight_mode(0);
reductionMethod->neighbors(neighbors);
reductionMethod->neighbor_mode(0);
break;
}
EigenOptions eigopts;
reductionMethod->verbose(2);
reductionMethod->find_t(input_w, output_w, lowdim, eigopts);
model.setMethod(method);
model.setModel(reductionMethod);
}
void
JPlotFitQuad2::CalculateFirstPass()
{
JFloat Y, X, X2, YX, X3, YX2, X4, Sig;
JFloat tempa, tempb, tempc, det;
JSize i,j, k;
JArray<JFloat> yAdjError;
const JPlotDataBase* data = GetData();
J2DDataPoint point;
JSize rcount = GetRealElementCount();
for (i=1; i<= rcount; i++)
{
J2DDataPoint point = GetRealElement(i);
JFloat newVal = 1;
if (point.yerr != 0)
{
newVal = point.yerr;
}
yAdjError.AppendElement(newVal);
}
JMatrix odata(rcount, 3, 1.0);
JVector yData(rcount);
for (i=1; i<= rcount; i++)
{
point = GetRealElement(i);
JFloat yerr = yAdjError.GetElement(i);
odata.SetElement(i, 1, 1/(yerr*yerr));
odata.SetElement(i, 2, point.x/(yerr*yerr));
odata.SetElement(i, 3, point.x*point.x/(yerr*yerr));
yData.SetElement(i, point.y/(yerr*yerr));
}
JMatrix tData = odata.Transpose();
JMatrix lData = tData * odata;
JMatrix rData = tData * yData;
JMatrix parms(3,1);
JGaussianElimination(lData, rData, &parms);
for (k=1; k<= 4; k++)
{
Y = 0;
X = 0;
X2 = 0;
YX = 0;
X3 = 0;
YX2 = 0;
X4 = 0;
Sig = 0;
for (i=1; i<= rcount; i++)
{
point = GetRealElement(i);
JFloat yerr = yAdjError.GetElement(i);
Y += point.y/(yerr*yerr);
X += point.x/(yerr*yerr);
X2 += point.x*point.x/(yerr*yerr);
YX += point.y*point.x/(yerr*yerr);
X3 += point.x*point.x*point.x/(yerr*yerr);
YX2 += point.x*point.x*point.y/(yerr*yerr);
X4 += point.x*point.x*point.x*point.x/(yerr*yerr);
Sig += 1/(yerr*yerr);
}
JFloat cv1 = 0, cv2 = 0, cv3 = 0;
for (i=1; i<= rcount; i++)
{
point = GetRealElement(i);
JFloat syi = yAdjError.GetElement(i);
JFloat yi = point.y;
JFloat xi = point.x;
for (j = 1; j <= rcount; j++)
{
point = GetRealElement(j);
JFloat syj = yAdjError.GetElement(j);
JFloat yj = point.y;
JFloat xj = point.x;
cv1 += xi*xj*xj*(xi*yj-yi*xj)/(syi*syi*syj*syj);
cv2 += (xi*xj*xj*(yi - yj))/(syi*syi*syj*syj);
cv3 += (xi*xj*xj*(xj - xi))/(syi*syi*syj*syj);
}
}
det = Sig*(X2*X4-X3*X3) + X*(X3*X2-X*X4) + X2*(X*X3-X2*X2);
tempa = (Y*(X2*X4-X3*X3) + X*(X3*YX2-YX*X4) + X2*(YX*X3-X2*YX2))/det;
tempb = (Sig*(YX*X4-YX2*X3) + Y*(X3*X2-X*X4) + X2*(X*YX2-YX*X2))/det;
tempc = (Sig*cv1 + X*cv2 + Y*cv3)/det;
for (i=1; i<=rcount; i++)
{
J2DDataPoint point = GetRealElement(i);
JFloat newVal =
sqrt(point.yerr*point.yerr + (tempb+2*tempc*point.x)*(tempb+2*tempc*point.x)*point.xerr*point.xerr);
if (newVal == 0)
{
newVal = 1;
}
yAdjError.SetElement(i, newVal);
}
}
// itsAParameter = tempa;
// itsBParameter = tempb;
// itsCParameter = tempc;
itsAParameter = parms.GetElement(1, 1);
itsBParameter = parms.GetElement(2, 1);
itsCParameter = parms.GetElement(3, 1);
itsChi2Start = 0;
for (i=1; i<= rcount; i++)
{
point = GetRealElement(i);
JFloat yerr = yAdjError.GetElement(i);
itsChi2Start += pow(point.y - tempa - tempb*point.x - tempc*point.x*point.x,2)/(yerr*yerr);
}
itsAErrParameter = 0;
itsBErrParameter = 0;
itsCErrParameter = 0;
}
void
JPlotFitExp::CalculateFirstPass()
{
J2DDataPoint point;
const JSize count = GetRealElementCount();
JSize rcount = 0;
for (JIndex i = 1; i <= count; i++)
{
point = GetRealElement(i);
if (point.y > 0)
{
rcount++;
}
}
JMatrix odata(rcount, 2, 1.0);
JVector yData(rcount);
rcount = 0;
for (JIndex i = 1; i <= count; i++)
{
point = GetRealElement(i);
if (point.y > 0)
{
rcount++;
JFloat yerr = point.yerr;
if (yerr == 0)
{
yerr = 1;
}
else
{
yerr = log((point.y - point.yerr)/point.y);
}
odata.SetElement(rcount, 1, 1/(yerr*yerr));
odata.SetElement(rcount, 2, log(point.x)/(yerr*yerr));
yData.SetElement(rcount, log(point.x)/(yerr*yerr));
}
}
JMatrix tData = odata.Transpose();
JMatrix lData = tData * odata;
JMatrix rData = tData * yData;
JMatrix parms(2,1);
JGaussianElimination(lData, rData, &parms);
JVector eparms(2);
eparms.SetElement(1, exp(parms.GetElement(1,1)));
eparms.SetElement(2, parms.GetElement(2,1));
SetCurrentParameters(eparms);
itsChi2Start = 0;
for (JIndex i = 1; i <= count; i++)
{
// do
// {
point = GetRealElement(i);
// }
// while (point.y == 0);
JFloat yerr = point.yerr;
if (yerr == 0)
{
yerr = 1;
}
itsChi2Start += pow(point.y - FunctionN(point.x),2)/(yerr*yerr);
}
}
