// This only copies the current information of the argument e to
// *this ExprRep.
void ExprRep::reduceTo(const ExprRep *e) {
if (e->appComputed()) {
appValue() = e->appValue();
appComputed() = true;
flagsComputed() = true;
knownPrecision() = e->knownPrecision();
#ifdef CORE_DEBUG
relPrecision() = e->relPrecision();
absPrecision() = e->absPrecision();
numNodes() = e->numNodes();
#endif
}
d_e() = e->d_e();
//visited() = e->visited();
sign() = e->sign();
uMSB() = e->uMSB();
lMSB() = e->lMSB();
// length() = e->length(); // fixed? original = 1
measure() = e->measure();
// BFMSS[2,5] bound.
u25() = e->u25();
l25() = e->l25();
v2p() = e->v2p();
v2m() = e->v2m();
v5p() = e->v5p();
v5m() = e->v5m();
high() = e->high();
low() = e->low(); // fixed? original = 0
lc() = e->lc();
tc() = e->tc();
// Chee (Mar 23, 2004), Notes on ratFlag():
// ===============================================================
// For more information on the use of this flag, see progs/pentagon.
// This is an integer valued member of the NodeInfo class.
// Its value is used to determine whether
// we can ``reduce'' an Expression to a single node containing
// a BigRat value. This reduction is done if the global variable
// rationalReduceFlag=true. The default value is false.
// This is the intepretation of ratFlag:
// ratFlag < 0 means irrational
// ratFlag = 0 means not initialized
// ratFlag > 0 means rational
// Currently, ratFlag>0 is an upper bound on the size of the expression,
// since we recursively compute
// ratFlag(v) = ratFlag(v.lchild)+ratFlag(v.rchild) + 1.
// PROPOSAL: if ratFlag() > RAT_REDUCE_THRESHHOLD
// then we automatically do a reduction. We must determine
// an empirical value for RAT_REDUCE_THRESHOLD
if (rationalReduceFlag) {
ratFlag() = e->ratFlag();
if (e->ratFlag() > 0 && e->ratValue() != NULL) {
ratFlag() ++;
if (ratValue() == NULL)
ratValue() = new BigRat(*(e->ratValue()));
else
*(ratValue()) = *(e->ratValue());
} else
ratFlag() = -1;
}
}
// Computes the root bit bound of the expression.
// In effect, computeBound() returns the current value of low.
extLong ExprRep::computeBound() {
extLong measureBd = measure();
// extLong cauchyBd = length();
extLong ourBd = (d_e() - EXTLONG_ONE) * high() + lc();
// BFMSS[2,5] bound.
extLong bfmsskBd;
if (v2p().isInfty() || v2m().isInfty())
bfmsskBd = CORE_INFTY;
else
bfmsskBd = l25() + u25() * (d_e() - EXTLONG_ONE) - v2() - ceilLg5(v5());
// since we might compute \infty - \infty for this bound
if (bfmsskBd.isNaN())
bfmsskBd = CORE_INFTY;
extLong bd = core_min(measureBd,
// core_min(cauchyBd,
core_min(bfmsskBd, ourBd));
#ifdef CORE_SHOW_BOUNDS
std::cout << "Bounds (" << measureBd <<
"," << bfmsskBd << ", " << ourBd << "), ";
std::cout << "MIN = " << bd << std::endl;
std::cout << "d_e= " << d_e() << std::endl;
#endif
#ifdef CORE_DEBUG_BOUND
// Some statistics about which one is/are the winner[s].
computeBoundCallsCounter++;
int number_of_winners = 0;
std::cerr << " New contest " << std::endl;
if (bd == bfmsskBd) {
BFMSS_counter++;
number_of_winners++;
std::cerr << " BFMSS is the winner " << std::endl;
}
if (bd == measureBd) {
Measure_counter++;
number_of_winners++;
std::cerr << " measureBd is the winner " << std::endl;
}
/* if (bd == cauchyBd) {
Cauchy_counter++;
number_of_winners++;
std::cerr << " cauchyBd is the winner " << std::endl;
}
*/
if (bd == ourBd) {
LiYap_counter++;
number_of_winners++;
std::cerr << " ourBd is the winner " << std::endl;
}
assert(number_of_winners >= 1);
if (number_of_winners == 1) {
if (bd == bfmsskBd) {
BFMSS_only_counter++;
std::cerr << " BFMSSBd is the only winner " << std::endl;
} else if (bd == measureBd) {
Measure_only_counter++;
std::cerr << " measureBd is the only winner " << std::endl;
}
/* else if (bd == cauchyBd) {
Cauchy_only_counter++;
std::cerr << " cauchyBd is the only winner " << std::endl;
} */
else if (bd == ourBd) {
LiYap_only_counter++;
std::cerr << " ourBd is the only winner " << std::endl;
}
}
#endif
return bd;
}//computeBound()
void OrganizedData::process(RawData* raw, int nBlock, double pTest, int nSupport)
{
int nData = raw->nData, nDim = raw->nDim - 1;
this->nSupport = nSupport;
this->nBlock = nBlock;
this->nDim = nDim;
train = field<mat>(nBlock,2);
test = field<mat>(nBlock,2);
support = field<mat>(1,2);
mat xm(nSupport,nDim),
ym(nSupport,1);
vec mark(nData); mark.fill(0);
printf("Randomly selecting %d supporting point ...\n", nSupport);
for (int i = 0; i < nSupport; i++)
{
int pos = IRAND(0, nData - 1);
while (mark[pos] > 0)
pos = IRAND(0, nData - 1);
mark[pos] = 1;
for (int j = 0; j < nDim; j++)
xm(i, j) = raw->X(pos,j);
ym(i,0) = raw->X(pos,nDim);
}
support(0,0) = xm; xm.clear();
support(0,1) = ym; ym.clear();
cout << "Partitioning the remaining data into " << nBlock << " cluster using K-Mean ..." << endl;
vvd _remain;
for (int i = 0; i < nData; i++) if (!mark(i))
{
rowvec R = raw->X.row(i);
_remain.push_back(r2v(R));
}
mat remaining = v2m(_remain);
mark.clear();
RawData* remain = new RawData(remaining);
KMean* partitioner = new KMean(remain);
Partition* clusters = partitioner->cluster(nBlock);
cout << "Packaging training/testing data points into their respective cluster" << endl;
for (int i = 0; i < nBlock; i++)
{
cout << "Processing block " << i + 1 << endl;
int bSize = (int) clusters->member[i].size(),
tSize = (int) floor(bSize * pTest),
pos = 0,
counter = 0;
mark = vec(bSize); mark.fill(0);
if (bSize > tSize) // if we can afford to draw tSize test points from this block without depleting it ...
{
mat xt(tSize,nDim),
yt(tSize,1);
for (int j = 0; j < tSize; j++)
{
pos = IRAND(0, bSize - 1);
while (mark[pos] > 0)
pos = IRAND(0, bSize - 1);
mark[pos] = 1; pos = clusters->member[i][pos];
for (int t = 0; t < nDim; t++)
xt(j, t) = remain->X(pos,t);
yt(j,0) = remain->X(pos,nDim);
}
bSize -= tSize;
nTest += tSize;
test(i,0) = xt; xt.clear();
test(i,1) = yt; yt.clear();
}
nTrain += bSize;
mat xb(bSize,nDim),
yb(bSize,1);
//cout << remain->X.n_rows << endl;
for (int j = 0; j < (int)mark.n_elem; j++) if (mark[j] < 1)
{
for (int t = 0; t < nDim; t++) {
xb(counter,t) = remain->X(clusters->member[i][j],t);
}
yb(counter++,0) = remain->X(clusters->member[i][j],nDim);
}
train(i,0) = xb; xb.clear();
train(i,1) = yb; yb.clear();
mark.clear();
printf("Done ! nData[%d] = %d, nTrain[%d] = %d, nTest[%d] = %d .\n", i, (int) clusters->member[i].size(), i, train(i,0).n_rows, i, (int) test(i,0).n_rows);
}
}
void
CConfigDisplay::ReadReg(RegistryKey & reg) {
AutoLog alog("CCD::ReadReg");
m_vBkPanel = reg.Read(RegWindowsColorBkPanel, m_vBkPanel);
m_vBkNormal = reg.Read(RegWindowsColorBkNormal, m_vBkNormal);
m_vBkHigh = reg.Read(RegWindowsColorBkHigh, m_vBkHigh);
m_vBkSel = reg.Read(RegWindowsColorBkSel, m_vBkSel);
m_vTxPanel = reg.Read(RegWindowsColorTxPanel, m_vTxPanel);
m_vTxNormal = reg.Read(RegWindowsColorTxNormal, m_vTxNormal);
m_vTxHigh = reg.Read(RegWindowsColorTxHigh, m_vTxHigh);
m_vTxSel = reg.Read(RegWindowsColorTxSel, m_vTxSel);
m_vBkColHdr = reg.Read(RegWindowsColorBkColHdr, m_vBkColHdr);
m_vTxColHdr = reg.Read(RegWindowsColorTxColHdr, m_vTxColHdr);
MBCONFIG_READ_COLOR_3D(reg,MB3DCOLHDRCOLOR,
m_vcrColHdrInUL,m_vcrColHdrInLR,m_vcrColHdrOutUL,m_vcrColHdrOutLR);
MBCONFIG_READ_COLOR_3D(reg,MB3DDATACOLOR,
m_vcrDataInUL,m_vcrDataInLR,m_vcrDataOutUL,m_vcrDataOutLR);
MBCONFIG_READ_COLOR_3D(reg,MB3DSTATUSCOLOR,
m_vcrStatusInUL,m_vcrStatusInLR,m_vcrStatusOutUL,m_vcrStatusOutLR);
m_3dData = reg.Read(MB3DDATA,0);
m_3dColHdr = reg.Read(MB3DCOLHDRS,0);
m_3dStatus = reg.Read(MB3DSTATUS,0);
if (IsWindow(m_3dDataCheck.m_hWnd)) {
m_3dColHdrsCheck.SetCheck(m_3dColHdr);
m_3dDataCheck.SetCheck(m_3dData);
m_3dStatusCheck.SetCheck(m_3dStatus);
}
v2m();
m_vBorderWidth = reg.Read(RegWindowsBorderWidth, m_vBorderWidth);
m_vBorderHorz = reg.Read(RegWindowsBorderHorz, m_vBorderHorz);
m_vBorderVert = reg.Read(RegWindowsBorderVert, m_vBorderVert);
int sel;
if (IsWindow(m_BorderWidth.m_hWnd)) {
sel = m_BorderWidth.SelectString(-1, numToString(m_vBorderWidth));
m_BorderWidth.SetCurSel(sel);
}
AutoBuf buf(1000);
reg.Read(RegWindowsFontTitles, buf.p, 999, "");
if (MBUtil::ConfigFontValidate(buf.p) && strlen(buf.p) > MBCCFONTFACEPOS) {
MBUtil::FontStr2LogFont(buf.p, &m_lfTitles);
}
reg.Read(RegWindowsFontPanel, buf.p, 999, "");
if (MBUtil::ConfigFontValidate(buf.p) && strlen(buf.p) > MBCCFONTFACEPOS) {
MBUtil::FontStr2LogFont(buf.p, &m_lfPanel);
}
reg.Read(RegWindowsFontColHdr, buf.p, 999, "");
if (MBUtil::ConfigFontValidate(buf.p) && strlen(buf.p) > MBCCFONTFACEPOS) {
MBUtil::FontStr2LogFont(buf.p, &m_lfColHdr);
}
EnableDisable();
}
void SqrtRep::computeExactFlags() {
if (!child->flagsComputed())
child->computeExactFlags();
if (rationalReduceFlag)
ratFlag() = -1;
sign() = child->sign();
if (sign() < 0)
core_error("squareroot is called with negative operand.",
__FILE__, __LINE__, true);
uMSB() = child->uMSB() / EXTLONG_TWO;
lMSB() = child->lMSB() / EXTLONG_TWO;
// length() = child->length();
measure() = child->measure();
// BFMSS[2,5] bound.
if (child->v2p() + ceilLg5(child->v5p()) + child->u25() >=
child->v2m() + ceilLg5(child->v5m()) + child->l25()) {
extLong vtilda2 = child->v2p() + child->v2m();
v2p() = vtilda2 / EXTLONG_TWO;
v2m() = child->v2m();
extLong vmod2;
if (v2p().isInfty())
vmod2 = CORE_INFTY;
else
vmod2 = vtilda2 - EXTLONG_TWO*v2p(); // == vtilda2 % 2
extLong vtilda5 = child->v5p() + child->v5m();
v5p() = vtilda5 / EXTLONG_TWO;
v5m() = child->v5m();
extLong vmod5;
if (v5p().isInfty())
vmod5 = CORE_INFTY;
else
vmod5 = vtilda5 - EXTLONG_TWO*v5p(); // == vtilda5 % 2
u25() = (child->u25() + child->l25() + vmod2 + ceilLg5(vmod5) + EXTLONG_ONE) / EXTLONG_TWO;
l25() = child->l25();
} else {
extLong vtilda2 = child->v2p() + child->v2m();
v2p() = child->v2p();
v2m() = vtilda2 / EXTLONG_TWO;
extLong vmod2;
if (v2m().isInfty())
vmod2 = CORE_INFTY;
else
vmod2 = vtilda2 - EXTLONG_TWO*v2m(); // == vtilda2 % 2
extLong vtilda5 = child->v5p() + child->v5m();
v5p() = child->v5p();
v5m() = vtilda5 / EXTLONG_TWO;
u25() = child->u25();
extLong vmod5;
if (v5m().isInfty())
vmod5 = CORE_INFTY;
else
vmod5 = vtilda5 - EXTLONG_TWO*v5m(); // == vtilda5 % 2
l25() = (child->u25() + child->l25() + vmod2 + ceilLg5(vmod5) + EXTLONG_ONE) / EXTLONG_TWO;
}
high() = (child->high() +EXTLONG_ONE)/EXTLONG_TWO;
low() = child->low() / EXTLONG_TWO;
lc() = child->lc();
tc() = child->tc();
flagsComputed() = true;
}// SqrtRep::computeExactFlags
