/// <summary> /// Multiplies 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 Mul(BigFloat res, BigFloat n1, BigFloat n2) { res.Assign(n1); res.Mul(n2); return res; }
/// <summary> /// Multiplication (this = this * n2) /// </summary> /// <param name="n2">The number to multiply this by</param> public void Mul(BigFloat n2) { if (SpecialValueMulTest(n2)) return; //Anything times 0 = 0 if (n2.mantissa.IsZero()) { mantissa.Assign(n2.mantissa); exponent = 0; return; } mantissa.MulHi(n2.mantissa); int shift = mantissa.Normalise(); exponent = exponent + n2.exponent + 1 - shift; }
/// <summary> /// Division-based reciprocal, fastest for small precisions up to 15,000 bits. /// </summary> /// <returns>The reciprocal 1/this</returns> public BigFloat Reciprocal() { if (mantissa.Precision.NumBits >= 8192) return ReciprocalNewton(); BigFloat reciprocal = new BigFloat(1u, mantissa.Precision); reciprocal.Div(this); return reciprocal; }
//******************** Mathematical Constants ******************* /// <summary> /// Gets pi to the indicated precision /// </summary> /// <param name="precision">The precision to perform the calculation to</param> /// <returns>pi (the ratio of the area of a circle to its diameter)</returns> public static BigFloat GetPi(PrecisionSpec precision) { if (pi == null || precision.NumBits <= pi.mantissa.Precision.NumBits) { CalculatePi(precision.NumBits); } BigFloat ret = new BigFloat (precision); ret.Assign(pi); return ret; }
//******************** Arithmetic Functions ******************** /// <summary> /// Addition (this = this + n2) /// </summary> /// <param name="n2">The number to add</param> public void Add(BigFloat n2) { if (SpecialValueAddTest(n2)) return; if (scratch.Precision.NumBits != n2.mantissa.Precision.NumBits) { scratch = new BigInt(n2.mantissa.Precision); } if (exponent <= n2.exponent) { int diff = n2.exponent - exponent; exponent = n2.exponent; if (diff != 0) { mantissa.RSH(diff); } uint carry = mantissa.Add(n2.mantissa); if (carry != 0) { mantissa.RSH(1); mantissa.SetBit(mantissa.Precision.NumBits - 1); exponent++; } exponent -= mantissa.Normalise(); } else { int diff = exponent - n2.exponent; scratch.Assign(n2.mantissa); scratch.RSH(diff); uint carry = scratch.Add(mantissa); if (carry != 0) { scratch.RSH(1); scratch.SetBit(mantissa.Precision.NumBits - 1); exponent++; } mantissa.Assign(scratch); exponent -= mantissa.Normalise(); } }
/// <summary> /// Calculates the odd reciprocals of the natural numbers (for atan series) /// </summary> /// <param name="numBits"></param> /// <param name="terms"></param> private static void CalculateReciprocals(int numBits, int terms) { int bits = numBits + 32; PrecisionSpec extendedPres = new PrecisionSpec(bits, PrecisionSpec.BaseType.BIN); PrecisionSpec normalPres = new PrecisionSpec(numBits, PrecisionSpec.BaseType.BIN); System.Collections.Generic.List<BigFloat> list = new System.Collections.Generic.List<BigFloat>(terms); for (int i = 0; i < terms; i++) { BigFloat term = new BigFloat(i*2 + 1, extendedPres); list.Add(new BigFloat(term.Reciprocal(), normalPres)); } reciprocals = list.ToArray(); }
/// <summary> /// Copy Constructor - constructs a new BigFloat with the specified precision, copying the old one. /// /// The value is rounded towards zero in the case where precision is decreased. The Round() function /// should be used beforehand if a correctly rounded result is required. /// </summary> /// <param name="value"></param> /// <param name="mantissaPrec"></param> public BigFloat(BigFloat value, PrecisionSpec mantissaPrec) { Init(mantissaPrec); exponent = value.exponent; if (mantissa.AssignHigh(value.mantissa)) exponent++; }
private bool SpecialValueDivTest(BigFloat n2) { if (IsSpecialValue || n2.IsSpecialValue) { SpecialValueType s1 = SpecialValue; SpecialValueType s2 = n2.SpecialValue; if (s1 == SpecialValueType.NAN) return true; if (s2 == SpecialValueType.NAN) { //Set NaN and return. SetNaN(); return true; } if ((s1 == SpecialValueType.INF_PLUS || s1 == SpecialValueType.INF_MINUS)) { if (s2 == SpecialValueType.INF_PLUS || s2 == SpecialValueType.INF_MINUS) { //Set NaN and return. SetNaN(); return true; } if (n2.Sign) { if (s1 == SpecialValueType.INF_PLUS) { SetInfMinus(); return true; } SetInfPlus(); return true; } //Keep inf return true; } if (s2 == SpecialValueType.ZERO) { if (s1 == SpecialValueType.ZERO) { SetNaN(); return true; } if (Sign) { SetInfMinus(); return true; } SetInfPlus(); return true; } } return false; }
/// <summary> /// The binary logarithm, log2(x) - for precisions above 1000 bits, use Log() and convert the base. /// </summary> private void Log2() { if (scratch.Precision.NumBits != mantissa.Precision.NumBits) { scratch = new BigInt(mantissa.Precision); } int bits = mantissa.Precision.NumBits; BigFloat temp = new BigFloat(this); BigFloat result = new BigFloat(exponent, mantissa.Precision); BigFloat pow2 = new BigFloat(1, mantissa.Precision); temp.exponent = 0; int bitsCalculated = 0; while (bitsCalculated < bits) { int i; for (i = 0; (temp.exponent == 0); i++) { temp.mantissa.SquareHiFast(scratch); int shift = temp.mantissa.Normalise(); temp.exponent += 1 - shift; if (i + bitsCalculated >= bits) break; } pow2.MulPow2(-i); result.Add(pow2); temp.exponent = 0; bitsCalculated += i; } this.Assign(result); }
private bool SpecialValueAddTest(BigFloat n2) { if (IsSpecialValue || n2.IsSpecialValue) { SpecialValueType s1 = SpecialValue; SpecialValueType s2 = n2.SpecialValue; if (s1 == SpecialValueType.NAN) return true; if (s2 == SpecialValueType.NAN) { //Set NaN and return. SetNaN(); return true; } if (s1 == SpecialValueType.INF_PLUS) { //INF+ + INF- = NAN if (s2 == SpecialValueType.INF_MINUS) { SetNaN(); return true; } return true; } if (s1 == SpecialValueType.INF_MINUS) { //INF+ + INF- = NAN if (s2 == SpecialValueType.INF_PLUS) { SetNaN(); return true; } return true; } if (s2 == SpecialValueType.ZERO) { return true; } if (s1 == SpecialValueType.ZERO) { Assign(n2); return true; } } return false; }
private bool SpecialValueMulTest(BigFloat n2) { if (IsSpecialValue || n2.IsSpecialValue) { SpecialValueType s1 = SpecialValue; SpecialValueType s2 = n2.SpecialValue; if (s1 == SpecialValueType.NAN) return true; if (s2 == SpecialValueType.NAN) { //Set NaN and return. SetNaN(); return true; } if (s1 == SpecialValueType.INF_PLUS) { //Inf+ * Inf- = Inf- if (s2 == SpecialValueType.INF_MINUS) { Assign(n2); return true; } //Inf+ * 0 = NaN if (s2 == SpecialValueType.ZERO) { //Set NaN and return. SetNaN(); return true; } return true; } if (s1 == SpecialValueType.INF_MINUS) { //Inf- * Inf- = Inf+ if (s2 == SpecialValueType.INF_MINUS) { Sign = false; return true; } //Inf- * 0 = NaN if (s2 == SpecialValueType.ZERO) { //Set NaN and return. SetNaN(); return true; } return true; } if (s2 == SpecialValueType.ZERO) { SetZero(); return true; } if (s1 == SpecialValueType.ZERO) { return true; } } return false; }
/// <summary> /// Returns a base-10 string representing the number. /// /// Note: This is inefficient and possibly inaccurate. Please use with enough /// rounding digits (set using the RoundingDigits property) to ensure accuracy /// </summary> public override string ToString() { if (IsSpecialValue) { SpecialValueType s = SpecialValue; if (s == SpecialValueType.ZERO) { return String.Format("0{0}0", System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator); } else if (s == SpecialValueType.INF_PLUS) { return System.Globalization.CultureInfo.CurrentCulture.NumberFormat.PositiveInfinitySymbol; } else if (s == SpecialValueType.INF_MINUS) { return System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NegativeInfinitySymbol; } else if (s == SpecialValueType.NAN) { return System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NaNSymbol; } else { return "Unrecognised special type"; } } if (scratch.Precision.NumBits != mantissa.Precision.NumBits) { scratch = new BigInt(mantissa.Precision); } //The mantissa expresses 1.xxxxxxxxxxx //The highest possible value for the mantissa without the implicit 1. is 0.9999999... scratch.Assign(mantissa); //scratch.Round(3); scratch.Sign = false; BigInt denom = new BigInt("0", mantissa.Precision); denom.SetBit(mantissa.Precision.NumBits - 1); bool useExponentialNotation = false; int halfBits = mantissa.Precision.NumBits / 2; if (halfBits > 60) halfBits = 60; int precDec = 10; if (exponent > 0) { if (exponent < halfBits) { denom.RSH(exponent); } else { useExponentialNotation = true; } } else if (exponent < 0) { int shift = -(exponent); if (shift < precDec) { scratch.RSH(shift); } else { useExponentialNotation = true; } } string output; if (useExponentialNotation) { int absExponent = exponent; if (absExponent < 0) absExponent = -absExponent; int powerOf10 = (int)((double)absExponent * Math.Log10(2.0)); //Use 1 extra digit of precision (this is actually 32 bits more, nb) BigFloat thisFloat = new BigFloat(this, new PrecisionSpec(mantissa.Precision.NumBits + 1, PrecisionSpec.BaseType.BIN)); thisFloat.mantissa.Sign = false; //Multiplicative correction factor to bring number into range. BigFloat one = new BigFloat(1, new PrecisionSpec(mantissa.Precision.NumBits + 1, PrecisionSpec.BaseType.BIN)); BigFloat ten = new BigFloat(10, new PrecisionSpec(mantissa.Precision.NumBits + 1, PrecisionSpec.BaseType.BIN)); BigFloat tenRCP = ten.Reciprocal(); //Accumulator for the power of 10 calculation. BigFloat acc = new BigFloat(1, new PrecisionSpec(mantissa.Precision.NumBits + 1, PrecisionSpec.BaseType.BIN)); BigFloat tenToUse; if (exponent > 0) { tenToUse = new BigFloat(tenRCP, new PrecisionSpec(mantissa.Precision.NumBits + 1, PrecisionSpec.BaseType.BIN)); } else { tenToUse = new BigFloat(ten, new PrecisionSpec(mantissa.Precision.NumBits + 1, PrecisionSpec.BaseType.BIN)); } BigFloat tenToPower = new BigFloat(1, new PrecisionSpec(mantissa.Precision.NumBits + 1, PrecisionSpec.BaseType.BIN)); int powerTemp = powerOf10; //Fast power function while (powerTemp != 0) { tenToPower.Mul(tenToUse); tenToUse.Assign(tenToPower); if ((powerTemp & 1) != 0) { acc.Mul(tenToPower); } powerTemp >>= 1; } thisFloat.Mul(acc); //If we are out of range, correct. if (thisFloat.GreaterThan(ten)) { thisFloat.Mul(tenRCP); if (exponent > 0) { powerOf10++; } else { powerOf10--; } } else if (thisFloat.LessThan(one)) { thisFloat.Mul(ten); if (exponent > 0) { powerOf10--; } else { powerOf10++; } } //Restore the precision and the sign. BigFloat printable = new BigFloat(thisFloat, mantissa.Precision); printable.mantissa.Sign = mantissa.Sign; output = printable.ToString(); if (exponent < 0) powerOf10 = -powerOf10; output = String.Format("{0}E{1}", output, powerOf10); } else { BigInt bigDigit = BigInt.Div(scratch, denom); bigDigit.Sign = false; scratch.Sub(BigInt.Mul(denom, bigDigit)); if (mantissa.Sign) { output = String.Format("-{0}.", bigDigit); } else { output = String.Format("{0}.", bigDigit); } denom = BigInt.Div(denom, 10u); while (!denom.IsZero()) { uint digit = (uint)BigInt.Div(scratch, denom); if (digit == 10) digit--; scratch.Sub(BigInt.Mul(denom, digit)); output = String.Format("{0}{1}", output, digit); denom = BigInt.Div(denom, 10u); } output = RoundString(output, RoundingDigits); } return output; }
//************************** Conversions ************************* /// <summary> /// Converts a BigFloat to an BigInt with the specified precision /// </summary> /// <param name="n1">The number to convert</param> /// <param name="precision">The precision to convert it with</param> /// <param name="round">Do we round the number if we are truncating the mantissa?</param> /// <returns></returns> public static BigInt ConvertToInt(BigFloat n1, PrecisionSpec precision, bool round) { BigInt ret = new BigInt(precision); int numBits = n1.mantissa.Precision.NumBits; int shift = numBits - (n1.exponent + 1); BigFloat copy = new BigFloat(n1); bool inc = false; //Rounding if (copy.mantissa.Precision.NumBits > ret.Precision.NumBits) { inc = true; for (int i = copy.exponent + 1; i <= ret.Precision.NumBits; i++) { if (copy.mantissa.GetBitFromTop(i) == 0) { inc = false; break; } } } if (shift > 0) { copy.mantissa.RSH(shift); } else if (shift < 0) { copy.mantissa.LSH(-shift); } ret.Assign(copy.mantissa); if (inc) ret.Increment(); return ret; }
/// <summary> /// Divides 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 Div(BigFloat res, BigFloat n1, BigFloat n2) { res.Assign(n1); res.Div(n2); return res; }
private static void CalculateEOnly(int numBits) { PrecisionSpec extendedPrecision = new PrecisionSpec(numBits + 1, PrecisionSpec.BaseType.BIN); PrecisionSpec normalPrecision = new PrecisionSpec(numBits, PrecisionSpec.BaseType.BIN); int iExponent = (int)(Math.Sqrt(numBits)); BigFloat factorial = new BigFloat(1, extendedPrecision); BigFloat constant = new BigFloat(1, extendedPrecision); constant.exponent -= iExponent; BigFloat numerator = new BigFloat(constant); BigFloat reciprocal; //Calculate the 2^iExponent th root of e BigFloat e = new BigFloat(1, extendedPrecision); int i; for (i = 1; i < Int32.MaxValue; i++) { BigFloat number = new BigFloat(i, extendedPrecision); factorial.Mul(number); reciprocal = factorial.Reciprocal(); reciprocal.Mul(numerator); if (-reciprocal.exponent > numBits) break; e.Add(reciprocal); numerator.Mul(constant); System.GC.Collect(); } for (i = 0; i < iExponent; i++) { numerator.Assign(e); e.Mul(numerator); } //Set the cached static values. eCache = new BigFloat(e, normalPrecision); eRCPCache = new BigFloat(e.Reciprocal(), normalPrecision); }
/// <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> /// 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> /// Log(x) implemented as an Arithmetic-Geometric Mean. Fast for high precisions. /// </summary> private void LogAGM1() { if (mantissa.IsZero() || mantissa.Sign) { return; } //Compute ln2. if (ln2cache == null || mantissa.Precision.NumBits > ln2cache.mantissa.Precision.NumBits) { CalculateLog2(mantissa.Precision.NumBits); } //Compute ln(x) using AGM formula //1. Re-write the input as 2^n * (0.5 <= x < 1) int power2 = exponent + 1; exponent = -1; //BigFloat res = new BigFloat(firstAGMcache); BigFloat a0 = new BigFloat(1, mantissa.Precision); BigFloat b0 = new BigFloat(pow10cache); b0.Mul(this); BigFloat r = R(a0, b0); this.Assign(firstAGMcache); this.Sub(r); a0.Assign(ln2cache); a0.Mul(new BigFloat(power2, mantissa.Precision)); this.Add(a0); }
/// <summary> /// Copy constructor /// </summary> /// <param name="value"></param> public BigFloat(BigFloat value) { Init(value.mantissa.Precision); exponent = value.exponent; mantissa.Assign(value.mantissa); }
private void Exp(int numBits) { if (IsSpecialValue) { if (SpecialValue == SpecialValueType.ZERO) { //e^0 = 1 exponent = 0; mantissa.SetHighDigit(0x80000000); } else if (SpecialValue == SpecialValueType.INF_MINUS) { //e^-inf = 0 SetZero(); } return; } PrecisionSpec prec = new PrecisionSpec(numBits, PrecisionSpec.BaseType.BIN); numBits = prec.NumBits; if (scratch.Precision.NumBits != prec.NumBits) { scratch = new BigInt(prec); } if (inverseFactorialCache == null || invFactorialCutoff < numBits) { CalculateFactorials(numBits); } //let x = 1 * 'this'.mantissa (i.e. 1 <= x < 2) //exp(2^n * x) = e^(2^n * x) = (e^x)^2n = exp(x)^2n int oldExponent = 0; if (exponent > -4) { oldExponent = exponent + 4; exponent = -4; } BigFloat thisSave = new BigFloat(this, prec); BigFloat temp = new BigFloat(1, prec); BigFloat temp2 = new BigFloat(this, prec); BigFloat res = new BigFloat(1, prec); int length = inverseFactorialCache.Length; int iterations; for (int i = 1; i < length; i++) { //temp = x^i temp.Mul(thisSave); temp2.Assign(inverseFactorialCache[i]); temp2.Mul(temp); if (temp2.exponent < -(numBits + 4)) { iterations = i; break; } res.Add(temp2); } //res = exp(x) //Now... x^(2^n) = (x^2)^(2^(n - 1)) for (int i = 0; i < oldExponent; i++) { res.mantissa.SquareHiFast(scratch); int shift = res.mantissa.Normalise(); res.exponent = res.exponent << 1; res.exponent += 1 - shift; } //Deal with +/- inf if (res.exponent == Int32.MaxValue) { res.mantissa.Zero(); } Assign(res); }
/// <summary> /// Constructs a BigFloat from a string /// </summary> /// <param name="value"></param> /// <param name="mantissaPrec"></param> public BigFloat(string value, PrecisionSpec mantissaPrec) { Init(mantissaPrec); PrecisionSpec extendedPres = new PrecisionSpec(mantissa.Precision.NumBits + 1, PrecisionSpec.BaseType.BIN); BigFloat ten = new BigFloat(10, extendedPres); BigFloat iPart = new BigFloat(extendedPres); BigFloat fPart = new BigFloat(extendedPres); BigFloat tenRCP = ten.Reciprocal(); if (value.Contains(System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NaNSymbol)) { SetNaN(); return; } else if (value.Contains(System.Globalization.CultureInfo.CurrentCulture.NumberFormat.PositiveInfinitySymbol)) { SetInfPlus(); return; } else if (value.Contains(System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NegativeInfinitySymbol)) { SetInfMinus(); return; } string decimalpoint = System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator; char[] digitChars = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ',', '.' }; //Read in the integer part up the the decimal point. bool sign = false; value = value.Trim(); int i = 0; if (value.Length > i && value[i] == '-') { sign = true; i++; } if (value.Length > i && value[i] == '+') { i++; } for ( ; i < value.Length; i++) { //break on decimal point if (value[i] == decimalpoint[0]) break; int digit = Array.IndexOf(digitChars, value[i]); if (digit < 0) break; //Ignore place separators (assumed either , or .) if (digit > 9) continue; if (i > 0) iPart.Mul(ten); iPart.Add(new BigFloat(digit, extendedPres)); } //If we've run out of characters, assign everything and return if (i == value.Length) { iPart.mantissa.Sign = sign; exponent = iPart.exponent; if (mantissa.AssignHigh(iPart.mantissa)) exponent++; return; } //Assign the characters after the decimal point to fPart if (value[i] == '.' && i < value.Length - 1) { BigFloat RecipToUse = new BigFloat(tenRCP); for (i++; i < value.Length; i++) { int digit = Array.IndexOf(digitChars, value[i]); if (digit < 0) break; BigFloat temp = new BigFloat(digit, extendedPres); temp.Mul(RecipToUse); RecipToUse.Mul(tenRCP); fPart.Add(temp); } } //If we're run out of characters, add fPart and iPart and return if (i == value.Length) { iPart.Add(fPart); iPart.mantissa.Sign = sign; exponent = iPart.exponent; if (mantissa.AssignHigh(iPart.mantissa)) exponent++; return; } if (value[i] == '+' || value[i] == '-') i++; if (i == value.Length) { iPart.Add(fPart); iPart.mantissa.Sign = sign; exponent = iPart.exponent; if (mantissa.AssignHigh(iPart.mantissa)) exponent++; return; } //Look for exponential notation. if ((value[i] == 'e' || value[i] == 'E') && i < value.Length - 1) { //Convert the exponent to an int. int exp; try { exp = System.Convert.ToInt32(new string(value.ToCharArray(i + 1, value.Length - (i + 1)))); } catch (Exception) { iPart.Add(fPart); iPart.mantissa.Sign = sign; exponent = iPart.exponent; if (mantissa.AssignHigh(iPart.mantissa)) exponent++; return; } //Raise or lower 10 to the power of the exponent BigFloat acc = new BigFloat(1, extendedPres); BigFloat temp = new BigFloat(1, extendedPres); int powerTemp = exp; BigFloat multiplierToUse; if (exp < 0) { multiplierToUse = new BigFloat(tenRCP); powerTemp = -exp; } else { multiplierToUse = new BigFloat(ten); } //Fast power function while (powerTemp != 0) { temp.Mul(multiplierToUse); multiplierToUse.Assign(temp); if ((powerTemp & 1) != 0) { acc.Mul(temp); } powerTemp >>= 1; } iPart.Add(fPart); iPart.Mul(acc); iPart.mantissa.Sign = sign; exponent = iPart.exponent; if (mantissa.AssignHigh(iPart.mantissa)) exponent++; return; } iPart.Add(fPart); iPart.mantissa.Sign = sign; exponent = iPart.exponent; if (mantissa.AssignHigh(iPart.mantissa)) exponent++; }
/// <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> /// Get e to the indicated precision /// </summary> /// <param name="precision">The preicision to perform the calculation to</param> /// <returns>e (the number for which the d/dx(e^x) = e^x)</returns> public static BigFloat GetE(PrecisionSpec precision) { if (eCache == null || eCache.mantissa.Precision.NumBits < precision.NumBits) { CalculateEOnly(precision.NumBits); //CalculateFactorials(precision.NumBits); } BigFloat ret = new BigFloat(precision); ret.Assign(eCache); return ret; }
private static BigFloat TenPow(int power, PrecisionSpec precision) { BigFloat acc = new BigFloat(1, precision); BigFloat temp = new BigFloat(1, precision); int powerTemp = power; BigFloat multiplierToUse = new BigFloat(10, precision); if (power < 0) { multiplierToUse = multiplierToUse.Reciprocal(); powerTemp = -power; } //Fast power function while (powerTemp != 0) { temp.Mul(multiplierToUse); multiplierToUse.Assign(temp); if ((powerTemp & 1) != 0) { acc.Mul(temp); } powerTemp >>= 1; } return acc; }
/// <summary> /// Subtraction (this = this - n2) /// </summary> /// <param name="n2">The number to subtract from this</param> public void Sub(BigFloat n2) { n2.mantissa.Sign = !n2.mantissa.Sign; Add(n2); n2.mantissa.Sign = !n2.mantissa.Sign; }
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> /// Division (this = this / n2) /// </summary> /// <param name="n2">The number to divide this by</param> public void Div(BigFloat n2) { if (SpecialValueDivTest(n2)) return; if (mantissa.Precision.NumBits >= 8192) { BigFloat rcp = n2.Reciprocal(); Mul(rcp); } else { int shift = mantissa.DivAndShift(n2.mantissa); exponent = exponent - (n2.exponent + shift); } }
private static void CalculateFactorials(int numBits) { System.Collections.Generic.List<BigFloat> list = new System.Collections.Generic.List<BigFloat>(64); System.Collections.Generic.List<BigFloat> list2 = new System.Collections.Generic.List<BigFloat>(64); PrecisionSpec extendedPrecision = new PrecisionSpec(numBits + 1, PrecisionSpec.BaseType.BIN); PrecisionSpec normalPrecision = new PrecisionSpec(numBits, PrecisionSpec.BaseType.BIN); BigFloat factorial = new BigFloat(1, extendedPrecision); BigFloat reciprocal; //Calculate e while we're at it BigFloat e = new BigFloat(1, extendedPrecision); list.Add(new BigFloat(factorial, normalPrecision)); for (int i = 1; i < Int32.MaxValue; i++) { BigFloat number = new BigFloat(i, extendedPrecision); factorial.Mul(number); if (factorial.exponent > numBits) break; list2.Add(new BigFloat(factorial, normalPrecision)); reciprocal = factorial.Reciprocal(); e.Add(reciprocal); list.Add(new BigFloat(reciprocal, normalPrecision)); } //Set the cached static values. inverseFactorialCache = list.ToArray(); factorialCache = list2.ToArray(); invFactorialCutoff = numBits; eCache = new BigFloat(e, normalPrecision); eRCPCache = new BigFloat(e.Reciprocal(), normalPrecision); }
/// <summary> /// Newton's method reciprocal, fastest for larger precisions over 15,000 bits. /// </summary> /// <returns>The reciprocal 1/this</returns> public BigFloat ReciprocalNewton() { if (mantissa.IsZero()) { exponent = Int32.MaxValue; return null; } bool oldSign = mantissa.Sign; int oldExponent = exponent; //Kill exponent for now (will re-institute later) exponent = 0; bool topBit = mantissa.IsTopBitOnlyBit(); PrecisionSpec curPrec = new PrecisionSpec(32, PrecisionSpec.BaseType.BIN); BigFloat reciprocal = new BigFloat(curPrec); BigFloat constant2 = new BigFloat(curPrec); BigFloat temp = new BigFloat(curPrec); BigFloat thisPrec = new BigFloat(this, curPrec); reciprocal.exponent = 1; reciprocal.mantissa.SetHighDigit(3129112985u); constant2.exponent = 1; constant2.mantissa.SetHighDigit(0x80000000u); //D is deliberately left negative for all the following operations. thisPrec.mantissa.Sign = true; //Initial estimate. reciprocal.Add(thisPrec); //mantissa.Sign = false; //Shift down into 0.5 < this < 1 range thisPrec.mantissa.RSH(1); //Iteration. int accuracyBits = 2; int mantissaBits = mantissa.Precision.NumBits; //Each iteration is a pass of newton's method for RCP. //The is a substantial optimisation to be done here... //You can double the number of bits for the calculations //at each iteration, meaning that the whole process only //takes some constant multiplier of the time for the //full-scale multiplication. while (accuracyBits < mantissaBits) { //Increase the precision as needed if (accuracyBits >= curPrec.NumBits / 2) { int newBits = curPrec.NumBits * 2; if (newBits > mantissaBits) newBits = mantissaBits; curPrec = new PrecisionSpec(newBits, PrecisionSpec.BaseType.BIN); reciprocal = new BigFloat(reciprocal, curPrec); constant2 = new BigFloat(curPrec); constant2.exponent = 1; constant2.mantissa.SetHighDigit(0x80000000u); temp = new BigFloat(temp, curPrec); thisPrec = new BigFloat(this, curPrec); thisPrec.mantissa.Sign = true; thisPrec.mantissa.RSH(1); } //temp = Xn temp.exponent = reciprocal.exponent; temp.mantissa.Assign(reciprocal.mantissa); //temp = -Xn * D temp.Mul(thisPrec); //temp = -Xn * D + 2 (= 2 - Xn * D) temp.Add(constant2); //reciprocal = X(n+1) = Xn * (2 - Xn * D) reciprocal.Mul(temp); accuracyBits *= 2; } //'reciprocal' is now the reciprocal of the shifted down, zero-exponent mantissa of 'this' //Restore the mantissa. //mantissa.LSH(1); exponent = oldExponent; //mantissa.Sign = oldSign; if (topBit) { reciprocal.exponent = -(oldExponent); } else { reciprocal.exponent = -(oldExponent + 1); } reciprocal.mantissa.Sign = oldSign; return reciprocal; }
/// <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; }