int CheckGameAvb() { TCHAR szRomDat[MAX_PATH]; FILE* h; int bOK; int nBufferSize = nBurnDrvCount + 256; TCHAR* buffer = (TCHAR*)malloc(nBufferSize * sizeof(TCHAR)); if (buffer == NULL) { return 1; } memset(buffer, 0, nBufferSize * sizeof(TCHAR)); CreateRomDatName(szRomDat); if ((h = _tfopen(szRomDat, _T("r"))) == NULL) { return 1; } _fgetts(buffer, nBufferSize, h); fclose(h); bOK = DoCheck(buffer); if (buffer) { free(buffer); buffer = NULL; } return bOK; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- BOOL CMapCheckDlg::OnInitDialog() { CDialog::OnInitDialog(); DoCheck(); return TRUE; }
void DoCheckPointer (const PolyWord pt) { if (pt == PolyWord::FromUnsigned(0)) return; if (OBJ_IS_AN_INTEGER(pt)) return; DoCheck (pt); if (pt.IsDataPtr()) { PolyObject *obj = pt.AsObjPtr(); DoCheckObject (obj, obj->LengthWord()); } }
void CDummyUsbDevice::RunL() { DoCheck(); if (GetNextLine() < 0) { iTest.End(); iTest.Getch(); CActiveScheduler::Stop(); } else { iLineNumber++; iTest.Next(_L("")); InterpretLine(); DoCommand(); DoAsyncOp(); } }
void DoCheckObject (const PolyObject *base, POLYUNSIGNED L) { PolyWord *pt = (PolyWord*)base; CheckAddress(pt); MemSpace *space = gMem.SpaceForAddress(pt-1); if (space == 0) Crash ("Bad pointer 0x%08" PRIxPTR " found", (uintptr_t)pt); ASSERT (OBJ_IS_LENGTH(L)); POLYUNSIGNED n = OBJ_OBJECT_LENGTH(L); if (n == 0) return; ASSERT (n > 0); ASSERT(pt-1 >= space->bottom && pt+n <= space->top); byte flags = GetTypeBits(L); /* discards GC flag and mutable bit */ if (flags == F_BYTE_OBJ) /* possibly signed byte object */ return; /* Nothing more to do */ if (flags == F_CODE_OBJ) /* code object */ { ScanCheckAddress checkAddr; /* We flush the instruction cache here in case we change any of the instructions when we update addresses. */ machineDependent->FlushInstructionCache(pt, (n + 1) * sizeof(PolyWord)); machineDependent->ScanConstantsWithinCode((PolyObject *)base, (PolyObject *)base, n, &checkAddr); /* Skip to the constants. */ base->GetConstSegmentForCode(n, pt, n); } else if (flags == F_CLOSURE_OBJ) { n -= sizeof(PolyObject*) / sizeof(PolyWord); pt += sizeof(PolyObject*) / sizeof(PolyWord); } else ASSERT (flags == 0); /* ordinary word object */ while (n--) DoCheck (*pt++); }
wxThread::ExitCode AegisubVersionCheckerThread::Entry() { if (!interactive) { // Automatic checking enabled? if (!OPT_GET("App/Auto/Check For Updates")->GetBool()) return 0; // Is it actually time for a check? time_t next_check = OPT_GET("Version/Next Check")->GetInt(); if (next_check > wxDateTime::GetTimeNow()) return 0; } if (VersionCheckLock.TryLock() != wxMUTEX_NO_ERROR) return 0; try { DoCheck(); } catch (const agi::Exception &e) { PostErrorEvent(wxString::Format( _("There was an error checking for updates to Aegisub:\n%s\n\nIf other applications can access the Internet fine, this is probably a temporary server problem on our end."), e.GetMessage())); } catch (...) { PostErrorEvent(_("An unknown error occurred while checking for updates to Aegisub.")); } VersionCheckLock.Unlock(); // While Options isn't perfectly thread safe, this should still be okay. // Traversing the std::map to find the key-value pair doesn't modify any data as long as // the key already exists (which it does at this point), and modifying the value only // touches that specific key-value pair and will never cause a rebalancing of the tree, // because the tree only depends on the keys. // Lastly, writing options to disk only happens when Options.Save() is called. time_t new_next_check_time = wxDateTime::GetTimeNow() + 60*60; // in one hour OPT_SET("Version/Next Check")->SetInt((int)new_next_check_time); return 0; }
int ModulesLoaded(WPARAM, LPARAM) { Silent = true; HOTKEYDESC hkd = { 0 }; hkd.cbSize = sizeof(hkd); hkd.dwFlags = HKD_TCHAR; hkd.pszName = "Check for pack updates"; hkd.ptszDescription = LPGENT("Check for pack updates"); hkd.ptszSection = LPGENT("Pack Updater"); hkd.pszService = MODNAME"/CheckUpdates"; hkd.DefHotKey = HOTKEYCODE(HOTKEYF_CONTROL, VK_F10) | HKF_MIRANDA_LOCAL; hkd.lParam = FALSE; Hotkey_Register(&hkd); if (AllowUpdateOnStartup()) DoCheck(UpdateOnStartup); Timer = CreateWaitableTimer(NULL, FALSE, NULL); InitTimer(); return 0; }
INT_PTR MenuCommand(WPARAM, LPARAM) { Silent = false; DoCheck(TRUE); return 0; }
int F843343(TRUSERID *handle,int iRequest,ST_PACK *rPack,int *pRetCode,char *szMsg) { int ret=0; CAccTrans *pAccTrans=CAccTrans::getInstance(); des2src(pAccTrans->trans.opercode,rPack->scust_limit); pAccTrans->trans.transcode=TC_SHOPCARDOPEN; ret=pAccTrans->InitTrans(); if (ret) return ret; TRANS& trans=pAccTrans->trans; T_t_shop tShop; T_t_shopcard tShopCard; memset(&tShop,0,sizeof(tShop)); memset(&tShopCard,0,sizeof(tShopCard)); ret=DoCheck(rPack,tShopCard,tShop); if (ret) return ret; ret=DoUpdate(tShopCard); if (ret) return ret; T_t_transdtl transdtl; memset(&transdtl,0,sizeof(transdtl)); transdtl.purseno=trans.purseno; transdtl.amount=trans.totaltransamt; transdtl.managefee=trans.totalfeeamt; transdtl.paytype=trans.fundtype; des2src(transdtl.voucherno,trans.voucherno); transdtl.status[0]=DTLSTATUS_SUCCESS; transdtl.revflag[0]='0'; transdtl.errcode=0; transdtl.custid=trans.custid; strcpy(transdtl.custname,tShop.shopname); strcpy(transdtl.transdate,trans.transdate); strcpy(transdtl.transtime,trans.transtime); strcpy(transdtl.accdate,trans.accdate); strcpy(transdtl.acctime,trans.acctime); transdtl.termid=trans.termid; transdtl.termseqno=trans.termseqno; transdtl.transcode=trans.transcode; des2src(transdtl.opercode,trans.opercode); transdtl.cardno=tShopCard.cardno; transdtl.cardbefbal=trans.cardbefbal; transdtl.cardaftbal=trans.cardaftbal; des2src(transdtl.showcardno,tShopCard.showcardno); ret=DB_t_transdtl_add(&transdtl); if (ret) { if (DB_REPEAT==ret) return E_DB_TRANSDTL_E; else return E_DB_TRANSDTL_I; } ST_CPACK aPack; ST_PACK *outPack = &(aPack.pack); memset(&aPack,0,sizeof(aPack)); ResetNormalCPack(&aPack,0,1); SetCol(handle,0); SetCol(handle,F_LVOL0,F_LVOL1,F_LVOL5, F_SCUST_NO, F_SCUST_NO2,F_SCUST_AUTH,F_SCERT_NO, F_SDATE0,F_SNAME,F_SNAME2, F_SOPEN_EMP,F_SSTATUS0, F_DAMT2,F_LSERIAL1,F_VSMESS, F_SORDER0,F_SORDER1,F_SORDER2, F_SHOLDER_AC_NO,F_SSTAT_TYPE,F_SSTAT_TYPE2, F_SNATION_CODE,F_SBRANCH_CODE0,F_LVOL10,F_LVOL11, 0); outPack->lvol10=SHOPCARDTYPE; //卡类型 outPack->lvol11=tShopCard.shopid; //商户号 outPack->lvol0 = tShopCard.cardno; //交易卡号 outPack->lvol1 = CUSTTYPE_SHOP; //客户类别 outPack->lvol5 = SHOPFEETYPE; //收费类别 des2src(outPack->scust_no,tShopCard.showcardno); //显示卡号 des2src(outPack->scust_no2,tShop.deptcode); //部门号 des2src(outPack->scert_no,tShop.idno); //身份证号 des2src(outPack->sname,tShop.shopname); //客户姓名 des2src(outPack->sopen_emp,trans.cardpwd); //卡密码 des2src(outPack->sdate0,tShopCard.expiredate); //有效截至日期 strcpy(outPack->sorder0,CARD_STRUCT_VERSION); //制卡版本号 strcpy(outPack->sorder1,CARD_REGISTER_PUBLISH_CODE); //发卡注册标识号 strcpy(outPack->sorder2,CARD_REGISTER_SERVICE_CODE); //服务注册标识号 sprintf(outPack->sholder_ac_no,"%d",tShop.shopid); //商户号 des2src(outPack->sstat_type,tShop.idtype); //证件类型 des2src(outPack->sbranch_code0,tShop.areacode); //院校代码 PutRow(handle,outPack,pRetCode,szMsg); return 0; }
/* ** The AGM itself ** ** A[0]=1 B[0]=1/sqrt(2) Sum=1 ** ** n=1..inf ** A[n] = (A[n-1] + B[n-1])/2 ** B[n] = Sqrt(A[n-1]*B[n-1]) ** C[n] = (A[n-1]-B[n-1])/2 or: ** C[n]^2 = A[n]^2 - B[n]^2 or: ** C[n]^2 = 4A[n+1]*C[n+1] ** Sum = Sum - C[n]^2*(2^(n+1)) ** PI[n] = 4A[n+1]^2 / Sum ** ** However, it's not implemented that way. We can save a full ** sized multiplication (with two numbers) by rearranging it, ** and keeping the squares of the A and B. Also, we can do the ** first pass a little differently since A and A^2 will both be 1. ** ** A[0]=1 A[0]^2=1 ** B[0]=1/sqrt(2) B[0]^2=0.5 ** ** First pass: ** ** A[1] = (A[0] + B[0])/2 ** B[1]^2 = A[0]*B[0] ; Since A[0]==1, B[1]^2=B[0] ** C[1]^2 = ((A[0]^2+B[0]^2)/2-B[1]^2)/2 ** ** Remainging passes: ** ** C[n] = (A[n-1]-B[n-1])/2; C[n] is actually temp usage of C[n]^2 ** A[n] = A[n-1] - C[n] ** C[n]^2 = C[n]*C[n] ** B[n]^2 = (A[n-1]^2+B[n-1]^2-4C[n]^2)/2 ** ** Then the rest of the formula is done the same: ** ** A[n]^2 = C[n]^2 + B[n]^2 ** B[n] = sqrt(B[n]^2) ** Sum = Sum - C[n]^2*(2^(n+1)) ** ** It is an unusual arrangment, but they are all derived directly ** from the standard AGM formulas as given by Salamin. ** */ static int ComputeFastAGM(size_t Len, size_t MaxPasses) { int Sign; size_t Pass; double Pow2; clock_t LoopTime,EndTime,StartTime; BigInt AGM_A, AGM_B, AGM_Sum, AGM_C2; BigInt AGM_A2, AGM_B2; /* Squares */ int Done; /* boolean */ if ((Cfg.PiFormulaToUse != 2) && (Cfg.PiFormulaToUse != 3)) FatalError("FastAGM was somehow called with pi formula %d\n", Cfg.PiFormulaToUse); if (!Cfg.Macintosh) fprintf(stderr,"Creating vars"); AGM_A = CreateBigInt(Len); AGM_A2 = CreateBigInt(Len); AGM_B = CreateBigInt(Len); AGM_B2 = CreateBigInt(Len); AGM_C2 = CreateBigInt(Len); AGM_Sum = CreateBigInt(Len); if (!Cfg.Macintosh) BackSpace(13); Num1IsCached = Num2IsCached = 0; StartTime = clock(); Pow2 = 4.0; Pass = 0; if (!LoadData(AGM_A,AGM_A2,AGM_B,AGM_B2,AGM_Sum,OldRoot, &StartTime,&Pow2,&Pass,Len,Cfg.PiFormulaToUse)) { fprintf(stderr, "Init : "); LoopTime = clock(); Pow2 = 4.0; Pass = 0; if (Cfg.PiFormulaToUse==2) { if (!Cfg.Macintosh) fprintf(stderr,"Setting vars"); SetNum(AGM_A,Len, BI_One,0); SetNum(AGM_A2,Len, BI_One,0); SetNum(AGM_B2,Len, BI_OneHalf,0); SetNum(AGM_Sum,Len,BI_One,0); ClearBigInt(OldRoot,Len); if (!Cfg.Macintosh) BackSpace(12); Sqrt05(AGM_B,Len); if ((Cfg.AGMSelfCheck == 3) || (Cfg.AGMSelfCheck == 4)) { /* We can use OldRoot and DSWork as scratch. */ if (!Cfg.Macintosh) fprintf(stderr,"Self Check"); SpecialSquare(OldRoot,AGM_B,Len,DSWork); DoCheck(OldRoot,AGM_B2,0,Len); ClearBigInt(OldRoot,Len); if (!Cfg.Macintosh) BackSpace(10); } } else { Sqrt20(AGM_A,Len); Sqrt60(AGM_A2,Len); if (!Cfg.Macintosh) fprintf(stderr,"Square"); Add(AGM_B,AGM_A,AGM_A2,Len); DivBy(AGM_B,AGM_B,4,Len); SpecialSquare(AGM_B2,AGM_B,Len,AGM_A); if (!Cfg.Macintosh) BackSpace(6); if (!Cfg.Macintosh) fprintf(stderr,"Setting vars"); ClearBigInt(OldRoot,Len); SetNum(AGM_A,Len, BI_One,0); SetNum(AGM_A2,Len, BI_One,0); SetNum(AGM_Sum,Len,BI_One,0); if (!Cfg.Macintosh) BackSpace(12); Pass=1; } EndTime = clock(); fprintf(stderr, "Time= %0.2f\n", ((double)EndTime-(double)LoopTime) /CLOCKS_PER_SEC); DumpTimings(((double)EndTime-(double)LoopTime) /CLOCKS_PER_SEC); if (Cfg.AlwaysSaveData) SaveData(AGM_A,AGM_A2,AGM_B,AGM_B2,AGM_Sum,OldRoot, ((double)EndTime-(double)StartTime)/CLOCKS_PER_SEC, Pow2,Pass,Len,Cfg.PiFormulaToUse); } /* DumpBigInt("AGM_A ",AGM_A,Len); DumpBigInt("AGM_A2 ",AGM_A2,Len); DumpBigInt("AGM_B ",AGM_B,Len); DumpBigInt("AGM_B2 ",AGM_B2,Len); DumpBigInt("AGM_C2 ",AGM_C2,Len); DumpBigInt("AGM_Sum",AGM_Sum,Len); */ Done=0; MaxPasses+=Pass; while ((!Done) && (Pass < MaxPasses)) {size_t FNZ; int Key=0; /* DJGPP stuff to test the self checking. ** Comment out the keyboard break statement at the end of the loop. extern int getkey(void); if (TestKeyboard()) {Key=getkey();srand((unsigned int)time(NULL));} */ fprintf(stderr, "Pass %4s: ", Num2Str(2<<(++Pass))); LoopTime = clock(); if ((Pass==1) && (strcmp(GetCheckStr(AGM_A),"1000000000000000")==0)) { /* ** Since AGM_A==1, we can do the first pass a little differently ** and avoide the multiplication completely. */ if (!Cfg.Macintosh) fprintf(stderr,"AGM Part1"); /* Compute a=(a+b)/2 */ if (Key=='1') CorruptVar(AGM_A,Len); Add(AGM_A, AGM_A, AGM_B, Len);DivBy(AGM_A,AGM_A, 2, Len); if (Cfg.AGMSelfCheck >= 1) { DivBy(DSWork,AGM_B,2,Len);AddInt(DSWork,BI_OneHalf); DoCheck(DSWork,AGM_A,1,Len); } /* Compute C^2 and B^2 */ Add(AGM_C2,AGM_A2,AGM_B2,Len);DivBy(AGM_C2,AGM_C2,2,Len); if (Cfg.AGMSelfCheck >= 1) Add(DSWork,AGM_A2,AGM_B2,Len); Copy(AGM_B2,AGM_B,Len); /* AGM_A == 1.0, so we can copy */ Sign=Sub(AGM_C2,AGM_C2,AGM_B2,Len);DivBy(AGM_C2,AGM_C2,2,Len); if (Key=='4') CorruptVar(AGM_B2,Len); if (Key=='5') CorruptVar(AGM_C2,Len); if (Sign) FatalError("AGM_C2 should never be negative.\n"); if (!Cfg.Macintosh) BackSpace(9); } else { if (!Cfg.Macintosh) fprintf(stderr,"AGM Part1"); /* Compute C */ /* Sign=Sub(AGM_C2, AGM_A, AGM_B, Len);DivBy(AGM_C2,AGM_C2,2,Len); */ Sign=HalfDiff(AGM_C2,AGM_A,AGM_B,Len); if (Sign) FatalError("AGM_C2 should never be negative.\n"); /* Compute A. AGM_C2 is still only C at the moment. */ if (Cfg.AGMSelfCheck >= 1) {Add(DSWork,AGM_A,AGM_B,Len);DivBy(DSWork,DSWork,2,Len);} if (Sub(AGM_A,AGM_A,AGM_C2,Len)) FatalError("AGM_A should never be negative.\n"); if (Key=='1') CorruptVar(AGM_A,Len); if (Cfg.AGMSelfCheck >= 1) DoCheck(DSWork,AGM_A,2,Len); if (!Cfg.Macintosh) BackSpace(9); if (!Cfg.Macintosh) fprintf(stderr,"Sqr"); /* Compute C^2 */ SpecialSquare(AGM_C2,AGM_C2,Len,AGM_B); if (Key=='5') CorruptVar(AGM_C2,Len); if (!Cfg.Macintosh) BackSpace(3); if (!Cfg.Macintosh) fprintf(stderr,"AGM Part2"); if (Cfg.AGMSelfCheck >= 1) Add(DSWork,AGM_A2,AGM_B2,Len); /* Compute B^2 */ Sign=SpecialAGMFunc1(AGM_B2,AGM_A2,AGM_C2,Len); if (Key=='4') CorruptVar(AGM_B2,Len); /* Add(AGM_B2,AGM_B2,AGM_A2,Len); MulBy(AGM_A2,AGM_C2,4,Len); Sign=Sub(AGM_B2,AGM_B2,AGM_A2,Len); DivBy(AGM_B2,AGM_B2,2,Len); */ if (Sign) FatalError("AGM_B2 should never be negative.\n"); if (!Cfg.Macintosh) BackSpace(9); } if (!Cfg.Macintosh) fprintf(stderr,"AGM Part3"); /* Compute A^2 */ if (Cfg.AGMSelfCheck >= 1) { Add(DSWork,DSWork,AGM_B2,Len); Add(DSWork,DSWork,AGM_B2,Len); DivBy(DSWork,DSWork,4,Len); } Add(AGM_A2,AGM_C2,AGM_B2,Len); if (Key=='2') CorruptVar(AGM_A2,Len); if (Cfg.AGMSelfCheck >= 1) DoCheck(DSWork,AGM_A2,3,Len); if (!Cfg.Macintosh) BackSpace(9); /* ** Do some self checking. The estimate formula predicts the number of ** leading zeros. It's based on the regular AGM accuracy formula. It ** predicts just a couple of digits less than what is actually there, ** so if anything happens, this should fail. But, since it is so ** close, it just might fail for the wrong reason. */ if (!Cfg.Macintosh) fprintf(stderr,"Self Check"); FNZ=FindFirstNonZero(AGM_C2,Len); if ((Pass > 3) && (FNZ != Len)) {size_t P=Pass-2;size_t Est; /* formula based on the AGM 'number of digits right' formula */ if (Cfg.PiFormulaToUse==2) Est=(1.364376354*(1<<(P))-P*.301029995-2.342434419)/2; else /* other agm does 1 less pass, so pass is one higher, so div by 4 */ Est=(sqrt(3.0)*1.364376354*(1<<(P))-P*.301029995-2.690531961)/4; if (Est >= FNZ) { fprintf(stderr,"\aAGM self check fails. Predicted: %lu Actual: %lu\n", (ULINT)Est,(ULINT)FNZ); fprintf(stderr,"Beyond what I've tested, this may not be an actual failure\n"); fprintf(stderr,"but an inaccuracy in the self check formula itself.\n"); } } /* See if it's done. (ie: more than half zeros) */ if (FNZ > Len/2+4) Done=1; if ((Cfg.AGMSelfCheck == 2) || (Cfg.AGMSelfCheck == 4)) { /* We can use AGM_B and DSWork as scratch. */ SpecialSquare(AGM_B,AGM_A,Len,DSWork); DoCheck(AGM_B,AGM_A2,4,Len); } if (!Cfg.Macintosh) BackSpace(10); /* Compute B=sqrt(B^2) */ if (!Done) AGMSqrt(AGM_B, AGM_B2, Len, (Pass>5) ? (2<<(Pass-5)) : 0); if (Key=='3') CorruptVar(AGM_B,Len); if (!Cfg.Macintosh) fprintf(stderr,"AGM Part4"); /* Sum = Sum - C2 * 2^(J+1) */ MulByFloat(AGM_C2,Pow2,Len);Pow2 *= 2.0; if (Sub(AGM_Sum,AGM_Sum,AGM_C2,Len)) FatalError("AGM_Sum should never be negative.\n"); EndTime=clock(); /* DumpBigInt("AGM_A ",AGM_A,Len); DumpBigInt("AGM_A2 ",AGM_A2,Len); DumpBigInt("AGM_B ",AGM_B,Len); DumpBigInt("AGM_B2 ",AGM_B2,Len); DumpBigInt("AGM_C2 ",AGM_C2,Len); DumpBigInt("AGM_Sum",AGM_Sum,Len); */ if (!Cfg.Macintosh) BackSpace(9); if (!Done && ((Cfg.AGMSelfCheck == 3) || (Cfg.AGMSelfCheck == 4))) { /* We can use AGM_C2 and DSWork as scratch. */ if (!Cfg.Macintosh) fprintf(stderr,"Self Check"); SpecialSquare(AGM_C2,AGM_B,Len,DSWork); DoCheck(AGM_C2,AGM_B2,5,Len); if (!Cfg.Macintosh) BackSpace(10); } DumpDebug("Pass %u took:", Pass); fprintf(stderr,"Time= %0.2f\n", ((double)EndTime-(double)LoopTime) /CLOCKS_PER_SEC); DumpTimings(((double)EndTime-(double)LoopTime) /CLOCKS_PER_SEC); if (Cfg.AlwaysSaveData) SaveData(AGM_A,AGM_A2,AGM_B,AGM_B2,AGM_Sum,OldRoot, ((double)EndTime-(double)StartTime) /CLOCKS_PER_SEC,Pow2,Pass,Len,Cfg.PiFormulaToUse); if (TestKeyboard()) break; } /* We've done the AGM part, now do the final calculation. */ LoopTime=clock(); if (Done) { fprintf(stderr, "Final : "); /* ** Since AGM_A and AGM_B have converged, I can compute the AGM_A2 ** by calculating AGM_B2. That can be done like up above, except ** we don't need the 4*AGM_C2 because that will be zero. */ if (!Cfg.Macintosh) fprintf(stderr,"Part 1"); Add(AGM_B2,AGM_B2,AGM_A2,Len); MulBy(AGM_B2,AGM_B2,2,Len); if (!Cfg.Macintosh) BackSpace(6); if (Cfg.PiFormulaToUse==3) { if (!Cfg.Macintosh) fprintf(stderr,"Part 2"); if (!Cfg.Macintosh) BackSpace(6); Sqrt30(AGM_A2,Len); if (!Cfg.Macintosh) fprintf(stderr,"Part 3"); SpecialFullMul(AGM_A,AGM_Sum,AGM_A2,Len,AGM_B); SubInt(AGM_A, BI_OneHalf); Copy(AGM_Sum,AGM_A,Len); if (!Cfg.Macintosh) BackSpace(6); } AGMDivide(AGM_B, AGM_B2, AGM_Sum, Len, AGM_A2); EndTime=clock(); fprintf(stderr, "Time= %0.2f\n", ((double)EndTime-(double)LoopTime) /CLOCKS_PER_SEC); DumpTimings(((double)EndTime-(double)LoopTime) /CLOCKS_PER_SEC); if (Cfg.PiFormulaToUse==2) PrintFormattedPi("Fast 1/sqrt(2) AGM",((double)EndTime-(double)StartTime) /CLOCKS_PER_SEC, AGM_B, Len); else PrintFormattedPi("Fast sqrt(3) AGM",((double)EndTime-(double)StartTime) /CLOCKS_PER_SEC, AGM_B, Len); DeleteSaveFile(); } else if (Pass >= FatalPasses) FatalError("The AGM didn't converge.\n"); else SaveData(AGM_A,AGM_A2,AGM_B,AGM_B2,AGM_Sum,OldRoot, ((double)clock()-(double)StartTime) /CLOCKS_PER_SEC,Pow2,Pass,Len,Cfg.PiFormulaToUse); fprintf(stderr,"\nTotal Execution time: %0.2f\n\n",((double)clock()-(double)StartTime) /CLOCKS_PER_SEC); if (!Done) DumpTimings(((double)clock()-(double)StartTime) /CLOCKS_PER_SEC); return (Done); }
VOID CALLBACK TimerAPCProc(LPVOID, DWORD, DWORD) { DoCheck(TRUE); }