void ReadINI(void)
{if (pdini("HZKFILE=",8,text))
strcpy(HZK,text);
else
strcpy(HZK,"C:\\HREADER\\HZK16");
if (pdini("LABELPATH=",10,text))
{strcpy(LABEL_PATH,text);
zl(LABEL_PATH);
}
else
strcpy(LABEL_PATH,"C:\\HREADER\\LABEL\\");
if (pdini("TEMPPATH=",9,text))
{strcpy(TEMP_PATH,text);
zl(TEMP_PATH);
}
else
strcpy(TEMP_PATH,"C:\\HREADER\\TEMP\\");
if (pdini("HISTORY=",8,text))
{strcpy(HISTORY,text);
History=1;
}
else
History=0;
printf("OK!\n");
}
void
InterfaceElement3dTrLin :: computeLCS(FloatMatrix &answer)
{
// computes local coordinate system unit vectors (expressed in global cs)
// unit vectors are stored rowwise
FloatArray xl(3), yl(3), zl(3), t2(3);
// compute local x-axis xl (node(2)-node(1))
xl.at(1) = this->giveNode(2)->giveCoordinate(1) - this->giveNode(1)->giveCoordinate(1);
xl.at(2) = this->giveNode(2)->giveCoordinate(2) - this->giveNode(1)->giveCoordinate(2);
xl.at(3) = this->giveNode(2)->giveCoordinate(3) - this->giveNode(1)->giveCoordinate(3);
xl.normalize();
// compute another in-plane tangent vector t2 (node(3)-node(1))
t2.at(1) = this->giveNode(3)->giveCoordinate(1) - this->giveNode(1)->giveCoordinate(1);
t2.at(2) = this->giveNode(3)->giveCoordinate(2) - this->giveNode(1)->giveCoordinate(2);
t2.at(3) = this->giveNode(3)->giveCoordinate(3) - this->giveNode(1)->giveCoordinate(3);
// compute local z axis as product of xl and t2
zl.beVectorProductOf(xl, t2);
zl.normalize();
// compute local y axis as product of zl x xl
yl.beVectorProductOf(zl, xl);
answer.resize(3, 3);
for ( int i = 1; i <= 3; i++ ) {
answer.at(1, i) = xl.at(i);
answer.at(2, i) = yl.at(i);
answer.at(3, i) = zl.at(i);
}
}
// we use a tree architecture to build the subzones
int VEF::divideIntoZones(Zone z, int nbZones){
TreeZone tz(z);
TreeZone *father;
int flag, flag2, depth; // used to determine the cutting axis
flag = flag2 = depth = 0;
Vertex bottom, middle_bottom, middle_top, top;
bottom = middle_bottom = z.getZoneBottomVertex();
top = middle_top = z.getZoneTopVertex();
int id = 0;
int rootFlag = 0;
std::vector<TreeZone> parents; // store the parent trees relative to the one we manipulate
for (int i = 0; i < nbZones; i++){
if (!(i % 2)){
if (flag % 3 == 0) // we cut along the x axis
{
Vertex vx(middle_top.getX() - (middle_top.getX() / 2), middle_top.getY(), middle_top.getZ());
Zone zl(bottom, vx, -1);
TreeZone *l = new TreeZone(zl);
tz.addLeftChild(l);
//top.setX(vx.getX());
middle_top = vx;
}
if (flag % 3 == 1) // we cut along the y axis
{
Vertex vy(middle_top.getX(), middle_top.getY() - middle_top.getY() / 2, middle_top.getZ());
Zone zl(bottom, vy, -1);
TreeZone *l = new TreeZone(zl);
tz.addLeftChild(l);
//top.setY(vy.getY());
middle_top = vy;
}
if (flag % 3 == 2) // we cut along the z axis
{
Vertex vz(middle_top.getX(), middle_top.getY(), middle_top.getZ() - middle_top.getZ() / 2);
Zone zl(bottom, vz, -1);
TreeZone *l = new TreeZone(zl);
tz.addLeftChild(l);
//top.setZ(vz.getZ());
middle_top = vz;
}
}
else
{
if (flag2 % 3 == 0) // we cut along the x axis
{
Vertex vx(middle_bottom.getX() + (middle_bottom.getX() / 2), middle_bottom.getY(), middle_bottom.getZ());
Zone zr(vx, top, -1);
TreeZone *r = new TreeZone(zr);
tz.addRightChild(r);
middle_bottom = vx;
}
if (flag2 % 3 == 1) // we cut along the y axis
{
Vertex vy(middle_bottom.getX(), middle_bottom.getY() + (middle_bottom.getY() / 2), middle_bottom.getZ());
Zone zr(vy, top, -1);
TreeZone *r = new TreeZone(zr);
tz.addRightChild(r);
middle_bottom = vy;
}
if (flag2 % 3 == 2) // we cut along the z axis
{
Vertex vz(middle_bottom.getX(), middle_bottom.getY(), middle_bottom.getZ() + (middle_bottom.getZ() / 2));
Zone zr(vz, top, -1);
TreeZone *r = new TreeZone(zr);
tz.addRightChild(r);
}
if (depth){
if (!(*(father->getRightChild()) == tz))
{
if (father->getRightChild()->getLeftChild() == NULL)
{ // the brother of t doesn't exist yet
tz = *(father->getRightChild());
father = &(parents.back());
parents.pop_back();
}
}
}
parents.push_back(*father);
father = &tz;
tz = *(tz.getLeftChild());
depth++;
}
}
// depth-first search to add the zones we created (the leaves) into the zone vector
while (tz.hasLeftChild()){
father = &tz;
tz = *(tz.getLeftChild());
}
tz.getRoot().setZoneId(id);
m_zones.push_back(tz.getRoot());
id++;
// we stop when we reach the root for the second time, i.e, when all the leaves have been found
/*while(rootFlag != 1){
if (father->hasRightChild()){
father->getRightChild()->getRoot().setZoneId(id);
m_zones.push_back(father->getRightChild()->getRoot());
}
tz = father;
if (depth){
father = parents.back();
parents.pop_back();
}
depth--;
}*/
return 0;
}
void CLogitVGPiecewiseBoundLikelihood::precompute()
{
//This function is based on the Matlab code
//function [f, gm, gv] = Ellp(m, v, bound, ind), to compute common variables later
//used in get_variational_expection and get_variational_first_derivative
const Map<VectorXd> eigen_c(m_bound.get_column_vector(0), m_bound.num_rows);
const Map<VectorXd> eigen_b(m_bound.get_column_vector(1), m_bound.num_rows);
const Map<VectorXd> eigen_a(m_bound.get_column_vector(2), m_bound.num_rows);
const Map<VectorXd> eigen_mu(m_mu.vector, m_mu.vlen);
const Map<VectorXd> eigen_s2(m_s2.vector, m_s2.vlen);
Map<VectorXd> eigen_l(m_bound.get_column_vector(3), m_bound.num_rows);
Map<VectorXd> eigen_h(m_bound.get_column_vector(4), m_bound.num_rows);
index_t num_rows = m_bound.num_rows;
index_t num_cols = m_mu.vlen;
m_pl = SGMatrix<float64_t>(num_rows,num_cols);
m_ph = SGMatrix<float64_t>(num_rows,num_cols);
m_cdf_diff = SGMatrix<float64_t>(num_rows,num_cols);
m_l2_plus_s2 = SGMatrix<float64_t>(num_rows,num_cols);
m_h2_plus_s2 = SGMatrix<float64_t>(num_rows,num_cols);
m_weighted_pdf_diff = SGMatrix<float64_t>(num_rows,num_cols);
Map<MatrixXd> eigen_pl(m_pl.matrix, num_rows, num_cols);
Map<MatrixXd> eigen_ph(m_ph.matrix, num_rows, num_cols);
Map<MatrixXd> eigen_cdf_diff(m_cdf_diff.matrix, num_rows, num_cols);
Map<MatrixXd> eigen_l2_plus_s2(m_l2_plus_s2.matrix, num_rows, num_cols);
Map<MatrixXd> eigen_h2_plus_s2(m_h2_plus_s2.matrix, num_rows, num_cols);
Map<MatrixXd> eigen_weighted_pdf_diff(m_weighted_pdf_diff.matrix, num_rows, num_cols);
SGMatrix<float64_t> zl(num_rows, num_cols);
Map<MatrixXd> eigen_zl(zl.matrix, num_rows, num_cols);
SGMatrix<float64_t> zh(num_rows, num_cols);
Map<MatrixXd> eigen_zh(zh.matrix, num_rows, num_cols);
//bsxfun(@minus,l,m)
eigen_zl = ((-eigen_mu).replicate(1,eigen_l.rows()).array().transpose().colwise() + eigen_l.array()).matrix();
//bsxfun(@minus,h,m)
eigen_zh = ((-eigen_mu).replicate(1,eigen_h.rows()).array().transpose().colwise() + eigen_h.array()).matrix();
VectorXd eigen_s_inv = eigen_s2.array().sqrt().inverse().matrix();
//zl = bsxfun(@times, bsxfun(@minus,l,m), 1./sqrt(v))
eigen_zl = (eigen_zl.array().rowwise()*eigen_s_inv.array().transpose()).matrix();
//zh = bsxfun(@times, bsxfun(@minus,h,m), 1./sqrt(v))
eigen_zh = (eigen_zh.array().rowwise()*eigen_s_inv.array().transpose()).matrix();
//Usually we use pdf in log-domain and the log_sum_exp trick
//to avoid numerical underflow in particular for IID samples
for (index_t r = 0; r < zl.num_rows; r++)
{
for (index_t c = 0; c < zl.num_cols; c++)
{
if (CMath::abs(zl(r, c)) == CMath::INFTY)
m_pl(r, c) = 0;
else
m_pl(r, c) = CMath::exp(CGaussianDistribution::univariate_log_pdf(zl(r, c)));
if (CMath::abs(zh(r, c)) == CMath::INFTY)
m_ph(r, c) = 0;
else
m_ph(r, c) = CMath::exp(CGaussianDistribution::univariate_log_pdf(zh(r, c)));
}
}
//pl = bsxfun(@times, normpdf(zl), 1./sqrt(v));
eigen_pl = (eigen_pl.array().rowwise()*eigen_s_inv.array().transpose()).matrix();
//ph = bsxfun(@times, normpdf(zh), 1./sqrt(v));
eigen_ph = (eigen_ph.array().rowwise()*eigen_s_inv.array().transpose()).matrix();
SGMatrix<float64_t> & cl = zl;
SGMatrix<float64_t> & ch = zh;
for (index_t r = 0; r < zl.num_rows; r++)
{
for (index_t c = 0; c < zl.num_cols; c++)
{
//cl = 0.5*erf(zl/sqrt(2)); %normal cdf -const
cl(r, c) = CStatistics::normal_cdf(zl(r, c)) - 0.5;
//ch = 0.5*erf(zl/sqrt(2)); %normal cdf -const
ch(r, c) = CStatistics::normal_cdf(zh(r, c)) - 0.5;
}
}
Map<MatrixXd> eigen_cl(cl.matrix, num_rows, num_cols);
Map<MatrixXd> eigen_ch(ch.matrix, num_rows, num_cols);
eigen_cdf_diff = eigen_ch - eigen_cl;
float64_t l_bak = eigen_l(0);
eigen_l(0) = 0;
float64_t h_bak = eigen_h(eigen_h.size()-1);
eigen_h(eigen_h.size()-1) = 0;
//bsxfun(@plus, l.^2, v)
eigen_l2_plus_s2 = (eigen_s2.replicate(1,eigen_l.rows()).array().transpose().colwise() + eigen_l.array().pow(2)).matrix();
//bsxfun(@plus, h.^2, v)
eigen_h2_plus_s2 = (eigen_s2.replicate(1,eigen_h.rows()).array().transpose().colwise() + eigen_h.array().pow(2)).matrix();
//pl.*l - ph.*h
eigen_weighted_pdf_diff = (eigen_pl.array().colwise() * eigen_l.array() - eigen_ph.array().colwise() * eigen_h.array()).matrix();
eigen_l(0) = l_bak;
eigen_h(eigen_h.size()-1) = h_bak;
}
