private static BigFloat R(BigFloat a0, BigFloat b0)
{
//Precision extend taken out.
int bits = a0.mantissa.Precision.NumBits;
PrecisionSpec extendedPres = new PrecisionSpec(bits, PrecisionSpec.BaseType.BIN);
BigFloat an = new BigFloat(a0, extendedPres);
BigFloat bn = new BigFloat(b0, extendedPres);
BigFloat sum = new BigFloat(extendedPres);
BigFloat term = new BigFloat(extendedPres);
BigFloat temp1 = new BigFloat(extendedPres);
BigFloat one = new BigFloat(1, extendedPres);
int iteration = 0;
for (iteration = 0; ; iteration++)
{
//Get the sum term for this iteration.
term.Assign(an);
term.Mul(an);
temp1.Assign(bn);
temp1.Mul(bn);
//term = an^2 - bn^2
term.Sub(temp1);
//term = 2^(n-1) * (an^2 - bn^2)
term.exponent += iteration - 1;
sum.Add(term);
if (term.exponent < -(bits - 8)) break;
//Calculate the new AGM estimates.
temp1.Assign(an);
an.Add(bn);
//a(n+1) = (an + bn) / 2
an.MulPow2(-1);
//b(n+1) = sqrt(an*bn)
bn.Mul(temp1);
bn.Sqrt();
}
one.Sub(sum);
one = one.Reciprocal();
return new BigFloat(one, a0.mantissa.Precision);
}
/// <summary>
/// Uses the Gauss-Legendre formula for pi
/// Taken from http://en.wikipedia.org/wiki/Gauss%E2%80%93Legendre_algorithm
/// </summary>
/// <param name="numBits"></param>
private static void CalculatePi(int numBits)
{
int bits = numBits + 32;
//Precision extend taken out.
PrecisionSpec normalPres = new PrecisionSpec(numBits, PrecisionSpec.BaseType.BIN);
PrecisionSpec extendedPres = new PrecisionSpec(bits, PrecisionSpec.BaseType.BIN);
if (scratch.Precision.NumBits != bits)
{
scratch = new BigInt(extendedPres);
}
//a0 = 1
BigFloat an = new BigFloat(1, extendedPres);
//b0 = 1/sqrt(2)
BigFloat bn = new BigFloat(2, extendedPres);
bn.Sqrt();
bn.exponent--;
//to = 1/4
BigFloat tn = new BigFloat(1, extendedPres);
tn.exponent -= 2;
int pn = 0;
BigFloat anTemp = new BigFloat(extendedPres);
int iteration = 0;
int cutoffBits = numBits >> 5;
for (iteration = 0; ; iteration++)
{
//Save a(n)
anTemp.Assign(an);
//Calculate new an
an.Add(bn);
an.exponent--;
//Calculate new bn
bn.Mul(anTemp);
bn.Sqrt();
//Calculate new tn
anTemp.Sub(an);
anTemp.mantissa.SquareHiFast(scratch);
anTemp.exponent += anTemp.exponent + pn + 1 - anTemp.mantissa.Normalise();
tn.Sub(anTemp);
anTemp.Assign(an);
anTemp.Sub(bn);
if (anTemp.exponent < -(bits - cutoffBits)) break;
//New pn
pn++;
}
an.Add(bn);
an.mantissa.SquareHiFast(scratch);
an.exponent += an.exponent + 1 - an.mantissa.Normalise();
tn.exponent += 2;
an.Div(tn);
pi = new BigFloat(an, normalPres);
piBy2 = new BigFloat(pi);
piBy2.exponent--;
twoPi = new BigFloat(pi, normalPres);
twoPi.exponent++;
piRecip = new BigFloat(an.Reciprocal(), normalPres);
twoPiRecip = new BigFloat(piRecip);
twoPiRecip.exponent--;
//1/3 is going to be useful for sin.
threeRecip = new BigFloat((new BigFloat(3, extendedPres)).Reciprocal(), normalPres);
}
/// <summary>
/// Tried the newton method for logs, but the exponential function is too slow to do it.
/// </summary>
private void LogNewton()
{
if (mantissa.IsZero() || mantissa.Sign)
{
return;
}
//Compute ln2.
if (ln2cache == null || mantissa.Precision.NumBits > ln2cache.mantissa.Precision.NumBits)
{
CalculateLog2(mantissa.Precision.NumBits);
}
int numBits = mantissa.Precision.NumBits;
//Use inverse exp function with Newton's method.
BigFloat xn = new BigFloat(this);
BigFloat oldExponent = new BigFloat(xn.exponent, mantissa.Precision);
xn.exponent = 0;
this.exponent = 0;
//Hack to subtract 1
xn.mantissa.ClearBit(numBits - 1);
//x0 = (x - 1) * log2 - this is a straight line fit between log(1) = 0 and log(2) = ln2
xn.Mul(ln2cache);
//x0 = (x - 1) * log2 + C - this corrects for minimum error over the range.
xn.Add(logNewtonConstant);
BigFloat term = new BigFloat(mantissa.Precision);
BigFloat one = new BigFloat(1, mantissa.Precision);
int precision = 32;
int normalPrecision = mantissa.Precision.NumBits;
int iterations = 0;
while (true)
{
term.Assign(xn);
term.mantissa.Sign = true;
term.Exp(precision);
term.Mul(this);
term.Sub(one);
iterations++;
if (term.exponent < -((precision >> 1) - 4))
{
if (precision == normalPrecision)
{
if (term.exponent < -(precision - 4)) break;
}
else
{
precision = precision << 1;
if (precision > normalPrecision) precision = normalPrecision;
}
}
xn.Add(term);
}
//log(2^n*s) = log(2^n) + log(s) = nlog(2) + log(s)
term.Assign(ln2cache);
term.Mul(oldExponent);
this.Assign(xn);
this.Add(term);
}
/// <summary>
/// Calculates ln(2) and returns -10^(n/2 + a bit) for reuse, using the AGM method as described in
/// http://lacim.uqam.ca/~plouffe/articles/log2.pdf
/// </summary>
/// <param name="numBits"></param>
/// <returns></returns>
private static void CalculateLog2(int numBits)
{
//Use the AGM method formula to get log2 to N digits.
//R(a0, b0) = 1 / (1 - Sum(2^-n*(an^2 - bn^2)))
//log(1/2) = R(1, 10^-n) - R(1, 10^-n/2)
PrecisionSpec normalPres = new PrecisionSpec(numBits, PrecisionSpec.BaseType.BIN);
PrecisionSpec extendedPres = new PrecisionSpec(numBits + 1, PrecisionSpec.BaseType.BIN);
BigFloat a0 = new BigFloat(1, extendedPres);
BigFloat b0 = TenPow(-(int)((double)((numBits >> 1) + 2) * 0.302), extendedPres);
BigFloat pow10saved = new BigFloat(b0);
BigFloat firstAGMcacheSaved = new BigFloat(extendedPres);
//save power of 10 (in normal precision)
pow10cache = new BigFloat(b0, normalPres);
ln2cache = R(a0, b0);
//save the first half of the log calculation
firstAGMcache = new BigFloat(ln2cache, normalPres);
firstAGMcacheSaved.Assign(ln2cache);
b0.MulPow2(-1);
ln2cache.Sub(R(a0, b0));
//Convert to log(2)
ln2cache.mantissa.Sign = false;
//Save magic constant for newton log
//First guess in range 1 <= x < 2 is x0 = ln2 * (x - 1) + C
logNewtonConstant = new BigFloat(ln2cache);
logNewtonConstant.Mul(new BigFloat(3, extendedPres));
logNewtonConstant.exponent--;
logNewtonConstant.Sub(new BigFloat(1, extendedPres));
logNewtonConstant = new BigFloat(logNewtonConstant, normalPres);
//Save the inverse.
log2ecache = new BigFloat(ln2cache);
log2ecache = new BigFloat(log2ecache.Reciprocal(), normalPres);
//Now cache log10
//Because the log functions call this function to the precision to which they
//are called, we cannot call them without causing an infinite loop, so we need
//to inline the code.
log10recip = new BigFloat(10, extendedPres);
{
int power2 = log10recip.exponent + 1;
log10recip.exponent = -1;
//BigFloat res = new BigFloat(firstAGMcache);
BigFloat ax = new BigFloat(1, extendedPres);
BigFloat bx = new BigFloat(pow10saved);
bx.Mul(log10recip);
BigFloat r = R(ax, bx);
log10recip.Assign(firstAGMcacheSaved);
log10recip.Sub(r);
ax.Assign(ln2cache);
ax.Mul(new BigFloat(power2, log10recip.mantissa.Precision));
log10recip.Add(ax);
}
log10recip = log10recip.Reciprocal();
log10recip = new BigFloat(log10recip, normalPres);
//Trim to n bits
ln2cache = new BigFloat(ln2cache, normalPres);
}
/// <summary>
/// Subtracts two numbers and returns the result
/// </summary>
public static BigFloat Sub(BigFloat n1, BigFloat n2)
{
BigFloat ret = new BigFloat(n1);
ret.Sub(n2);
return ret;
}
/// <summary>
/// Subtracts two numbers and assigns the result to res.
/// </summary>
/// <param name="res">a pre-existing BigFloat to take the result</param>
/// <param name="n1">the first number</param>
/// <param name="n2">the second number</param>
/// <returns>a handle to res</returns>
public static BigFloat Sub(BigFloat res, BigFloat n1, BigFloat n2)
{
res.Assign(n1);
res.Sub(n2);
return res;
}
/// <summary>
/// Two-variable iterative square root, taken from
/// http://en.wikipedia.org/wiki/Methods_of_computing_square_roots#A_two-variable_iterative_method
/// </summary>
public void Sqrt()
{
if (mantissa.Sign || IsSpecialValue)
{
if (SpecialValue == SpecialValueType.ZERO)
{
return;
}
if (SpecialValue == SpecialValueType.INF_MINUS || mantissa.Sign)
{
SetNaN();
}
return;
}
BigFloat temp2;
BigFloat temp3 = new BigFloat(mantissa.Precision);
BigFloat three = new BigFloat(3, mantissa.Precision);
int exponentScale = 0;
//Rescale to 0.5 <= x < 2
if (exponent < -1)
{
int diff = -exponent;
if ((diff & 1) != 0)
{
diff--;
}
exponentScale = -diff;
exponent += diff;
}
else if (exponent > 0)
{
if ((exponent & 1) != 0)
{
exponentScale = exponent + 1;
exponent = -1;
}
else
{
exponentScale = exponent;
exponent = 0;
}
}
temp2 = new BigFloat(this);
temp2.Sub(new BigFloat(1, mantissa.Precision));
//if (temp2.mantissa.IsZero())
//{
// exponent += exponentScale;
// return;
//}
int numBits = mantissa.Precision.NumBits;
while ((exponent - temp2.exponent) < numBits && temp2.SpecialValue != SpecialValueType.ZERO)
{
//a(n+1) = an - an*cn / 2
temp3.Assign(this);
temp3.Mul(temp2);
temp3.MulPow2(-1);
this.Sub(temp3);
//c(n+1) = cn^2 * (cn - 3) / 4
temp3.Assign(temp2);
temp2.Sub(three);
temp2.Mul(temp3);
temp2.Mul(temp3);
temp2.MulPow2(-2);
}
exponent += (exponentScale >> 1);
}
/// <summary>
/// Arctanh(): the inverse tanh function
/// </summary>
public void Arctanh()
{
//|x| <= 1 for a non-NaN output
if (IsSpecialValue)
{
if (SpecialValue == SpecialValueType.INF_MINUS || SpecialValue == SpecialValueType.INF_PLUS)
{
SetNaN();
return;
}
return;
}
BigFloat one = new BigFloat(1, mantissa.Precision);
BigFloat plusABit = new BigFloat(1, mantissa.Precision);
plusABit.exponent -= (mantissa.Precision.NumBits - (mantissa.Precision.NumBits >> 6));
BigFloat onePlusABit = new BigFloat(1, mantissa.Precision);
onePlusABit.Add(plusABit);
bool sign = mantissa.Sign;
mantissa.Sign = false;
if (GreaterThan(onePlusABit))
{
SetNaN();
}
else if (LessThan(one))
{
BigFloat temp = new BigFloat(this);
Add(one);
one.Sub(temp);
Div(one);
Log();
exponent--;
mantissa.Sign = sign;
}
else
{
if (sign)
{
SetInfMinus();
}
else
{
SetInfPlus();
}
}
}
/// <summary>
/// Arccosh(): the inverse cosh() function
/// </summary>
public void Arccosh()
{
//acosh isn't defined for x < 1
if (IsSpecialValue)
{
if (SpecialValue == SpecialValueType.INF_MINUS || SpecialValue == SpecialValueType.ZERO)
{
SetNaN();
return;
}
return;
}
BigFloat one = new BigFloat(1, mantissa.Precision);
if (LessThan(one))
{
SetNaN();
return;
}
BigFloat temp = new BigFloat(this);
temp.Mul(this);
temp.Sub(one);
temp.Sqrt();
Add(temp);
Log();
}
/// <summary>
/// arcsin(): the inverse function of sin(), range of (-pi/2..pi/2)
/// </summary>
public void Arcsin()
{
if (IsSpecialValue)
{
if (SpecialValue == SpecialValueType.INF_MINUS || SpecialValue == SpecialValueType.INF_PLUS || SpecialValue == SpecialValueType.NAN)
{
SetNaN();
return;
}
return;
}
BigFloat one = new BigFloat(1, mantissa.Precision);
BigFloat plusABit = new BigFloat(1, mantissa.Precision);
plusABit.exponent -= (mantissa.Precision.NumBits - (mantissa.Precision.NumBits >> 6));
BigFloat onePlusABit = new BigFloat(1, mantissa.Precision);
onePlusABit.Add(plusABit);
bool sign = mantissa.Sign;
mantissa.Sign = false;
if (GreaterThan(onePlusABit))
{
SetNaN();
}
else if (LessThan(one))
{
BigFloat temp = new BigFloat(this);
temp.Mul(this);
temp.Sub(one);
temp.mantissa.Sign = !temp.mantissa.Sign;
temp.Sqrt();
temp.Add(one);
Div(temp);
Arctan();
exponent++;
mantissa.Sign = sign;
}
else
{
if (pi == null || pi.mantissa.Precision.NumBits != mantissa.Precision.NumBits)
{
CalculatePi(mantissa.Precision.NumBits);
}
Assign(piBy2);
if (sign) mantissa.Sign = true;
}
}
/// <summary>
/// Calculates tan(x)
/// </summary>
public void Tan()
{
if (IsSpecialValue)
{
//Tan(x) has no limit as x->inf
if (SpecialValue == SpecialValueType.INF_MINUS || SpecialValue == SpecialValueType.INF_PLUS)
{
SetNaN();
}
else if (SpecialValue == SpecialValueType.ZERO)
{
SetZero();
}
return;
}
if (pi == null || pi.mantissa.Precision.NumBits != mantissa.Precision.NumBits)
{
CalculatePi(mantissa.Precision.NumBits);
}
//Work out the sign change (involves replicating some rescaling).
bool sign = mantissa.Sign;
mantissa.Sign = false;
if (mantissa.IsZero())
{
return;
}
//Rescale into 0 <= x < pi
if (GreaterThan(pi))
{
//There will be an inherent loss of precision doing this.
BigFloat newAngle = new BigFloat(this);
newAngle.Mul(piRecip);
newAngle.FPart();
newAngle.Mul(pi);
Assign(newAngle);
}
//Rescale to -pi/2 <= x < pi/2
if (!LessThan(piBy2))
{
Sub(pi);
}
//Now the sign of the sin determines the sign of the tan.
//tan(x) = sin(x) / sqrt(1 - sin^2(x))
Sin();
BigFloat denom = new BigFloat(this);
denom.Mul(this);
denom.Sub(new BigFloat(1, mantissa.Precision));
denom.mantissa.Sign = !denom.mantissa.Sign;
if (denom.mantissa.Sign)
{
denom.SetZero();
}
denom.Sqrt();
Div(denom);
if (sign) mantissa.Sign = !mantissa.Sign;
}