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; } }