Word NewGameWindow(Word NewVidSize)
{
LongWord *LongPtr;
Byte *DestPtr;
int i;
printf("Called: %d\n", NewVidSize);
if (NewVidSize == VidSize)
return VidSize;
printf("Setting Size: %d (from %d)\n", NewVidSize, VidSize);
if (NewVidSize < 4) {
w = VidXs[NewVidSize];
h = VidYs[NewVidSize];
v = VidVs[NewVidSize];
} else {
fprintf(stderr, "Invalid Vid size: %d\n", NewVidSize);
exit(EXIT_FAILURE);
}
/* Free Image */
/* Resize Window */
gfxbuf = (Byte *)malloc(w * h);
/* Create Image */
VideoPointer = gfxbuf;
VideoWidth = w;
InitYTable();
SetAPalette(rBlackPal);
ClearTheScreen(BLACK);
BlastScreen();
LongPtr = (LongWord *) LoadAResource(VidPics[NewVidSize]);
if (GameShapes)
FreeSomeMem(GameShapes);
GameShapes = (Byte **)AllocSomeMem(lMSB(LongPtr[0]));
DLZSS((Byte *)GameShapes, (Byte *)&LongPtr[1], lMSB(LongPtr[0]));
ReleaseAResource(VidPics[NewVidSize]);
LongPtr = (LongWord *)GameShapes;
DestPtr = (Byte *)GameShapes;
for (i = 0; i < ((NewVidSize == 1) ? 57 : 47); i++)
GameShapes[i] = DestPtr + lMSB(LongPtr[i]);
VidSize = NewVidSize;
return VidSize;
}
void MultRep::computeApproxValue(const extLong& relPrec,
const extLong& absPrec) {
if (lMSB() < EXTLONG_BIG && lMSB() > EXTLONG_SMALL) {
extLong r = relPrec + EXTLONG_FOUR;
extLong afr = - first->lMSB() + EXTLONG_ONE;
extLong afa = second->uMSB() + absPrec + EXTLONG_FIVE;
extLong af = afr > afa ? afr : afa;
extLong asr = - second->lMSB() + EXTLONG_ONE;
extLong asa = first->uMSB() + absPrec + EXTLONG_FIVE;
extLong as = asr > asa ? asr : asa;
appValue() = first->getAppValue(r, af)*second->getAppValue(r, as);
} else {
std::cerr << "lMSB = " << lMSB() << std::endl;
core_error("a huge lMSB in MulRep", __FILE__, __LINE__, false);
}
}
void DivRep::computeExactFlags() {
if (!first->flagsComputed())
first->computeExactFlags();
if (!second->flagsComputed())
second->computeExactFlags();
if (!second->sign())
core_error("zero divisor.", __FILE__, __LINE__, true);
if (!first->sign()) {// value must be exactly zero.
reduceToZero();
return;
}
// rational node
if (rationalReduceFlag) {
if (first->ratFlag() > 0 && second->ratFlag() > 0) {
BigRat val = (*(first->ratValue()))/(*(second->ratValue()));
reduceToBigRat(val);
ratFlag() = first->ratFlag() + second->ratFlag();
return;
} else
ratFlag() = -1;
}
// value is irrational.
uMSB() = first->uMSB() - second->lMSB();
lMSB() = first->lMSB() - second->uMSB() - EXTLONG_ONE;
sign() = first->sign() * second->sign();
extLong df = first->d_e();
extLong ds = second->d_e();
// extLong lf = first->length();
// extLong ls = second->length();
// length() = df * ls + ds * lf;
measure() = (first->measure())*ds + (second->measure())*df;
// BFMSS[2,5] bound.
v2p() = first->v2p() + second->v2m();
v2m() = first->v2m() + second->v2p();
v5p() = first->v5p() + second->v5m();
v5m() = first->v5m() + second->v5p();
u25() = first->u25() + second->l25();
l25() = first->l25() + second->u25();
high() = first->high() + second->low();
low() = first->low() + second->high();
lc() = ds * first->lc() + df * second->tc();
tc() = core_min(ds * first->tc() + df * second->lc(), measure());
flagsComputed() = true;
}
void DivRep::computeApproxValue(const extLong& relPrec,
const extLong& absPrec) {
if (lMSB() < EXTLONG_BIG && lMSB() > EXTLONG_SMALL) {
extLong rr = relPrec + EXTLONG_SEVEN; // These rules come from
extLong ra = uMSB() + absPrec + EXTLONG_EIGHT; // Koji's Master Thesis, page 65
extLong ra2 = core_max(ra, EXTLONG_TWO);
extLong r = core_min(rr, ra2);
extLong af = - first->lMSB() + r;
extLong as = - second->lMSB() + r;
extLong pr = relPrec + EXTLONG_SIX;
extLong pa = uMSB() + absPrec + EXTLONG_SEVEN;
extLong p = core_min(pr, pa); // Seems to be an error:
// p can be negative here!
// Also, this does not conform to
// Koji's thesis which has a default
// relative precision (p.65).
appValue() = first->getAppValue(r, af).div(second->getAppValue(r, as), p);
} else {
std::cerr << "lMSB = " << lMSB() << std::endl;
core_error("a huge lMSB in DivRep", __FILE__, __LINE__, false);
}
}
void SqrtRep::computeApproxValue(const extLong& relPrec,
const extLong& absPrec) {
extLong r = relPrec + relPrec + EXTLONG_EIGHT; // chenli: ???
extLong a = absPrec + absPrec + EXTLONG_EIGHT;
extLong pr = - lMSB() + r;
extLong p = pr < a ? pr : a;
Real val = child->getAppValue(r, a);
if (incrementalEvalFlag) {
if (appValue() == CORE_REAL_ZERO)
appValue() = val;
appValue() = val.sqrt(p, appValue().BigFloatValue());
} else
appValue() = val.sqrt(p);
}
void ExprRep::reduceToBigRat(const BigRat& rat) {
Real value(rat);
//appValue() = value;
appComputed() = false; // since appValue is not assigned until approx() is called
flagsComputed() = true;
knownPrecision() = CORE_negInfty;
#ifdef CORE_DEBUG
relPrecision() = EXTLONG_ZERO;
absPrecision() = CORE_negInfty;
//numNodes() = numNodes();
#endif
d_e() = EXTLONG_ONE;
//visited() = e->visited();
sign() = value.sign();
uMSB() = value.MSB();
lMSB() = value.MSB();
// length() = value.length(); // fixed? original = 1
measure() = value.height(); // measure <= height for rational value
// BFMSS[2,5] bound.
value.ULV_E(u25(), l25(), v2p(), v2m(), v5p(), v5m());
extLong u_e = u25() + v2p();
extLong l_e = l25() + v2m();
u_e = u_e + ceilLg5(v5p());
l_e = l_e + ceilLg5(v5m());
if (l_e == EXTLONG_ZERO) { // no divisions introduced
high() = u_e;
low() = EXTLONG_ONE - u_e; // - (u_e - 1)
} else {
high() = u_e - l_e + EXTLONG_ONE;
low() = 2 - high();
}
lc() = l_e;
tc() = u_e;
if (ratValue() == NULL)
ratValue() = new BigRat(rat);
else
*(ratValue()) = rat;
}
void NegRep::computeExactFlags() {
if (!child->flagsComputed())
child->computeExactFlags();
if (child->sign() == 0) {
reduceToZero();
return;
}
if (rationalReduceFlag) {
if (child->ratFlag()>0 && child->ratValue() != NULL) {
BigRat val = -(*(child->ratValue()));
reduceToBigRat(val);
ratFlag() = child->ratFlag()+1;
return;
} else
ratFlag() = -1;
}
sign() = -child->sign();
uMSB() = child->uMSB();
lMSB() = child->lMSB();
// length() = child->length();
measure() = child->measure();
u25() = child->u25();
l25() = child->l25();
v2p() = child->v2p();
v2m() = child->v2m();
v5p() = child->v5p();
v5m() = child->v5m();
high() = child->high();
low() = child->low();
lc() = child->lc();
tc() = child->tc();
flagsComputed() = true;
}//NegRep::computeExactFlags
const std::string ExprRep::dump(int level) const {
std::ostringstream ost;
if (level == OPERATOR_ONLY) {
ost << op();
} else if (level == VALUE_ONLY) {
ost << appValue();
} else if (level == OPERATOR_VALUE) {
ost << op() << "[val: " << appValue() << "]";
} else if (level == FULL_DUMP) {
ost << op()
<< "[val: " << appValue() << "; "
<< "kp: " << knownPrecision() << "; "
#ifdef CORE_DEBUG
<< "r: " << relPrecision() << "; "
<< "a: " << absPrecision() << "; "
#endif
<< "lMSB: " << lMSB() << "; "
<< "uMSB: " << uMSB() << "; "
<< "sign: " << sign() << "; "
// << "length: " << length() << "; "
<< "measure: " << measure() << "; "
<< "d_e: " << d_e() << "; "
<< "u25: " << u25() << "; "
<< "l25: " << l25() << "; "
<< "v2p: " << v2p() << "; "
<< "v2m: " << v2m() << "; "
<< "v5p: " << v5p() << "; "
<< "v5m: " << v5m() << "; "
<< "high: " << high() << "; "
<< "low: " << low() << "; "
<< "lc: " << lc() << "; "
<< "tc: " << tc()
<< "]";
}
return std::string(ost.str());
// note that str() return an array not properly terminated!
}
void ExprRep::reduceToZero() {
appValue() = CORE_REAL_ZERO;
appComputed() = true;
flagsComputed() = true;
knownPrecision() = CORE_negInfty;
#ifdef CORE_DEBUG
relPrecision() = EXTLONG_ZERO;
absPrecision() = CORE_negInfty;
// numNodes() = 0;
#endif
d_e() = EXTLONG_ONE;
visited() = false;
sign() = 0;
uMSB() = CORE_negInfty;
lMSB() = CORE_negInfty;
// length() = 0; // fixed? original = 1
measure() = EXTLONG_ZERO;
// BFMSS[2,5] bound.
u25() = l25() = v2p() = v2m() = v5p() = v5m() = EXTLONG_ZERO;
low() = EXTLONG_ONE; // fixed? original = 0
high() = lc() = tc() = EXTLONG_ZERO;
if (rationalReduceFlag) {
if (ratFlag() > 0) {
ratFlag() ++;
if (ratValue() == NULL)
ratValue() = new BigRat(0);
else
*(ratValue()) = 0;
} else
ratFlag() = 1;
}
}
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
// 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;
}
}
