static public string ToGoldStringKR(long bigInteger)
{
string output = "";
if (BigInteger.Compare(bigInteger, new BigInteger(10000)) == -1)
{
output = bigInteger.ToString();
}
else if (BigInteger.Compare(bigInteger, new BigInteger(100000000)) == -1)
{
string strTmp = bigInteger.ToString();
output = strTmp.Substring(0, strTmp.Length - 1 - 3) + "만" +
strTmp.Substring(strTmp.Length - 1 - 3);
}
else if (BigInteger.Compare(bigInteger, new BigInteger(1000000000000)) == -1)
{
string strTmp = bigInteger.ToString();
output = strTmp.Substring(0, strTmp.Length - 8) + "억" +
strTmp.Substring(strTmp.Length - 8, 4) + "만";
/* + strTmp.Substring(strTmp.Length - 1 - 3);*/
}
else if (BigInteger.Compare(bigInteger, new BigInteger(10000000000000000)) == -1)
{
string strTmp = bigInteger.ToString();
output = strTmp.Substring(0, strTmp.Length - 12) + "조" +
strTmp.Substring(strTmp.Length - 12, 4) + "억";
/*+ strTmp.Substring(strTmp.Length - 8, 4) + "만"
+ strTmp.Substring(strTmp.Length - 4);*/
}
else if (BigInteger.Compare(bigInteger, new BigInteger(10000000000000000000)) == -1)
{
string strTmp = bigInteger.ToString();
output = strTmp.Substring(0, strTmp.Length - 16) + "경" +
strTmp.Substring(strTmp.Length - 16, 4) + "조";
/*+ strTmp.Substring(strTmp.Length - 12, 4) + "억"
+ strTmp.Substring(strTmp.Length - 8, 4) + "만"
+ strTmp.Substring(strTmp.Length - 4);*/
}
return(output);
}
private static void VerifyComparison(BigInteger x, BigInteger y, int expectedResult)
{
bool expectedEquals = 0 == expectedResult;
bool expectedLessThan = expectedResult < 0;
bool expectedGreaterThan = expectedResult > 0;
Assert.Equal(expectedEquals, x == y);
Assert.Equal(expectedEquals, y == x);
Assert.Equal(!expectedEquals, x != y);
Assert.Equal(!expectedEquals, y != x);
Assert.Equal(expectedEquals, x.Equals(y));
Assert.Equal(expectedEquals, y.Equals(x));
Assert.Equal(expectedEquals, x.Equals((Object)y));
Assert.Equal(expectedEquals, y.Equals((Object)x));
VerifyCompareResult(expectedResult, x.CompareTo(y), "x.CompareTo(y)");
VerifyCompareResult(-expectedResult, y.CompareTo(x), "y.CompareTo(x)");
VerifyCompareResult(expectedResult, BigInteger.Compare(x, y), "Compare(x,y)");
VerifyCompareResult(-expectedResult, BigInteger.Compare(y, x), "Compare(y,x)");
if (expectedEquals)
{
Assert.Equal(x.GetHashCode(), y.GetHashCode());
Assert.Equal(x.ToString(), y.ToString());
}
Assert.Equal(x.GetHashCode(), x.GetHashCode());
Assert.Equal(y.GetHashCode(), y.GetHashCode());
Assert.Equal(expectedLessThan, x < y);
Assert.Equal(expectedGreaterThan, y < x);
Assert.Equal(expectedGreaterThan, x > y);
Assert.Equal(expectedLessThan, y > x);
Assert.Equal(expectedLessThan || expectedEquals, x <= y);
Assert.Equal(expectedGreaterThan || expectedEquals, y <= x);
Assert.Equal(expectedGreaterThan || expectedEquals, x >= y);
Assert.Equal(expectedLessThan || expectedEquals, y >= x);
}
public static HassiumObject lesserthanorequal(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
var BigInt = (self as HassiumBigInt).BigInt;
var bigintarg = args[0] as HassiumBigInt;
if (bigintarg != null)
{
return(new HassiumBool(BigInteger.Compare(BigInt, (bigintarg as HassiumBigInt).BigInt) <= 0));
}
var intarg = args[0] as HassiumInt;
if (intarg != null)
{
return(new HassiumBool(BigInteger.Compare(BigInt, (intarg as HassiumInt).Int) <= 0));
}
vm.RaiseException(HassiumConversionFailedException.ConversionFailedExceptionTypeDef._new(vm, null, location, args[0], Number));
return(Null);
}
public int CompareTo(NodeId other)
{
if ((object)other == null)
{
return(1);
}
BigInteger.Sign s = _value.Compare(other._value);
if (s == BigInteger.Sign.Zero)
{
return(0);
}
if (s == BigInteger.Sign.Positive)
{
return(1);
}
return(-1);
}
public int CompareTo(BigFloat other)
{
if (BigFloat.Equals(other, null))
{
throw new ArgumentNullException("other");
}
//Make copies
BigInteger one = this.numerator;
BigInteger two = other.numerator;
//cross multiply
one *= other.denominator;
two *= this.denominator;
//test
return(BigInteger.Compare(one, two));
}
private static Matrix GenerateValues(int rows, int cols)
{
Console.Clear();
var total = BigInteger.Multiply(new BigInteger(rows), new BigInteger(cols));
var current = new BigInteger(0);
BigInteger progress = new BigInteger(0);
Console.WriteLine($"GENERATION. Total: {total}");
using (var sw = new StreamWriter($"values_{rows}_{cols}", false))
{
for (var i = 0; i < rows; i++)
{
for (var c = 0; c < cols; c++)
{
var value = new Random((int)DateTime.Now.Ticks).Next(0, 1000 * 1000);
sw.Write(value);
sw.Write(';');
current = BigInteger.Add(current, 1);
var accuracy = 100000;
var currentProgress = BigInteger.Divide(BigInteger.Multiply(current, 100 * accuracy), total);
var result = BigInteger.Compare(progress, currentProgress);
if (result < 0)
{
var rem = new BigInteger();
BigInteger.DivRem(currentProgress, accuracy, out rem);
Console.SetCursorPosition(0, 1);
Console.WriteLine($"GENERATION. Progress: {BigInteger.Divide(currentProgress, accuracy)},{rem}");
}
progress = currentProgress;
}
sw.Write('_');
}
sw.Flush();
}
Console.WriteLine("GENERATION. All processes completed");
return(null);
}
private void TryParse1()
{
// <Snippet1>
BigInteger number1, number2;
bool succeeded1 = BigInteger.TryParse("-12347534159895123", out number1);
bool succeeded2 = BigInteger.TryParse("987654321357159852", out number2);
if (succeeded1 && succeeded2)
{
number1 *= 3;
number2 *= 2;
switch (BigInteger.Compare(number1, number2))
{
case -1:
Console.WriteLine("{0} is greater than {1}.", number2, number1);
break;
case 0:
Console.WriteLine("{0} is equal to {1}.", number1, number2);
break;
case 1:
Console.WriteLine("{0} is greater than {1}.", number1, number2);
break;
}
}
else
{
if (!succeeded1)
{
Console.WriteLine("Unable to initialize the first BigInteger value.");
}
if (!succeeded2)
{
Console.WriteLine("Unable to initialize the second BigInteger value.");
}
}
// The example displays the following output:
// 1975308642714319704 is greater than -37042602479685369.
// </Snippet1>
}
public static BigInteger Height(BigInteger n, BigInteger m)
{
if (BigInteger.Compare(n, BigInteger.Zero) == 0 || BigInteger.Compare(m, BigInteger.Zero) == 0)
{
return(BigInteger.Zero);
}
BigInteger result = 1;
BigInteger total = 0;
BigInteger value = 1;
for (BigInteger k = 1; k <= n; k++)
{
value = value * (m - k + 1) / k;
total += value;
}
return(total);
}
public int CompareTo(BigDecimal other)
{
var sdiff = this.Scale - other.Scale;
if (sdiff == 0)
{
return(BigInteger.Compare(this.IntVal, other.IntVal));
}
if (sdiff < 0)
{
var aValMultiplied = BigInteger.Multiply(this.IntVal, BigInteger.Pow(10, -sdiff));
return(aValMultiplied.CompareTo(other.IntVal));
}
// sdiff > 0
var bValMultiplied = BigInteger.Multiply(other.IntVal, BigInteger.Pow(10, sdiff));
return(BigInteger.Compare(this.IntVal, bValMultiplied));
}
/// <summary>
/// Entry point
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
#region BigInteger
BigInteger BigInt1 = new BigInteger(ulong.MaxValue);
BigInteger BigInt2 = new BigInteger(ulong.MaxValue);
Console.WriteLine(BigInteger.Add(BigInt1, BigInt2).ToString());
BigInteger aBigBigger;
BigInteger aBigSmaller;
BigInteger.TryParse("999999999999999999999999999999999999999999999999999999999999999999999999999999999999", out aBigBigger);
BigInteger.TryParse("999999999999999999999999999999999999999999999999999999999999999999999999999999999998", out aBigSmaller);
if (BigInteger.Compare(aBigBigger, aBigSmaller) > 0)
{
Console.WriteLine(aBigBigger);
}
#endregion BigInteger
#region Truple
for (Int16 i = 0; i <= 25; i++)
{
for (Int16 j = 1; j <= 5; j++)
{
var tuple = DivAndRemainder(i, j);
Console.WriteLine("{0}\t{1}\t{2}\t{3}\n", i, j, tuple.Item1, tuple.Item2);
}
}
#endregion
#region python
IronPythonCall.CallScript();
#endregion
Console.ReadKey();
}
public void UInt128BigIntegerAgreement()
{
BigInteger b = BigInteger.Parse(UInt128.MaxValue.ToString()) + 1;
foreach (UInt128 u in GetRandomUInt128(new Random(2), 16))
{
BigInteger u1 = (BigInteger)u;
foreach (UInt128 v in GetRandomUInt128(new Random(3), 16))
{
BigInteger v1 = (BigInteger)v;
// Comparison
Assert.IsTrue(UInt128.Compare(u, v) == BigInteger.Compare(u1, v1));
Assert.IsTrue((u < v) == (u1 < v1));
Assert.IsTrue((u > v) == (u1 > v1));
// Sum
UInt128 s = u + v;
BigInteger s1 = (u1 + v1) % b;
Assert.IsTrue((BigInteger)s == s1);
// Difference
if (u >= v)
{
UInt128 d = u - v;
BigInteger d1 = u1 - v1;
Assert.IsTrue((BigInteger)d == d1);
}
// Product
UInt128 p = u * v;
BigInteger p1 = (u1 * v1) % b;
Assert.IsTrue((BigInteger)p == p1);
// Quotient
UInt128 q = u / v;
BigInteger q1 = u1 / v1;
Assert.IsTrue((BigInteger)q == q1);
}
}
}
public void GenerateFibonacciSequence_LimitIs16_Sequence()
{
bool expected = true;
bool actual = true;
IEnumerable <BigInteger> arrayActual = Generator.GenerateFibonacciSequence(3);
int[] arrayExpected = new int[] { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610 };
int i = 0;
foreach (var number in arrayActual)
{
if (BigInteger.Compare(number, arrayExpected[i]) != 0)
{
actual = false;
}
i++;
}
Assert.AreEqual(expected, actual);
}
public void GeneratePrimeSequence_LimitIs7_Sequence()
{
bool expected = true;
bool actual = true;
IEnumerable <BigInteger> arrayActual = Generator.GeneratePrimeSequence(7);
int[] arrayExpected = new int[] { 1, 3, 5, 7, 9, 11, 13 };
int i = 0;
foreach (var number in arrayActual)
{
if (BigInteger.Compare(number, arrayExpected[i]) != 0)
{
actual = false;
}
i++;
}
Assert.AreEqual(expected, actual);
}
internal static bool EqLiteralExprs(LiteralExpr e0, LiteralExpr e1)
{
if (e0.Value is bool && e1.Value is bool)
{
return(((bool)e0.Value) == ((bool)e1.Value));
}
else if (e0.Value is int && e1.Value is int)
{
return(((int)e0.Value) == ((int)e1.Value));
}
else if (e0.Value is BigInteger && e1.Value is BigInteger)
{
return(BigInteger.Compare((BigInteger)e0.Value, (BigInteger)e1.Value) == 0);
}
else if (e0.Value is string && e1.Value is string)
{
return(((string)e0.Value).Equals((string)e1.Value));
}
return(false);
}
private static IEnumerable <int> GenDigits()
{
var k = 1;
var n1 = new BigInteger(4);
var n2 = new BigInteger(3);
var d = BigInteger.One;
while (true)
{
// digit
var u = BigInteger.Divide(n1, d);
var v = BigInteger.Divide(n2, d);
if (BigInteger.Compare(u, v) == 0)
{
yield return((int)u);
// extract
u = BigInteger.Multiply(u, -10);
u = BigInteger.Multiply(u, d);
n1 = BigInteger.Multiply(n1, 10);
n1 = BigInteger.Add(n1, u);
n2 = BigInteger.Multiply(n2, 10);
n2 = BigInteger.Add(n2, u);
}
else
{
// produce
var k2 = k * 2;
u = BigInteger.Multiply(n1, k2 - 1);
v = BigInteger.Add(n2, n2);
var w = BigInteger.Multiply(n1, k - 1);
n1 = BigInteger.Add(u, v);
u = BigInteger.Multiply(n2, k + 2);
n2 = BigInteger.Add(w, u);
d = BigInteger.Multiply(d, k2 + 1);
k++;
}
}
}
public BigInteger FindOrderOfGroup()
{
var ret = BigInteger.Zero;
var q = Curve.CalculateMultiplication(Point, BigInteger.Add(Curve.Modulo, BigInteger.One));
var m = BigInteger.Add(Curve.Modulo.SqareRoot2().SqareRoot2(), BigInteger.One);
for (var j = BigInteger.One; BigInteger.Compare(j, m) < 1; j = BigInteger.Add(j, BigInteger.One))
{
var jp = Curve.CalculateMultiplication(Point, j);
for (var k = BigInteger.Multiply(m, BigInteger.MinusOne); BigInteger.Compare(k, m) < 1; k = BigInteger.Add(k, BigInteger.One))
{
var twoMK = BigInteger.Multiply(BigInteger.Multiply(new BigInteger(2), m), k);
var cp = Curve.CalculateMultiplication(Point, twoMK);
cp = Curve.CalculateAddition(cp, q);
if (BigInteger.Compare(cp.XCoordinate, jp.XCoordinate) == 0)
{
ret = BigInteger.Add(Curve.Modulo, BigInteger.Add(BigInteger.One, twoMK));
// Console.WriteLine($"Order of group: {ret} +- {j}");
var ret1 = BigInteger.Add(ret, j);
var ret2 = BigInteger.Subtract(ret, j);
if (CheckInfinity(ret1))
{
return(ret1);
}
else if (CheckInfinity(ret2))
{
return(ret2);
}
}
}
}
return(ret);
}
// This is how the mining works!
public void Mine(int difficulty)
{
var maxTarget = new BigInteger(HexToLittleEndianSwap(MAX_TARGET_VALUE));
var diff = new BigInteger(difficulty);
var target = BigInteger.Divide(maxTarget, diff);
Console.WriteLine(string.Format("Target: (Difficulty: {0})", this._difficulty));
Utility.WriteHex(HexToBigEndianSwap(target.ToByteArray(), 32));
this._bits = CompBits(HexToBigEndianSwap(target.ToByteArray(), 32));
var value = new BigInteger();
do
{
this._nonce++;
this._hash = this.CalculateHash();
value = new BigInteger(HexToLittleEndianSwap(this._hash));
//Console.WriteLine("Mining: " + BitConverter.ToString(this._hash));
}while (BigInteger.Compare(value, target) > 0);
Console.WriteLine("Block has been mined: ");
Utility.WriteHex(this._hash);
}
public void CompareOps()
{
long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
for (int i = 0; i < values.Length; ++i)
{
for (int j = 0; j < values.Length; ++j)
{
var a = new BigInteger(values [i]);
var b = new BigInteger(values [j]);
Assert.AreEqual(values [i].CompareTo(values [j]), a.CompareTo(b), "#a_" + i + "_" + j);
Assert.AreEqual(values [i].CompareTo(values [j]), BigInteger.Compare(a, b), "#b_" + i + "_" + j);
Assert.AreEqual(values [i] < values [j], a < b, "#c_" + i + "_" + j);
Assert.AreEqual(values [i] <= values [j], a <= b, "#d_" + i + "_" + j);
Assert.AreEqual(values [i] == values [j], a == b, "#e_" + i + "_" + j);
Assert.AreEqual(values [i] != values [j], a != b, "#f_" + i + "_" + j);
Assert.AreEqual(values [i] >= values [j], a >= b, "#g_" + i + "_" + j);
Assert.AreEqual(values [i] > values [j], a > b, "#h_" + i + "_" + j);
}
}
}
public static NumericRelationship Compare(ValueType value1, ValueType value2)
{
if (!IsNumeric(value1))
{
throw new ArgumentException("value1 is not a number.");
}
else if (!IsNumeric(value2))
{
throw new ArgumentException("value2 is not a number.");
}
// Use BigInteger as common integral type
if (IsInteger(value1) && IsInteger(value2))
{
BigInteger bigint1 = (BigInteger)value1;
BigInteger bigint2 = (BigInteger)value2;
return((NumericRelationship)BigInteger.Compare(bigint1, bigint2));
}
// At least one value is floating point; use Double.
else
{
Double dbl1 = 0;
Double dbl2 = 0;
try {
dbl1 = Convert.ToDouble(value1);
}
catch (OverflowException) {
Console.WriteLine("value1 is outside the range of a Double.");
}
try {
dbl2 = Convert.ToDouble(value2);
}
catch (OverflowException) {
Console.WriteLine("value2 is outside the range of a Double.");
}
return((NumericRelationship)dbl1.CompareTo(dbl2));
}
}
public static int Compare(HNumber left, HNumber right)
{
if (left.Sign > right.Sign)
{
return(1);
}
else if (left.Sign < right.Sign)
{
return(-1);
}
int leftTheoreticalExponent = left.Exponent + left.DigitCount;
int rightTheoreticalExponent = right.Exponent + right.DigitCount;
if (leftTheoreticalExponent == rightTheoreticalExponent)
{
return(BigInteger.Compare(left.Mantissa, right.Mantissa));
}
else
{
return((leftTheoreticalExponent * left.Sign) > (rightTheoreticalExponent * right.Sign) ? 1 : -1);
}
}
{ [STAThread] // needed for Clipboard
static void Main(string[] args)
{
/* Variables ********************************************************************/
System.Text.StringBuilder sb = new System.Text.StringBuilder();
BigInteger a, b, c, d, n;
int flag;
/* Assign Data ******************************************************************/
n = 224869951114090657; // p=675730721, q=332780417 (~55 seconds)
a = Isqrt(n) + 1;
b = 0;
c = a * a;
d = n;
Console.WriteLine("\t Basic Fermat Factoring n = {0}", n);
/* Algorithm ********************************************************************/
do
{
flag = BigInteger.Compare(c, d); // test & set flag
if (flag < 0)
{
c += a++ + a; // enlarge "c"
}
if (flag > 0)
{
d += b++ + b; // enlarge "d"
}
} while (flag != 0);
/* Output Data ******************************************************************/
Console.WriteLine("\n p = {0}\n q = {1}", a + b, a - b);
Console.WriteLine(" Press <Enter> to write to Paste Buffer");
Console.Read(); Console.Read();
sb.Append(a + b + "\n"); sb.Append(a - b + "\n"); // store in a string
Clipboard.SetText(sb.ToString()); // output to clipboard
Console.Read();
} //end of Main()
private BigInteger.Sign bignum_cmp(BigInteger a, BigInteger b)
{
return a.Compare(b);
}
public SqlInt32 Compare(SqlBigInteger other)
{
return(_value.HasValue && other._value.HasValue ? BigInteger.Compare(_value.Value, other._value.Value) : SqlInt32.Null);
}
private void ParseUnmanagedTransactions(AltruismServices svc)
{
BigInteger big10Finney = BigInteger.Parse("10000000000000000"); // 0.01 ETH
BigInteger big30Finney = BigInteger.Parse("30000000000000000"); // 0.03 ETH
BigInteger big40Finney = BigInteger.Parse("40000000000000000"); // 0.04 ETH
BigInteger bigDivision = new BigInteger(3.0);
// Get the unmanaged tx
IEnumerable <TransactionModel> toManage = svc.GetUnmanagedTransactions();
if (toManage != null && toManage.Any())
{
// Get the past contributors
List <string> contributors = svc.GetContributors();
if (contributors == null || contributors.Count < 5)
{
// I hack the third system if contributors are less than 5.
// This is to prevent people to invest at the start time more than one time to get more token with less eth
contributors.Add(ownerAddress);
}
foreach (TransactionModel model in toManage)
{
if (model.isError != 0)
{
log.Debug("TX on error : " + model.hash);
// This tx is on error => Done.
svc.SetManaged(model.hash, false, false);
continue;
}
if (model.to != ownerContract)
{
log.Debug("TX not for us : " + model.hash);
// This tx does not concern us -> Done.
svc.SetManaged(model.hash, false, false);
continue;
}
if (BigInteger.Compare(model.BigValue, big10Finney) < 0)
{
// This tx is less than 0.01 ETH. Must be on error. Do I jump here ? => Done.
log.Debug("TX not in error ? : " + model.hash);
svc.SetManaged(model.hash, false, false);
continue;
}
log.Debug("tx from : " + model.from);
if (!contributors.Contains(model.from))
{
// Hoo a new contributor. Save it.
log.Debug("New contributor added : " + model.from);
contributors.Add(model.from);
svc.AddContributor(model.from);
if (contributors.Count > 5)
{
// If there are more than 5 contributors, I remove myself (if i'm in)
contributors.Remove(ownerAddress);
}
}
if (BigInteger.Compare(model.BigValue, big40Finney) == 0)
{
// Hacked mode enabled => Done.
log.Debug("Hacked mode : " + model.hash);
svc.SetManaged(model.hash, false, true);
continue;
}
if (BigInteger.Compare(model.BigValue, big30Finney) < 0)
{
// No Altruism mode => Done.
log.Debug("No hack, no altruist : " + model.hash);
svc.SetManaged(model.hash, false, false);
continue;
}
// Altruist one \o/
// Take a third of the value
BigInteger toSend = BigInteger.Divide(model.BigValue, bigDivision);
log.Debug("The altruist send : " + model.value);
log.Debug("The winner get : " + toSend.ToString());
Random rnd = new Random();
// Pick a random number
int next = rnd.Next(contributors.Count);
// Get the winner
string winnerAddress = contributors.ElementAt(next);
log.Debug("And the winner is : " + toSend.ToString());
// Unlock my account
Task <bool> unlocked = web3.Personal.UnlockAccount.SendRequestAsync(ownerAddress, ownerPassword, new HexBigInteger(60));
if (unlocked.Result)
{
TransactionInput input = new TransactionInput();
input.From = ownerAddress;
input.To = winnerAddress;
input.Value = new HexBigInteger(toSend);
// Generate the tx
Task <string> txHash = web3.Eth.Transactions.SendTransaction.SendRequestAsync(input);
// Get the receipt tx
Task <TransactionReceipt> receipt = web3.Eth.Transactions.GetTransactionReceipt.SendRequestAsync(txHash.Result);
// Save the tx => Done.
svc.SetManaged(model.hash, true, false, txHash.Result);
log.Info("Successfully send at " + txHash.Result);
}
else
{
log.Fatal("The unlock didn't work for the tx " + model.hash);
}
}
}
}
public static int Compare(BigInteger /*!*/ self, int other)
{
return(BigInteger.Compare(self, (BigInteger)other));
}
public static int Compare(BigInteger /*!*/ self, [NotNull] BigInteger /*!*/ other)
{
return(BigInteger.Compare(self, other));
}
static bool ZPKrecieveZ(BigInteger n, BigInteger z, BigInteger x) => BigInteger.Compare(BigInteger.ModPow(x, TWO, n), z) == 0;
static bool Verify(BigInteger s, BigInteger m, BigInteger n) => BigInteger.Compare(DeformatMessage(BigInteger.ModPow(s, TWO, n), n), m) == 0;
private static unsafe void Dragon4(double value, int precision, ref NumberBuffer number)
{
// ========================================================================================================================================
// This implementation is based on the paper: https://www.cs.indiana.edu/~dyb/pubs/FP-Printing-PLDI96.pdf
// Besides the paper, some of the code and ideas are modified from http://www.ryanjuckett.com/programming/printing-floating-point-numbers/
// You must read these two materials to fully understand the code.
//
// Note: we only support fixed format input.
// ========================================================================================================================================
//
// Overview:
//
// The input double number can be represented as:
// value = f * 2^e = r / s.
//
// f: the output mantissa. Note: f is not the 52 bits mantissa of the input double number.
// e: biased exponent.
// r: numerator.
// s: denominator.
// k: value = d0.d1d2 . . . dn * 10^k
// Step 1:
// Extract meta data from the input double value.
//
// Refer to IEEE double precision floating point format.
ulong f = (ulong)(ExtractFractionAndBiasedExponent(value, out int e));
int mantissaHighBitIndex = (e == -1074) ? (int)(BigInteger.LogBase2(f)) : 52;
// Step 2:
// Estimate k. We'll verify it and fix any error later.
//
// This is an improvement of the estimation in the original paper.
// Inspired by http://www.ryanjuckett.com/programming/printing-floating-point-numbers/
//
// LOG10V2 = 0.30102999566398119521373889472449
// DRIFT_FACTOR = 0.69 = 1 - log10V2 - epsilon (a small number account for drift of floating point multiplication)
int k = (int)(Math.Ceiling(((mantissaHighBitIndex + e) * Log10V2) - DriftFactor));
// Step 3:
// Store the input double value in BigInteger format.
//
// To keep the precision, we represent the double value as r/s.
// We have several optimization based on following table in the paper.
//
// ----------------------------------------------------------------------------------------------------------
// | e >= 0 | e < 0 |
// ----------------------------------------------------------------------------------------------------------
// | f != b^(P - 1) | f = b^(P - 1) | e = min exp or f != b^(P - 1) | e > min exp and f = b^(P - 1) |
// --------------------------------------------------------------------------------------------------------------
// | r | f * b^e * 2 | f * b^(e + 1) * 2 | f * 2 | f * b * 2 |
// --------------------------------------------------------------------------------------------------------------
// | s | 2 | b * 2 | b^(-e) * 2 | b^(-e + 1) * 2 |
// --------------------------------------------------------------------------------------------------------------
//
// Note, we do not need m+ and m- because we only support fixed format input here.
// m+ and m- are used for free format input, which need to determine the exact range of values
// that would round to value when input so that we can generate the shortest correct number.digits.
//
// In our case, we just output number.digits until reaching the expected precision.
var r = new BigInteger(f);
var s = new BigInteger(0);
if (e >= 0)
{
// When f != b^(P - 1):
// r = f * b^e * 2
// s = 2
// value = r / s = f * b^e * 2 / 2 = f * b^e / 1
//
// When f = b^(P - 1):
// r = f * b^(e + 1) * 2
// s = b * 2
// value = r / s = f * b^(e + 1) * 2 / b * 2 = f * b^e / 1
//
// Therefore, we can simply say that when e >= 0:
// r = f * b^e = f * 2^e
// s = 1
r.ShiftLeft((uint)(e));
s.SetUInt64(1);
}
else
{
// When e = min exp or f != b^(P - 1):
// r = f * 2
// s = b^(-e) * 2
// value = r / s = f * 2 / b^(-e) * 2 = f / b^(-e)
//
// When e > min exp and f = b^(P - 1):
// r = f * b * 2
// s = b^(-e + 1) * 2
// value = r / s = f * b * 2 / b^(-e + 1) * 2 = f / b^(-e)
//
// Therefore, we can simply say that when e < 0:
// r = f
// s = b^(-e) = 2^(-e)
BigInteger.ShiftLeft(1, (uint)(-e), ref s);
}
// According to the paper, we should use k >= 0 instead of k > 0 here.
// However, if k = 0, both r and s won't be changed, we don't need to do any operation.
//
// Following are the Scheme code from the paper:
// --------------------------------------------------------------------------------
// (if (>= est 0)
// (fixup r (* s (exptt B est)) m+ m− est B low-ok? high-ok? )
// (let ([scale (exptt B (− est))])
// (fixup (* r scale) s (* m+ scale) (* m− scale) est B low-ok? high-ok? ))))
// --------------------------------------------------------------------------------
//
// If est is 0, (* s (exptt B est)) = s, (* r scale) = (* r (exptt B (− est)))) = r.
//
// So we just skip when k = 0.
if (k > 0)
{
BigInteger poweredValue = new BigInteger(0);
BigInteger.Pow10((uint)(k), ref poweredValue);
s.Multiply(ref poweredValue);
}
else if (k < 0)
{
BigInteger poweredValue = new BigInteger(0);
BigInteger.Pow10((uint)(-k), ref poweredValue);
r.Multiply(ref poweredValue);
}
if (BigInteger.Compare(ref r, ref s) >= 0)
{
// The estimation was incorrect. Fix the error by increasing 1.
k += 1;
}
else
{
r.Multiply10();
}
number.scale = (k - 1);
// This the prerequisite of calling BigInteger.HeuristicDivide().
BigInteger.PrepareHeuristicDivide(ref r, ref s);
// Step 4:
// Calculate number.digits.
//
// Output number.digits until reaching the last but one precision or the numerator becomes zero.
int digitsNum = 0;
int currentDigit = 0;
while (true)
{
currentDigit = (int)(BigInteger.HeuristicDivide(ref r, ref s));
if (r.IsZero() || ((digitsNum + 1) == precision))
{
break;
}
number.digits[digitsNum] = (char)('0' + currentDigit);
digitsNum++;
r.Multiply10();
}
// Step 5:
// Set the last digit.
//
// We round to the closest digit by comparing value with 0.5:
// compare( value, 0.5 )
// = compare( r / s, 0.5 )
// = compare( r, 0.5 * s)
// = compare(2 * r, s)
// = compare(r << 1, s)
r.ShiftLeft(1);
int compareResult = BigInteger.Compare(ref r, ref s);
bool isRoundDown = compareResult < 0;
// We are in the middle, round towards the even digit (i.e. IEEE rouding rules)
if (compareResult == 0)
{
isRoundDown = (currentDigit & 1) == 0;
}
if (isRoundDown)
{
number.digits[digitsNum] = (char)('0' + currentDigit);
digitsNum++;
}
else
{
char *pCurrentDigit = (number.GetDigitsPointer() + digitsNum);
// Rounding up for 9 is special.
if (currentDigit == 9)
{
// find the first non-nine prior digit
while (true)
{
// If we are at the first digit
if (pCurrentDigit == number.GetDigitsPointer())
{
// Output 1 at the next highest exponent
*pCurrentDigit = '1';
digitsNum++;
number.scale += 1;
break;
}
pCurrentDigit--;
digitsNum--;
if (*pCurrentDigit != '9')
{
// increment the digit
*pCurrentDigit += (char)(1);
digitsNum++;
break;
}
}
}
else
{
// It's simple if the digit is not 9.
*pCurrentDigit = (char)('0' + currentDigit + 1);
digitsNum++;
}
}
while (digitsNum < precision)
{
number.digits[digitsNum] = '0';
digitsNum++;
}
number.digits[precision] = '\0';
number.scale++;
number.sign = double.IsNegative(value);
}
public void Factorial_BigInteger_Tests(int x, int expected)
{
Assert.IsTrue(BigInteger.Compare(new BigInteger(expected), Function.Factorial(new BigInteger(x))) == 0);
}
private bool IsProbablePrime(BigInteger source, int certainty)
{
if (BigInteger.Compare(source, BigInteger.Add(BigInteger.One, BigInteger.One)) == 0 || BigInteger.Compare(source, BigInteger.Add(BigInteger.Add(BigInteger.One, BigInteger.One), BigInteger.One)) == 0)
{
return(true);
}
if (BigInteger.Compare(source, BigInteger.Add(BigInteger.One, BigInteger.One)) == -1 || BigInteger.Remainder(source, BigInteger.Add(BigInteger.One, BigInteger.One)) == 0)
{
return(false);
}
BigInteger d = BigInteger.Subtract(source, BigInteger.One);
int s = 0;
while (BigInteger.Compare(BigInteger.Remainder(d, BigInteger.Add(BigInteger.One, BigInteger.One)), BigInteger.Zero) == 0)
{
d = BigInteger.Divide(d, BigInteger.Add(BigInteger.One, BigInteger.One));
s += 1;
}
RandomNumberGenerator rng = RandomNumberGenerator.Create();
byte[] bytes = new byte[source.ToByteArray().Length];
BigInteger a;
for (int i = 0; i < certainty; i++)
{
do
{
rng.GetBytes(bytes);
a = new BigInteger(bytes);
}while(BigInteger.Compare(a, BigInteger.Add(BigInteger.One, BigInteger.One)) == -1 || BigInteger.Compare(a, BigInteger.Subtract(source, BigInteger.Add(BigInteger.One, BigInteger.One))) >= 0);
BigInteger x = BigInteger.ModPow(a, d, source);
if (BigInteger.Compare(x, BigInteger.One) == 0 || BigInteger.Compare(x, BigInteger.Subtract(source, BigInteger.One)) == 0)
{
continue;
}
for (int r = 1; r < s; r++)
{
x = BigInteger.ModPow(x, BigInteger.Add(BigInteger.One, BigInteger.One), source);
if (BigInteger.Compare(x, BigInteger.One) == 0)
{
return(false);
}
if (BigInteger.Compare(x, BigInteger.Subtract(source, BigInteger.One)) == 0)
{
break;
}
}
if (BigInteger.Compare(x, BigInteger.Subtract(source, BigInteger.One)) != 0)
{
return(false);
}
}
return(true);
}
