BOOL PageLiquidAccumModel::UpData()
{
UpdateData(TRUE);
SetNum(m_strElastic,m_strElasticUnit,LiquidAccumulator::ms_Elastic);
SetNum(m_strVolume,m_strVolumeUnit,LiquidAccumulator::ms_InitVolume);
return TRUE;
}
BOOL PageCondition::UpData()
{
UpdateData(TRUE);
Condition::ms_Gravity.SetValue(m_strGravity);
Condition::ms_ReTransLam.SetValue(m_strRetransLam);
Condition::ms_ReTransTurb.SetValue(m_strRetransTurb);
SetNum(m_strAtmosphericPress,m_strPressUnit,Condition::ms_AtmosphericPress);
SetNum(m_strAtmosphericTemp,m_strTemperatureUnit,Condition::ms_AtmosphericTemp);
ASSERT(m_pCondition != NULL);
m_pCondition->SaveData();
return TRUE;
}
/*
** Computes the square root of 'n' by computing the reciprocal and then
** multiplying that by the original number.
** r = r*(3-n*r^2)/2
*/
void
ClassicSqrt(BigInt Root, BigInt Num, size_t Len)
{
size_t SubLen=1;
size_t Redo=REDO_LEN;
{INT32 PreSet;
double Prep;
Prep=GetBigIntDigit(Num,0)/((double)BI_One);
Prep=sqrt(1.0/Prep);
PreSet=Prep*BI_One;
SubLen=1;
SetNum(Root,1,PreSet,0);
ClearBigInt(Root+SubLen,Len-SubLen);
}
while (SubLen < Len)
{
SubLen *= 2;if (SubLen > Len) SubLen = Len;
if (!Cfg.Macintosh)
fprintf(stderr,"Sqrt: %4s",Num2Str(SubLen*RawIntDigits));
FullMul(DSWork, Root, Root, SubLen);
FullMul(DSWork, Num, DSWork, SubLen);
RevSubInt(BI_Three,DSWork,SubLen);
FullMul(Root,Root,DSWork,SubLen);
DivBy(Root, Root, 2, SubLen);
if (SubLen == Redo) {SubLen/=2;Redo=0;}
if (!Cfg.Macintosh) BackSpace(10);
}
if (!Cfg.Macintosh) fprintf(stderr,"Sqrt: Mul");
FullMul(Root,Num,Root,Len);
if (!Cfg.Macintosh) BackSpace(9);
}
/*
** d = a/b by computing the reciprocal of b and then multiplying
** that by a.
**
** r = r*(2-br)
** d = a * r
*/
void
ClassicDivide(BigInt D, BigInt Num, BigInt Denom, size_t Len)
{ size_t SubLen;
size_t Redo=REDO_LEN;
{INT32 PreSet;
double Prep;
Prep=(1.0*BI_One)/GetBigIntDigit(Denom,0);
PreSet=Prep*BI_One;
SubLen=1;
SetNum(D,1,PreSet,0);
ClearBigInt(D+SubLen,Len-SubLen);
}
while (SubLen < Len)
{
SubLen *= 2;if (SubLen > Len) SubLen = Len;
if (!Cfg.Macintosh) fprintf(stderr,"Div: %4s",Num2Str(SubLen*RawIntDigits));
FullMul(DSWork, D, Denom, SubLen);
RevSubInt(BI_Two,DSWork,SubLen);
FullMul(D, D, DSWork, SubLen);
if (SubLen == Redo) {SubLen/=2;Redo=0;}
if (!Cfg.Macintosh) BackSpace(9);
}
if (!Cfg.Macintosh) fprintf(stderr,"Div: Mul");
FullMul(D, Num, D, Len);
if (!Cfg.Macintosh) BackSpace(8);
}
BOOL DlgTolerance::Updata(StrFlyWeight &type,NumFlyWeight &absTol,StrFlyWeight &RelTol)
{
UpdateData(TRUE);
type.SetValue(m_nTolType);
SetNum(m_strAbsTol,m_strAbsTolUnit,absTol);
RelTol.SetValue(m_strRelTol);
return TRUE;
}
static void
InvSqrtInt(BigInt Root, INT32 INum,size_t Len)
/*
** Generic routine to compute the inverse of the square root of
** an integer. If you need the regular form, you can easily
** do a MulBy(x,x,INum,Len); yourself
*/
{
int Sign;
size_t Redo=REDO_LEN;
size_t SubLen=1;
char Check[128];
{double Prep;INT32 PreSet;
/* Yuck. I hate calculating the starting value. */
Prep=sqrt(1.0/INum);
Prep=Prep*10000000; PreSet=Prep;
SetNum(Root,1,PreSet,0);
ClearBigInt(Root+SubLen,Len-SubLen);
sprintf(Check,"%08d",PreSet);
}
Num1IsCached = Num2IsCached = 0;
FlushFFTCache(0);
while (SubLen < Len)
{
SubLen *= 2;if (SubLen > Len) SubLen = Len;
if (!Cfg.Macintosh)
fprintf(stderr,"Sqrt%d: %4s",INum,Num2Str(SubLen*RawIntDigits));
FlushFFTCache(0);
/* Perform safety check */
if (strncmp(GetCheckStr(Root),Check,8)!=0)
fprintf(stderr,"** WARNING **\a\nInvSqrtInt %d may be failing.\n%s vs. %s\n",
INum,Check,GetCheckStr(Root));
ClearBigInt(Root+SubLen/2,SubLen/2);
SaveNum1FFT = 30;
if (!Cfg.Macintosh) fputc('.',stderr);
HalfMul(DSWork, Root, Root, SubLen);
MulBy(DSWork,DSWork,INum,SubLen);
Sign = RevSubInt(BI_One,DSWork,SubLen);
Num1IsCached=30;
if (!Cfg.Macintosh) fputc('.',stderr);
HalfMul(DSWork,Root,DSWork,SubLen);
DivBy(DSWork,DSWork,2,SubLen);
if (Sign) Sub(Root,Root,DSWork,SubLen);
else Add(Root,Root,DSWork,SubLen);
if (Redo == ULONG_MAX) Redo = 0;
if (SubLen == Redo) {SubLen/=2;Redo=ULONG_MAX;}
if (!Cfg.Macintosh) BackSpace(13);
}
FlushFFTCache(0);
}
BOOL PageConfiguration::UpData(Configuration &ref)
{
UpdateData(TRUE);
SetNum(m_strBEP,m_strBEPUnit,ref.m_BEP);
SetTypeNum(m_nFlowType,m_strEndFlow,m_strFlowUnit,ref.m_CurveEndFlow);
ref.m_Affiniity.SetValue(m_strK);
return TRUE;
}
BOOL PageSurgeModel::UpData()
{
UpdateData(TRUE);
SetNum(m_strSurfacePress,m_strSurfacePressUnit,Surge::ms_SurfacePress);
SetNum(m_strEle,m_strEleUnit,Surge::ms_SurgeHeight);
SetNum(m_strConstArea,m_strAreaUnit,Surge::ms_ConstArea);
m_dlgShortPipe.UpData(Surge::ms_ShortPipe);
m_dlgRestrictor.UpData(Surge::ms_Orifice);
Surge::ms_Variable.SetValue(m_nAreaType);
Surge::ms_OneWay.SetValue(m_bModel);
OneWayWrapper wrapper(Surge::ms_CheckValve);
wrapper.SetPostion(m_nPosition);
wrapper.SetCv(m_strCv);
wrapper.SetPress(m_nPressType,m_strOpenPress,m_strOpenPressUnit);
Surge::ms_AreaTable.m_Unit.SetValue(m_strEleUnit);
Surge::ms_AreaTable.m_Unit.SetValue(m_strAreaUnit,1);
m_dlgTable.UpData(Surge::ms_AreaTable);
return TRUE;
}
// --- Methods inherited from Tex3D ---
void Water::ReadSXPData(const TCHAR *name, void *sxpdata) {
WaterState *state = (WaterState*)sxpdata;
if (state != NULL && (state->version == WATER_SXP_VERSION)) {
SetColor(0, ColorFromCol24(state->col1), TimeValue(0));
SetColor(1, ColorFromCol24(state->col2), TimeValue(0));
SetNum(state->count, TimeValue(0));
SetSize(state->size, TimeValue(0));
SetLenMin(state->minperiod, TimeValue(0));
SetLenMax(state->maxperiod, TimeValue(0));
SetAmp(state->amp, TimeValue(0));
SetPhase(0.0f, TimeValue(0), TRUE);
}
}
BOOL DlgTwoEnd::UpData()
{
UpdateData(TRUE);
SetNum(m_strInEle,m_strUnit,Jun::ms_InletEle);
if(m_bSameEle)
{
Jun::ms_OutletEle.SetValue(m_strInEle);
}
else
{
Jun::ms_OutletEle.SetValue(m_strOutEle);
}
Jun::ms_OutletEle.SetUnit(m_strUnit);
return TRUE;
}
BOOL PagePumpModel::UpData()
{
UpdateData(TRUE);
Pump::ms_PumpType.SetValue(m_nType);
SetTypeNum(m_nFlowType,m_strFlowRate,m_strFlowRateUnit,Pump::ms_PumpFlow);
OptionTypeNumWrapper wrapper(Pump::ms_SubmergePump);
wrapper.SetModel(m_bSubmerge);
wrapper.SetPress(m_nSuctionPressType,m_strSuctionPress,m_strSuctionPressUnit);
Pump::ms_antiReverse.SetValue(-int(!m_bAntiReserse));
Pump::ms_ExitCheck.SetValue(m_bCheckValve);
SetNum(m_strVelocity,m_strVelocityUnit,Pump::ms_CloseVel);
SetTypeNum(m_nOpenPressType,m_strOpenPress,m_strOpenPressUnit,Pump::ms_ReOpenPress);
return TRUE;
}
int CVarDefMap::SetStr( LPCTSTR pszName, bool fQuoted, LPCTSTR pszVal, bool fZero )
{
ADDTOCALLSTACK("CVarDefMap::SetStr");
// ASSUME: This has been clipped of unwanted beginning and trailing spaces.
if ( !pszName || !pszName[0] )
return -1;
if ( pszVal == NULL || pszVal[0] == '\0' ) // but not if empty
{
DeleteAtKey(pszName);
return( -1 );
}
if ( !fQuoted && IsSimpleNumberString(pszVal))
{
// Just store the number and not the string.
return SetNum( pszName, Exp_GetLLVal( pszVal ), fZero);
}
CVarDefContTest * pVarSearch = new CVarDefContTest(pszName);
DefSet::iterator iResult = m_Container.find(pVarSearch);
delete pVarSearch;
CVarDefCont * pVarBase = NULL;
if ( iResult != m_Container.end() )
pVarBase = (*iResult);
if ( !pVarBase )
{
return SetStrNew( pszName, pszVal );
}
CVarDefContStr * pVarStr = dynamic_cast <CVarDefContStr *>( pVarBase );
if ( pVarStr )
{
pVarStr->SetValStr( pszVal );
}
else
{
if ( g_Serv.IsLoading())
{
DEBUG_ERR(( "Replace existing VarNum '%s' with %s\n", pVarBase->GetKey(), pszVal ));
}
return SetStrOverride( pszName, pszVal );
}
return static_cast<int>(std::distance(m_Container.begin(), iResult) );
}
// This method is called to reset the texmap back to its default values.
void Water::Init() {
// Reset the XYZGen or allocate a new one
if (xyzGen)
xyzGen->Reset();
else
ReplaceReference(0, GetNewDefaultXYZGen());
// This replaces the reference to the previous parameter block with
// a new one. Note that the previous one is automatically deleted
// because when the last reference to an item is deleted, MAX deletes
// the item itself.
// ReplaceReference(1, CreateParameterBlock(pbdesc,
// PB_LENGTH, WATER_PB_VERSION));
// if (paramDlg)
// paramDlg->pmap->SetParamBlock(pblock);
// Set the inital parameters
SetColor(0, DEFAULT_COLOR1, TimeValue(0));
SetColor(1, DEFAULT_COLOR2, TimeValue(0));
SetRandSeed(0x75cf);
SetNum(DEFAULT_NUM_WAVESETS, TimeValue(0));
RegisterDistanceDefault(_T("Wave Params"), _T("Size"), DEFAULT_WAVE_RADIUS, IN_TO_M(DEFAULT_WAVE_RADIUS));
float size = GetDistanceDefault(_T("Wave Params"), _T("Size"));
SetSize(size, TimeValue(0));
RegisterDistanceDefault(_T("Wave Params"), _T("Len Min"), DEFAULT_WAVE_LEN_MIN, IN_TO_M(DEFAULT_WAVE_LEN_MIN));
float lenMin = GetDistanceDefault(_T("Wave Params"), _T("Len Min"));
SetLenMin(lenMin, TimeValue(0));
RegisterDistanceDefault(_T("Wave Params"), _T("Len Max"), DEFAULT_WAVE_LEN_MAX, IN_TO_M(DEFAULT_WAVE_LEN_MAX));
float lenMax = GetDistanceDefault(_T("Wave Params"), _T("Len Max"));
SetLenMax(lenMax, TimeValue(0));
SetAmp(1.0f, TimeValue(0));
SetPhase(0.0f, TimeValue(0));
ReInit();
type = 0;
// Set the validity interval of the texture to empty
texValidity.SetEmpty();
}
/*
** 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
mexFunction (
INT nlhs,
Matrix * plhs[],
INT nrhs,
const Matrix * prhs[]
)
{
char * opname;
OPCODE opcode;
Matrix * mat;
int status;
char * path;
int cmode;
int mode;
int cdfid;
int ndims;
int nvars;
int natts;
int recdim;
char * name;
long length;
int dimid;
nc_type datatype;
int * dim;
int varid;
long * coords;
VOIDP value;
long * start;
long * count;
int * intcount;
long * stride;
long * imap;
long recnum;
int nrecvars;
int * recvarids;
long * recsizes;
VOIDPP datap; /* pointers for record access. */
int len;
int incdf;
int invar;
int outcdf;
int outvar;
int attnum;
char * attname;
char * newname;
int fillmode;
int i;
int m;
int n;
char * p;
char buffer[MAX_BUFFER];
DOUBLE * pr;
DOUBLE addoffset;
DOUBLE scalefactor;
int autoscale; /* do auto-scaling if this flag is non-zero. */
/* Disable the NC_FATAL option from ncopts. */
if (ncopts & NC_FATAL) {
ncopts -= NC_FATAL;
}
/* Display usage if less than one input argument. */
if (nrhs < 1) {
Usage();
return;
}
/* Convert the operation name to its opcode. */
opname = Mat2Str(prhs[0]);
for (i = 0; i < strlen(opname); i++) {
opname[i] = (char) tolower((int) opname[i]);
}
p = opname;
if (strncmp(p, "nc", 2) == 0) { /* Trim away "nc". */
p += 2;
}
i = 0;
opcode = NONE;
while (ops[i].opcode != NONE) {
if (!strcmp(p, ops[i].opname)) {
opcode = ops[i].opcode;
if (ops[i].nrhs > nrhs) {
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: Too few input arguments.\n");
}
else if (0 && ops[i].nlhs > nlhs) { /* Disabled. */
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: Too few output arguments.\n");
}
break;
}
else {
i++;
}
}
if (opcode == NONE) {
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: No such operation.\n");
}
Free((VOIDPP) & opname);
/* Extract the cdfid by number. */
switch (opcode) {
case USAGE:
case CREATE:
case OPEN:
case TYPELEN:
case SETOPTS:
case ERR:
case PARAMETER:
break;
default:
cdfid = Scalar2Int(prhs[1]);
break;
}
/* Extract the dimid by number or name. */
switch (opcode) {
case DIMINQ:
case DIMRENAME:
if (mxIsNumeric(prhs[2])) {
dimid = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[2]);
dimid = ncdimid(cdfid, name);
Free((VOIDPP) & name);
}
break;
default:
break;
}
/* Extract the varid by number or name. */
switch (opcode) {
case VARINQ:
case VARPUT1:
case VARGET1:
case VARPUT:
case VARGET:
case VARPUTG:
case VARGETG:
case VARRENAME:
case VARCOPY:
case ATTPUT:
case ATTINQ:
case ATTGET:
case ATTCOPY:
case ATTNAME:
case ATTRENAME:
case ATTDEL:
if (mxIsNumeric(prhs[2])) {
varid = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[2]);
varid = ncvarid(cdfid, name);
Free((VOIDPP) & name);
if (varid == -1) {
varid = Parameter(prhs[2]);
}
}
break;
default:
break;
}
/* Extract the attname by name or number. */
switch (opcode) {
case ATTPUT:
case ATTINQ:
case ATTGET:
case ATTCOPY:
case ATTRENAME:
case ATTDEL:
if (mxIsNumeric(prhs[3])) {
attnum = Scalar2Int(prhs[3]);
attname = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncattname(cdfid, varid, attnum, attname);
}
else {
attname = Mat2Str(prhs[3]);
}
break;
default:
break;
}
/* Extract the "add_offset" and "scale_factor" attributes. */
switch (opcode) {
case VARPUT1:
case VARGET1:
case VARPUT:
case VARGET:
case VARPUTG:
case VARGETG:
addoffset = Add_Offset(cdfid, varid);
scalefactor = Scale_Factor(cdfid, varid);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
break;
default:
break;
}
/* Perform the NetCDF operation. */
switch (opcode) {
case USAGE:
Usage();
break;
case CREATE:
path = Mat2Str(prhs[1]);
if (nrhs > 2) {
cmode = Parameter(prhs[2]);
}
else {
cmode = NC_NOCLOBBER; /* Default. */
}
cdfid = nccreate(path, cmode);
plhs[0] = Int2Scalar(cdfid);
plhs[1] = Int2Scalar((cdfid >= 0) ? 0 : -1);
Free((VOIDPP) & path);
break;
case OPEN:
path = Mat2Str(prhs[1]);
if (nrhs > 2) {
mode = Parameter(prhs[2]);
}
else {
mode = NC_NOWRITE; /* Default. */
}
cdfid = ncopen(path, mode);
plhs[0] = Int2Scalar(cdfid);
plhs[1] = Int2Scalar((cdfid >= 0) ? 0 : -1);
Free((VOIDPP) & path);
break;
case REDEF:
status = ncredef(cdfid);
plhs[0] = Int2Scalar(status);
break;
case ENDEF:
status = ncendef(cdfid);
plhs[0] = Int2Scalar(status);
break;
case CLOSE:
status = ncclose(cdfid);
plhs[0] = Int2Scalar(status);
break;
case INQUIRE:
status = ncinquire(cdfid, & ndims, & nvars, & natts, & recdim);
if (nlhs > 1) {
plhs[0] = Int2Scalar(ndims);
plhs[1] = Int2Scalar(nvars);
plhs[2] = Int2Scalar(natts);
plhs[3] = Int2Scalar(recdim);
plhs[4] = Int2Scalar(status);
}
else { /* Default to 1 x 5 row vector. */
plhs[0] = mxCreateFull(1, 5, REAL);
pr = mxGetPr(plhs[0]);
if (status == 0) {
pr[0] = (DOUBLE) ndims;
pr[1] = (DOUBLE) nvars;
pr[2] = (DOUBLE) natts;
pr[3] = (DOUBLE) recdim;
}
pr[4] = (DOUBLE) status;
}
break;
case SYNC:
status = ncsync(cdfid);
plhs[0] = Int2Scalar(status);
break;
case ABORT:
status = ncabort(cdfid);
plhs[0] = Int2Scalar(status);
break;
case DIMDEF:
name = Mat2Str(prhs[2]);
length = Parameter(prhs[3]);
dimid = ncdimdef(cdfid, name, length);
plhs[0] = Int2Scalar(dimid);
plhs[1] = Int2Scalar((dimid >= 0) ? 0 : dimid);
Free((VOIDPP) & name);
break;
case DIMID:
name = Mat2Str(prhs[2]);
dimid = ncdimid(cdfid, name);
plhs[0] = Int2Scalar(dimid);
plhs[1] = Int2Scalar((dimid >= 0) ? 0 : dimid);
Free((VOIDPP) & name);
break;
case DIMINQ:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncdiminq(cdfid, dimid, name, & length);
plhs[0] = Str2Mat(name);
plhs[1] = Long2Scalar(length);
plhs[2] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case DIMRENAME:
name = Mat2Str(prhs[3]);
status = ncdimrename(cdfid, dimid, name);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case VARDEF:
name = Mat2Str(prhs[2]);
datatype = (nc_type) Parameter(prhs[3]);
ndims = Scalar2Int(prhs[4]);
if (ndims == -1) {
ndims = Count(prhs[5]);
}
dim = Mat2Int(prhs[5]);
varid = ncvardef(cdfid, name, datatype, ndims, dim);
Free((VOIDPP) & name);
plhs[0] = Int2Scalar(varid);
plhs[1] = Int2Scalar((varid >= 0) ? 0 : varid);
break;
case VARID:
name = Mat2Str(prhs[2]);
varid = ncvarid(cdfid, name);
Free((VOIDPP) & name);
plhs[0] = Int2Scalar(varid);
plhs[1] = Int2Scalar((varid >= 0) ? 0 : varid);
break;
case VARINQ:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
plhs[0] = Str2Mat(name);
plhs[1] = Int2Scalar(datatype);
plhs[2] = Int2Scalar(ndims);
plhs[3] = Int2Mat(dim, 1, ndims);
plhs[4] = Int2Scalar(natts);
plhs[5] = Int2Scalar(status);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
break;
case VARPUT1:
coords = Mat2Long(prhs[3]);
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[4]);
}
else {
mat = prhs[4];
}
if (mat == NULL) {
mat = prhs[4];
}
pr = mxGetPr(mat);
autoscale = (nrhs > 5 && Scalar2Int(prhs[5]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
status = Convert(opcode, datatype, 1, buffer, scalefactor, addoffset, pr);
status = ncvarput1(cdfid, varid, coords, buffer);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & coords);
break;
case VARGET1:
coords = Mat2Long(prhs[3]);
autoscale = (nrhs > 4 && Scalar2Int(prhs[4]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
mat = Int2Scalar(0);
pr = mxGetPr(mat);
status = ncvarget1(cdfid, varid, coords, buffer);
status = Convert(opcode, datatype, 1, buffer, scalefactor, addoffset, pr);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[0] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & coords);
break;
case VARPUT:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
autoscale = (nrhs > 6 && Scalar2Int(prhs[6]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[5]);
}
else {
mat = prhs[5];
}
if (mat == NULL) {
mat = prhs[5];
}
pr = mxGetPr(mat);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
len = 0;
if (ndims > 0) {
len = 1;
for (i = 0; i < ndims; i++) {
len *= count[i];
}
}
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
status = ncvarput(cdfid, varid, start, count, value);
Free((VOIDPP) & value);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & start);
Free((VOIDPP) & count);
break;
case VARGET:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
intcount = Mat2Int(prhs[4]);
autoscale = (nrhs > 5 && Scalar2Int(prhs[5]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
m = 0;
n = 0;
if (ndims > 0) {
m = count[0];
n = count[0];
for (i = 1; i < ndims; i++) {
n *= count[i];
if (count[i] > 1) {
m = count[i];
}
}
n /= m;
}
len = m * n;
if (ndims < 2) {
m = 1;
n = len;
}
for (i = 0; i < ndims; i++) {
intcount[i] = count[ndims-i-1]; /* Reverse order. */
}
if (MEXCDF_4 || ndims < 2) {
mat = mxCreateFull(m, n, mxREAL); /* mxCreateDoubleMatrix */
}
# if MEXCDF_5
else {
mat = mxCreateNumericArray(ndims, intcount, mxDOUBLE_CLASS, mxREAL);
}
# endif
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncvarget(cdfid, varid, start, count, value);
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
Free((VOIDPP) & value);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
plhs[0] = mat;
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & intcount);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARPUTG:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
if (nrhs > 7) {
if (datatype == NC_CHAR) {
mat = SetStr(prhs[7]);
}
else {
mat = prhs[7];
}
if (mat == NULL) {
mat = prhs[7];
}
}
else {
if (datatype == NC_CHAR) {
mat = SetStr(prhs[6]);
}
else {
mat = prhs[6];
}
if (mat == NULL) {
mat = prhs[6];
}
}
pr = mxGetPr(mat);
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
stride = Mat2Long(prhs[5]);
imap = NULL;
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
len = 0;
if (ndims > 0) {
len = 1;
for (i = 0; i < ndims; i++) {
len *= count[i];
}
}
autoscale = (nrhs > 8 && Scalar2Int(prhs[8]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
status = ncvarputg(cdfid, varid, start, count, stride, imap, value);
Free((VOIDPP) & value);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & stride);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARGETG:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
intcount = Mat2Int(prhs[4]);
stride = Mat2Long(prhs[5]);
imap = NULL;
autoscale = (nrhs > 7 && Scalar2Int(prhs[7]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
m = 0;
n = 0;
if (ndims > 0) {
m = count[0];
n = count[0];
for (i = 1; i < ndims; i++) {
n *= count[i];
if (count[i] > 1) {
m = count[i];
}
}
n /= m;
}
len = m * n;
if (ndims < 2) {
m = 1;
n = len;
}
for (i = 0; i < ndims; i++) {
intcount[i] = count[ndims-i-1]; /* Reverse order. */
}
if (MEXCDF_4 || ndims < 2) {
mat = mxCreateFull(m, n, mxREAL); /* mxCreateDoubleMatrix */
}
# if MEXCDF_5
else {
mat = mxCreateNumericArray(ndims, intcount, mxDOUBLE_CLASS, mxREAL);
}
# endif
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncvargetg(cdfid, varid, start, count, stride, imap, value);
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
Free((VOIDPP) & value);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[0] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & stride);
Free((VOIDPP) & intcount);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARRENAME:
name = Mat2Str(prhs[3]);
status = ncvarrename(cdfid, varid, name);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case VARCOPY:
incdf = cdfid;
invar = varid;
outcdf = Scalar2Int(prhs[3]);
outvar = -1;
/* outvar = ncvarcopy(incdf, invar, outcdf); */
plhs[0] = Int2Scalar(outvar);
plhs[1] = Int2Scalar((outvar >= 0) ? 0 : outvar);
break;
case ATTPUT:
datatype = (nc_type) Parameter(prhs[4]);
datatype = RepairBadDataType(datatype);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[6]);
}
else {
mat = prhs[6];
}
if (mat == NULL) {
mat = prhs[6];
}
len = Scalar2Int(prhs[5]);
if (len == -1) {
len = Count(mat);
}
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, (DOUBLE) 1.0, (DOUBLE) 0.0, pr);
status = ncattput(cdfid, varid, attname, datatype, len, value);
if (value != NULL) {
Free((VOIDPP) & value);
}
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTINQ:
status = ncattinq(cdfid, varid, attname, & datatype, & len);
datatype = RepairBadDataType(datatype);
plhs[0] = Int2Scalar((int) datatype);
plhs[1] = Int2Scalar(len);
plhs[2] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTGET:
status = ncattinq(cdfid, varid, attname, & datatype, & len);
datatype = RepairBadDataType(datatype);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncattget(cdfid, varid, attname, value);
mat = mxCreateDoubleMatrix(1, len, mxREAL);
pr = mxGetPr(mat);
status = Convert(opcode, datatype, len, value, (DOUBLE) 1.0, (DOUBLE) 0.0, pr);
if (value != NULL) {
Free((VOIDPP) & value);
}
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[4] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTCOPY:
incdf = cdfid;
invar = varid;
outcdf = Scalar2Int(prhs[4]);
if (mxIsNumeric(prhs[5])) {
outvar = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[5]);
outvar = ncvarid(cdfid, name);
Free((VOIDPP) & name);
}
status = ncattcopy(incdf, invar, attname, outcdf, outvar);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTNAME:
attnum = Scalar2Int(prhs[3]);
attname = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncattname(cdfid, varid, attnum, attname);
plhs[0] = Str2Mat(attname);
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTRENAME:
newname = Mat2Str(prhs[4]);
status = ncattrename(cdfid, varid, attname, newname);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
Free((VOIDPP) & newname);
break;
case ATTDEL:
status = ncattdel(cdfid, varid, attname);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case RECPUT:
recnum = Scalar2Long(prhs[2]);
pr = mxGetPr(prhs[3]);
autoscale = (nrhs > 4 && Scalar2Int(prhs[4]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
datap = (VOIDPP) mxCalloc(MAX_VAR_DIMS, sizeof(VOIDP));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status == -1) {
plhs[0] = Int2Scalar(status);
break;
}
length = 0;
n = 0;
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length += recsizes[i];
n += (recsizes[i] / nctypelen(datatype));
}
if (Count(prhs[3]) < n) {
status = -1;
plhs[0] = Int2Scalar(status);
break;
}
if ((value = (VOIDP) mxCalloc((int) length, sizeof(char))) == NULL) {
status = -1;
plhs[0] = Int2Scalar(status);
break;
}
length = 0;
p = value;
for (i = 0; i < nrecvars; i++) {
datap[i] = p;
p += recsizes[i];
}
p = (char *) value;
pr = mxGetPr(prhs[3]);
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length = recsizes[i] / nctypelen(datatype);
if (autoscale) {
addoffset = Add_Offset(cdfid, recvarids[i]);
scalefactor = Scale_Factor(cdfid, recvarids[i]);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
}
Convert(opcode, datatype, length, (VOIDP) p, scalefactor, addoffset, pr);
pr += length;
p += recsizes[i];
}
status = ncrecput(cdfid, recnum, datap);
plhs[0] = Int2Scalar(status);
Free ((VOIDPP) & value);
Free ((VOIDPP) & datap);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case RECGET:
recnum = Scalar2Long(prhs[2]);
autoscale = (nrhs > 3 && Scalar2Int(prhs[3]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
datap = (VOIDPP) mxCalloc(MAX_VAR_DIMS, sizeof(VOIDP));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status == -1) {
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
plhs[1] = Int2Scalar(status);
break;
}
if (nrecvars == 0) {
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
plhs[0] = mxCreateFull(0, 0, REAL);
break;
}
length = 0;
n = 0;
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length += recsizes[i];
n += (recsizes[i] / nctypelen(datatype));
}
if ((value = (VOIDP) mxCalloc((int) length, sizeof(char))) == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
if (value == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
length = 0;
p = value;
for (i = 0; i < nrecvars; i++) {
datap[i] = p;
p += recsizes[i];
}
if ((status = ncrecget(cdfid, recnum, datap)) == -1) {
plhs[1] = Int2Scalar(status);
break;
}
m = 1;
plhs[0] = mxCreateFull(m, n, REAL);
if (plhs[0] == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
pr = mxGetPr(plhs[0]);
p = (char *) value;
for (i = 0; i < nrecvars; i++) {
status = ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
if (status == -1) {
plhs[1] = Int2Scalar(status);
break;
}
length = recsizes[i] / nctypelen(datatype);
if (autoscale) {
addoffset = Add_Offset(cdfid, recvarids[i]);
scalefactor = Scale_Factor(cdfid, recvarids[i]);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
}
Convert(opcode, datatype, length, (VOIDP) p, scalefactor, addoffset, pr);
pr += length;
p += recsizes[i];
}
plhs[1] = Int2Scalar(status);
Free ((VOIDPP) & value);
Free ((VOIDPP) & datap);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case RECINQ:
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status != -1) {
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
recsizes[i] /= nctypelen(datatype);
}
m = 1;
n = nrecvars;
plhs[0] = Int2Mat(recvarids, m, n);
plhs[1] = Long2Mat(recsizes, m, n);
}
plhs[2] = Int2Scalar(status);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case TYPELEN:
datatype = (nc_type) Parameter(prhs[1]);
len = nctypelen(datatype);
plhs[0] = Int2Scalar(len);
plhs[1] = Int2Scalar((len >= 0) ? 0 : 1);
break;
case SETFILL:
fillmode = Scalar2Int(prhs[1]);
status = ncsetfill(cdfid, fillmode);
plhs[0] = Int2Scalar(status);
plhs[1] = Int2Scalar(0);
break;
case SETOPTS:
plhs[0] = Int2Scalar(ncopts);
plhs[1] = Int2Scalar(0);
ncopts = Scalar2Int(prhs[1]);
break;
case ERR:
plhs[0] = Int2Scalar(ncerr);
ncerr = 0;
plhs[1] = Int2Scalar(0);
break;
case PARAMETER:
if (nrhs > 1) {
plhs[0] = Int2Scalar(Parameter(prhs[1]));
plhs[1] = Int2Scalar(0);
}
else {
i = 0;
while (strcmp(parms[i].name, "NONE") != 0) {
mexPrintf("%12d %s\n", parms[i].code, parms[i].name);
i++;
}
plhs[0] = Int2Scalar(0);
plhs[1] = Int2Scalar(-1);
}
break;
default:
break;
}
return;
}
void CEntrez2_id_list::Resize(size_t size)
{
SetUids().resize(sm_UidSize * size);
SetNum(size);
}
void CMSPeakList::CreateLists(int Size)
{
SetSorted() = eMSPeakListSortNone;
SetNum() = Size;
SetMZI(new CMZI[Size]);
}
/*
** d = a/b by computing the reciprocal of b and then multiplying
** that by a.
*/
void
AGMDivide(BigInt R, BigInt Num1, BigInt Num2, size_t Len, BigInt Work)
{ int Sign;
size_t SubLen=2;
size_t Redo=REDO_LEN;
if (NumIs(Num2, 9138931,62088927)) SetNum(R,Len,10942198, 7613238);
else if (NumIs(Num2,12300397,35639667)) SetNum(R,Len, 8129818,66378456);
else
{
DumpBigInt("Unknown Divisor: ",Num2,4);
ExitPrg(EXIT_FAILURE);
}
if (SubLen >= Redo) Redo=0;
Num1IsCached = Num2IsCached = 0;
FlushFFTCache(0);
while (SubLen < Len/2)
{
SubLen *= 2;if (SubLen > Len) SubLen = Len;
if (!Cfg.Macintosh)
fprintf(stderr,"Recip: %4s",Num2Str(SubLen*RawIntDigits));
FlushFFTCache(0);
/* Perform safety check */
if ( (strcmp(GetCheckStr(R),"1094219807613238")!=0) &&
(strcmp(GetCheckStr(R),"0812981866378456")!=0) )
fprintf(stderr,"** WARNING **\a\nAGMDivide may be failing.\n%s\n",GetCheckStr(R));
SaveNum1FFT = 10;
if (SubLen==Len/2) SaveNum2FFT=11;
ClearBigInt(R+SubLen/2,SubLen/2);
if (!Cfg.Macintosh) fputc('|',stderr);
N1R0Mul(DSWork, R, Num2, Work,SubLen);
Sign = RevSubInt(BI_One,DSWork,SubLen);
Num1IsCached=10;
if (!Cfg.Macintosh) fputc('.',stderr);
HalfMul(DSWork,R,DSWork,SubLen);
if (Sign) Sub(R,R,DSWork,SubLen);
else Add(R,R,DSWork,SubLen);
if (Redo == ULONG_MAX) Redo=0;
if (SubLen == Redo) {SubLen/=2;Redo=ULONG_MAX;}
if (!Cfg.Macintosh) BackSpace(13);
}
if (!Cfg.Macintosh) fprintf(stderr,"Recip: %4s",Num2Str(Len*RawIntDigits));
FlushFFTCache(11);
ClearBigInt(R+Len/2,Len/2);
SaveNum1FFT = 10;
if (!Cfg.Macintosh) fputc('.',stderr);
HalfMul(OldRoot,R,Num1,Len);
ClearBigInt(OldRoot+Len/2,Len/2);
Num2IsCached=11;
if (!Cfg.Macintosh) fputc('|',stderr);
N1R0Mul(DSWork,OldRoot,Num2,Work,Len);
Sign=Sub(DSWork,Num1,DSWork,Len);
if (Sign) Negate(DSWork,Len);
Num1IsCached=10;
if (!Cfg.Macintosh) fputc('.',stderr);
HalfMul(DSWork,R,DSWork,Len);
if (Sign) Sub(R,OldRoot,DSWork,Len);
else Add(R,OldRoot,DSWork,Len);
if (!Cfg.Macintosh) BackSpace(14);
Num1IsCached = Num2IsCached = 0;
FlushFFTCache(0);
}
/*
** Computes the square root of 'n' by computing its reciprocal square
** root using the Newton's method, and then multiplying by the original
** number. This is faster than doing the normal Newton 'divide & average'
** method.
*/
/* static */ void
AGMSqrt(BigInt Root, BigInt Num, size_t Len, size_t SubLen)
{
int Sign;
size_t Redo=REDO_LEN;
if (SubLen <= 0) SubLen = 2;
if (SubLen > Len) SubLen = Len;
if (NumIs(Num, 7071067,81186547)) SetNum(OldRoot,2,11892071,15002721);
else if (NumIs(Num, 7177499,86377537)) SetNum(OldRoot,2,11803570,64195417);
else if (NumIs(Num, 7177700,10976296)) SetNum(OldRoot,2,11803405,99073515);
else if (NumIs(Num, 7177700,11046129)) SetNum(OldRoot,2,11803405,99016096);
/* The second AGM */
else if (NumIs(Num, 9659258,26289068)) SetNum(OldRoot,2,10174852,23681446);
else if (NumIs(Num, 9660709,46551927)) SetNum(OldRoot,2,10174087,99031044);
else if (NumIs(Num, 9660709,49277277)) SetNum(OldRoot,2,10174087,97595956);
else
{
DumpBigInt("Unknown Sqrt: ",Num,4);
ExitPrg(EXIT_FAILURE);
}
ClearBigInt(OldRoot+SubLen,Len-SubLen);
if (SubLen >= Redo) Redo=0;
Num1IsCached = Num2IsCached = 0;
FlushFFTCache(0);
while (SubLen < Len/2)
{
SubLen *= 2;if (SubLen > Len) SubLen = Len;
if (!Cfg.Macintosh)
fprintf(stderr,"Sqrt: %4s",Num2Str(SubLen*RawIntDigits));
FlushFFTCache(0);
/* Perform safety check */
{char *Str=GetCheckStr(OldRoot);
if ( (strcmp(Str,"1189207115002721")!=0) &&
(strcmp(Str,"1180357064195417")!=0) &&
(strcmp(Str,"1180340599073515")!=0) &&
(strcmp(Str,"1180340599016096")!=0) &&
(strcmp(Str,"1017485223681446")!=0) &&
(strcmp(Str,"1017408799031044")!=0) &&
(strcmp(Str,"1017408797595956")!=0)
)
fprintf(stderr,"** WARNING **\a\nAGMSqrt may be failing.\n%s\n",Str);
}
ClearBigInt(OldRoot+SubLen/2,SubLen/2);
if (!Cfg.Macintosh) fputc('.',stderr);
SaveNum1FFT = 20;
HalfMul(DSWork, OldRoot, OldRoot, SubLen);
if (SubLen == Len/2) SaveNum1FFT = 21;
if (!Cfg.Macintosh) fputc('|',stderr);
FullMul(DSWork, Num, DSWork, SubLen);
Sign = RevSubInt(BI_One,DSWork,SubLen);
Num1IsCached=20;
if (!Cfg.Macintosh) fputc('.',stderr);
HalfMul2(DSWork,OldRoot,DSWork,SubLen);
if (Sign) Sub(OldRoot,OldRoot,DSWork,SubLen);
else Add(OldRoot,OldRoot,DSWork,SubLen);
if (Redo == ULONG_MAX) Redo = 0;
if (SubLen == Redo) {SubLen/=2;Redo=ULONG_MAX;}
if (!Cfg.Macintosh) BackSpace(13);
}
if (!Cfg.Macintosh) fprintf(stderr,"Sqrt: %4s",Num2Str(Len*RawIntDigits));
FlushFFTCache(21);
if (!Cfg.Macintosh) fputc('.',stderr);
SaveNum2FFT=20;
Num1IsCached=21;
HalfMul(Root, Num, OldRoot, Len);
ClearBigInt(Root+Len/2,Len/2);
if (!Cfg.Macintosh) fputc('.',stderr);
HalfMul(DSWork, Root, Root, Len);
Sign=Sub(DSWork, Num, DSWork, Len);
if (Sign) Negate(DSWork,Len);
Num1IsCached = 20;
if (!Cfg.Macintosh) fputc('.',stderr);
HalfMul2(DSWork,OldRoot,DSWork,Len);
if (Sign) Sub(Root, Root, DSWork, Len);
else Add(Root, Root, DSWork, Len);
if (!Cfg.Macintosh) BackSpace(13);
Num1IsCached = Num2IsCached = 0;
FlushFFTCache(0);
}
static int
ComputeClassicAGM(size_t Len, size_t MaxPasses)
{
int Sign;
size_t Pass;
double Pow2;
clock_t LoopTime,EndTime,StartTime;
BigInt AGM_A, AGM_B, AGM_C, AGMWork;
int Done; /* boolean */
AGM_A = CreateBigInt(Len);
AGM_B = CreateBigInt(Len);
AGM_C = CreateBigInt(Len);
AGMWork = OldRoot;
StartTime = clock();
Pow2 = 4.0;
Pass = 0;
if (!LoadData(AGM_A,AGM_B,AGM_C,NO_NUM,NO_NUM,NO_NUM,
&StartTime,&Pow2,&Pass,Len,Cfg.PiFormulaToUse))
{
fprintf(stderr, "Init : ");
LoopTime = clock();
SetNum(AGM_A,Len,BI_One,0);
SetNum(AGM_C,Len,BI_OneHalf,0);
ClassicSqrt(AGM_B,AGM_C,Len);
SetNum(AGM_C,Len,BI_One,0);
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_B,AGM_C,NO_NUM,NO_NUM,NO_NUM,
((double)EndTime-(double)StartTime)
/CLOCKS_PER_SEC,Pow2,Pass,Len,Cfg.PiFormulaToUse);
}
/*
DumpBigInt("AGM_A",AGM_A,Len);
DumpBigInt("AGM_B",AGM_B,Len);
DumpBigInt("AGM_C",AGM_C,Len);
*/
Done=0;
MaxPasses+=Pass;
while ((!Done) && (Pass < MaxPasses))
{
fprintf(stderr, "Pass %4s: ", Num2Str(1<<(++Pass)));
LoopTime = clock();
if (!Cfg.Macintosh) fprintf(stderr,"AGM Part1");
/* w = (a-b)/2 */
Sign = Sub(AGMWork, AGM_A, AGM_B, Len);
if (Sign) Negate(AGMWork,Len);
DivBy(AGMWork,AGMWork, 2, Len);
if (!Cfg.Macintosh) BackSpace(9);
/* m = w*w */
if (!Cfg.Macintosh) fprintf(stderr,"Sqr1");
if (IsZero(AGMWork,Len/2)) Done=1;
if (Done) ClearBigInt(AGMWork,Len);
else FullMul(AGMWork, AGMWork, AGMWork, Len);
if (!Cfg.Macintosh) BackSpace(4);
if (!Cfg.Macintosh) fprintf(stderr,"AGM Part2");
/* m = m* w^(J+1) */
MulByFloat(AGMWork,Pow2,Len);
Pow2 *= 2.0;
/* c = c - m */
if (Sign) Add(AGM_C, AGM_C, AGMWork, Len);
else Sub(AGM_C, AGM_C, AGMWork, Len);
/* See if it's done */
if (IsZero(AGMWork,Len-(Len/16))) Done=1;
if (!Cfg.Macintosh) BackSpace(9);
/* m = a*b */
if (!Cfg.Macintosh) fprintf(stderr,"Sqr2");
if (Pass==1) Copy(AGMWork,AGM_B,Len); /* first pass, AGM_A = 1.0 */
else if (!Done) /* If last iter, we can skip it. */
FullMul(AGMWork, AGM_A, AGM_B, Len);
/* a = (a+b)/2 */
Add(AGM_A, AGM_A, AGM_B, Len);
DivBy(AGM_A,AGM_A, 2, Len);
if (!Cfg.Macintosh) BackSpace(4);
/* b = sqrt(a*b) */
if (!Done) /* Optimization */
ClassicSqrt(AGM_B, AGMWork, Len);
EndTime=clock();
/*
DumpBigInt("AGM_A",AGM_A,Len);
DumpBigInt("AGM_B",AGM_B,Len);
DumpBigInt("AGM_C",AGM_C,Len);
*/
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 (TestKeyboard()) break;
if (Cfg.AlwaysSaveData)
SaveData(AGM_A,AGM_B,AGM_C,NO_NUM,NO_NUM,NO_NUM,
((double)EndTime-(double)StartTime)
/CLOCKS_PER_SEC,Pow2,Pass,Len,Cfg.PiFormulaToUse);
}
LoopTime=clock();
if (Done)
{
fprintf(stderr,"Final : ");
if (!Cfg.Macintosh) fprintf(stderr,"Sqr");
FullMul(AGM_A, AGM_A, AGM_A, Len);
MulBy(AGM_A,AGM_A,4,Len);
if (!Cfg.Macintosh) BackSpace(3);
ClassicDivide(AGM_B, AGM_A, AGM_C,Len);
EndTime=clock();
fprintf(stderr, "Time= %0.2f\n", ((double)EndTime-(double)LoopTime)
/CLOCKS_PER_SEC);
DumpTimings(((double)EndTime-(double)LoopTime)
/CLOCKS_PER_SEC);
PrintFormattedPi("Classic 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_B,AGM_C,NO_NUM,NO_NUM,NO_NUM,
((double)clock()-(double)StartTime)
/CLOCKS_PER_SEC,Pow2,Pass,Len,Cfg.PiFormulaToUse);
fprintf(stderr,"\nTotal Execution time: %0.2f seconds.\n\n",((double)clock()-(double)StartTime)
/CLOCKS_PER_SEC);
if (!Done) DumpTimings(((double)clock()-(double)StartTime)
/CLOCKS_PER_SEC);
return (Done);
}
/*
*****************************************************
** The AGM itself **
** **
** 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 **
** **
** n **
** PI[n] = 4A[n+1]^2 / (1-(Sum (2^(j+1))*C[j]^2)) **
** j = 1 **
*****************************************************
*/
static int
ComputeSlowAGM(size_t Len, size_t MaxPasses)
{
int Sign;
size_t Pass;
double Pow2;
clock_t LoopTime,StartTime,EndTime;
BigInt AGM_A, AGM_B, AGM_C, AGMWork;
int Done; /* boolean */
if ((Cfg.PiFormulaToUse != 2) && (Cfg.PiFormulaToUse != 3))
FatalError("SlowAGM was somehow called with pi formula %d\n",
Cfg.PiFormulaToUse);
AGM_A = CreateBigInt(Len);
AGM_B = CreateBigInt(Len);
AGM_C = CreateBigInt(Len);
AGMWork = CreateBigInt(Len);
Num1IsCached = Num2IsCached = 0;
StartTime = clock();
Pow2 = 4.0;
Pass = 0;
if (!LoadData(AGM_A,AGM_B,AGM_C,OldRoot,NO_NUM,NO_NUM,
&StartTime,&Pow2,&Pass,Len,Cfg.PiFormulaToUse))
{
LoopTime = clock();
fprintf(stderr, "Init : ");
if (Cfg.PiFormulaToUse==2)
{
SetNum(AGM_A,Len,BI_One,0);
SetNum(AGM_C,Len,BI_One,0);
ClearBigInt(OldRoot,Len);
Sqrt05(AGM_B,Len);
}
else
{
Sqrt20(AGM_A,Len);
Sqrt60(AGM_C,Len);
if (!Cfg.Macintosh) fprintf(stderr,"Square");
Add(AGM_B,AGM_A,AGM_C,Len);
DivBy(AGM_B,AGM_B,4,Len);
if (!Cfg.Macintosh) BackSpace(6);
if (!Cfg.Macintosh) fprintf(stderr,"Setting vars");
ClearBigInt(OldRoot,Len);
SetNum(AGM_A,Len,BI_One,0);
SetNum(AGM_C,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_B,AGM_C,OldRoot,NO_NUM,NO_NUM,
((double)EndTime-(double)StartTime)
/CLOCKS_PER_SEC,Pow2,Pass,Len,Cfg.PiFormulaToUse);
}
/*
DumpBigInt("AGM_A",AGM_A,Len);
DumpBigInt("AGM_B",AGM_B,Len);
DumpBigInt("AGM_C",AGM_C,Len);
*/
Done=0;
MaxPasses+=Pass;
while ((!Done) && (Pass < MaxPasses))
{
fprintf(stderr, "Pass %4s: ", Num2Str(1<<(++Pass)));
LoopTime = clock();
if (!Cfg.Macintosh) fprintf(stderr,"AGM Part1");
/* w = (a-b)/2 */
Sign = Sub(AGMWork, AGM_A, AGM_B, Len);
if (Sign) Negate(AGMWork,Len);
DivBy(AGMWork,AGMWork, 2, Len);
{size_t Nz;
Nz=FindFirstNonZero(AGMWork,Len);
if ((Pass > 4) && (Nz != Len))
if ((1<<(Pass-4)) > Nz)
fprintf(stderr,"AGMCheck1 fails. Predicted: %lu Actual: %lu\a\n",
(unsigned long)1<<(Pass-4),(ULINT)Nz);
}
if (!Cfg.Macintosh) BackSpace(9);
/* m = w*w */
if (!Cfg.Macintosh) fprintf(stderr,"Sqr1");
if (IsZero(AGMWork,Len/2)) Done=1;
if (Done) ClearBigInt(AGMWork,Len);
else FullMul(AGMWork, AGMWork, AGMWork, Len);
if (!Cfg.Macintosh) BackSpace(4);
if (!Cfg.Macintosh) fprintf(stderr,"AGM Part2");
{size_t Nz;
Nz=FindFirstNonZero(AGMWork,Len);
if ((Pass > 3) && (Nz != Len))
if ((1<<(Pass-3)) > Nz)
fprintf(stderr,"AGMCheck2 fails. Predicted: %lu Actual: %lu\a\n",
(unsigned long)1<<(Pass-3),(ULINT)Nz);
}
/* m = m* w^(J+1) */
MulByFloat(AGMWork,Pow2,Len);
Pow2 *= 2.0;
/* c = c - m */
if (Sign) Add(AGM_C, AGM_C, AGMWork, Len);
else Sub(AGM_C, AGM_C, AGMWork, Len);
/* See if it's done */
if (IsZero(AGMWork,Len-(Len/16))) Done=1;
if (!Cfg.Macintosh) BackSpace(9);
/* m = a*b */
if (!Cfg.Macintosh) fprintf(stderr,"Sqr2");
if (Pass==1) Copy(AGMWork,AGM_B,Len); /* first pass, AGM_A = 1.0 */
else if (!Done) /* If last iter, we can skip it. */
FullMul(AGMWork, AGM_A, AGM_B, Len);
if (!Cfg.Macintosh) BackSpace(4);
/* a = (a+b)/2 */
Add(AGM_A, AGM_A, AGM_B, Len);
DivBy(AGM_A,AGM_A, 2, Len);
/* b = sqrt(a*b) */
if (!Done) /* Optimization */
AGMSqrt(AGM_B, AGMWork, Len, (Pass>5) ? (2<<(Pass-5)) : 0 );
EndTime=clock();
/*
DumpBigInt("AGM_A",AGM_A,Len);
DumpBigInt("AGM_B",AGM_B,Len);
DumpBigInt("AGM_C",AGM_C,Len);
*/
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 (TestKeyboard()) break;
if (Cfg.AlwaysSaveData)
SaveData(AGM_A,AGM_B,AGM_C,OldRoot,NO_NUM,NO_NUM,
((double)EndTime-(double)StartTime)
/CLOCKS_PER_SEC,Pow2,Pass,Len,Cfg.PiFormulaToUse);
}
LoopTime=clock();
if (Done)
{
fprintf(stderr,"Final : ");
if (!Cfg.Macintosh) fprintf(stderr,"Sqr");
SpecialSquare(AGM_A, AGM_A, Len, AGMWork);
MulBy(AGM_A,AGM_A,4,Len);
if (!Cfg.Macintosh) BackSpace(3);
if (Cfg.PiFormulaToUse==3)
{
Sqrt30(AGM_B,Len);
if (!Cfg.Macintosh) fprintf(stderr,"Part 2");
FullMul(AGM_C,AGM_C,AGM_B,Len);
SubInt(AGM_C, BI_OneHalf);
if (!Cfg.Macintosh) BackSpace(6);
}
AGMDivide(AGM_B, AGM_A, AGM_C, Len, AGMWork);
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("Slow 1/sqrt(2) AGM",((double)EndTime-(double)StartTime)
/CLOCKS_PER_SEC, AGM_B, Len);
else
PrintFormattedPi("Slow 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_B,AGM_C,OldRoot,NO_NUM,NO_NUM,
((double)clock()-(double)StartTime)
/CLOCKS_PER_SEC,Pow2,Pass,Len,Cfg.PiFormulaToUse);
fprintf(stderr,"\nTotal Execution time: %0.2f seconds.\n\n",((double)clock()-(double)LoopTime)
/CLOCKS_PER_SEC);
if (!Done) DumpTimings(((double)clock()-(double)LoopTime)
/CLOCKS_PER_SEC);
return (Done);
}
void FindNextSmallerPalindrome(int num[],int n) {
int i;
if(IsAll9(num,n)) {
printf("1");
for(i=1; i<n; i++) {
printf("0");
}
printf("1");
return ;
}
int j;
if(n&1) {
i=(n/2)-1;
j=(n/2)+1;
//printf("\nHere : i :%d , j : %d",i,j);
while( (num[i]==num[j]) && i>=0) {
i--;
j++;
}
if(i<0) {
SetNum(num,n);
/*
int k;
for(k=0;k<n;k++){
printf("%d ",num[k]);
}
*/
} else {
if(num[i]<num[j]) {
SetNum(num,n);
} else {
while(i>=0) {
num[j]=num[i];
i--;
j++;
}
}
}
} else {
i=(n/2)-1;
j=(n/2);
//printf("\nHere : i :%d , j : %d",i,j);
while( (num[i]==num[j]) && i>=0) {
i--;
j++;
}
if(i<0) {
SetNum(num,n);
/*
int k;
for(k=0;k<n;k++){
printf("%d ",num[k]);
}
*/
} else {
if(num[i]<num[j]) {
SetNum(num,n);
} else {
while(i>=0) {
num[j]=num[i];
i--;
j++;
}
}
}
}
PrintPalindrome(num,n);
}
RomanNumeralBuilder::RomanNumeralBuilder(long i)
{
SetNum(i);
}