public BigNumber Rez(int places)
{
BigNumber res = 0;
BigNumber.Reziprocal(this, res, places);
return(res);
}
public BigNumber Rez()
{
BigNumber res = 0;
BigNumber.Reziprocal(this, res, numDefaultPlaces);
return(res);
}
static void CheckLogPlaces(int places)
{
BigNumber tmp6, tmp7, tmp8, tmp9;
int dplaces;
dplaces = places + 4;
if (dplaces > MM_lc_log_digits)
{
MM_lc_log_digits = dplaces + 4;
tmp6 = new BigNumber();
tmp7 = new BigNumber();
tmp8 = new BigNumber();
tmp9 = new BigNumber();
dplaces += 6 + (int)Math.Log10((double)places);
BigNumber.Copy(BigNumber.One, tmp7);
tmp7.exponent = -places;
BigNumber.LogAGMRFunc(BigNumber.One, tmp7, tmp8, dplaces);
BigNumber.Mul(tmp7, BigNumber.BN_OneHalf, tmp6);
BigNumber.LogAGMRFunc(BigNumber.One, tmp6, tmp9, dplaces);
BigNumber.Sub(tmp9, tmp8, BN_lc_log2);
tmp7.exponent -= 1;
BigNumber.LogAGMRFunc(BigNumber.One, tmp7, tmp9, dplaces);
BigNumber.Sub(tmp9, tmp8, BN_lc_log10);
BigNumber.Reziprocal(BN_lc_log10R, BN_lc_log10, dplaces);
}
}
static private void IntPow(int places, BigNumber src, int mexp, BigNumber dst)
{
BigNumber A, B, C;
int nexp, ii, signflag, local_precision;
if (mexp == 0)
{
BigNumber.Copy(BigNumber.One, dst);
return;
}
else
{
if (mexp > 0)
{
signflag = 0;
nexp = mexp;
}
else
{
signflag = 1;
nexp = -mexp;
}
}
if (src.signum == 0)
{
BigNumber.SetZero(dst);
return;
}
A = new BigNumber();
B = new BigNumber();
C = new BigNumber();
local_precision = places + 8;
BigNumber.Copy(BigNumber.One, B);
BigNumber.Copy(src, C);
while (true)
{
ii = nexp & 1;
nexp = nexp >> 1;
if (ii != 0) /* exponent -was- odd */
{
BigNumber.Mul(B, C, A);
BigNumber.Round(A, B, local_precision);
if (nexp == 0)
{
break;
}
}
BigNumber.Mul(C, C, A);
BigNumber.Round(A, C, local_precision);
}
if (signflag > 0)
{
BigNumber.Reziprocal(B, dst, places);
}
else
{
BigNumber.Round(B, dst, places);
}
}
/****************************************************************************/
/*
* define a notation for a function 'R' :
*
*
*
* 1
* R (a0, b0) = ------------------------------
*
* ----
* \
* \ n-1 2 2
* 1 - | 2 * (a - b )
* / n n
* /
* ----
* n >= 0
*
*
* where a, b are the classic AGM iteration :
*
*
* a = 0.5 * (a + b )
* n+1 n n
*
*
* b = sqrt(a * b )
* n+1 n n
*
*
*
* define a variable 'c' for more efficient computation :
*
* 2 2 2
* c = 0.5 * (a - b ) , c = a - b
* n+1 n n n n n
*
*/
/****************************************************************************/
static void LogAGMRFunc(BigNumber aa, BigNumber bb, BigNumber rr, int places)
{
BigNumber tmp1, tmp2, tmp3, tmp4, tmpC2, sum, pow_2, tmpA0, tmpB0;
int tolerance, dplaces;
tmpA0 = new BigNumber();
tmpB0 = new BigNumber();
tmpC2 = new BigNumber();
tmp1 = new BigNumber();
tmp2 = new BigNumber();
tmp3 = new BigNumber();
tmp4 = new BigNumber();
sum = new BigNumber();
pow_2 = new BigNumber();
tolerance = places + 8;
dplaces = places + 16;
BigNumber.Copy(aa, tmpA0);
BigNumber.Copy(bb, tmpB0);
BigNumber.Copy(BigNumber.BN_OneHalf, pow_2);
BigNumber.Mul(aa, aa, tmp1); /* 0.5 * [ a ^ 2 - b ^ 2 ] */
BigNumber.Mul(bb, bb, tmp2);
BigNumber.Sub(tmp1, tmp2, tmp3);
BigNumber.Mul(BigNumber.BN_OneHalf, tmp3, sum);
while (true)
{
BigNumber.Sub(tmpA0, tmpB0, tmp1); /* C n+1 = 0.5 * [ An - Bn ] */
BigNumber.Mul(BigNumber.BN_OneHalf, tmp1, tmp4); /* C n+1 */
BigNumber.Mul(tmp4, tmp4, tmpC2); /* C n+1 ^ 2 */
/* do the AGM */
BigNumber.Add(tmpA0, tmpB0, tmp1);
BigNumber.Mul(BigNumber.BN_OneHalf, tmp1, tmp3);
BigNumber.Mul(tmpA0, tmpB0, tmp2);
BigNumber.Sqrt(tmp2, tmpB0, dplaces);
BigNumber.Round(tmp3, tmpA0, dplaces);
/* end AGM */
BigNumber.Mul(BigNumber.Two, pow_2, tmp2);
BigNumber.Copy(tmp2, pow_2);
BigNumber.Mul(tmpC2, pow_2, tmp1);
BigNumber.Add(sum, tmp1, tmp3);
if ((tmp1.signum == 0) || ((-2 * tmp1.exponent) > tolerance))
{
break;
}
BigNumber.Round(tmp3, sum, dplaces);
}
BigNumber.Sub(BigNumber.One, tmp3, tmp4);
BigNumber.Reziprocal(tmp4, rr, places);
}
