public void CanSubtractHugeInt() { HugeInt a = new HugeInt(456); HugeInt b = new HugeInt(123); HugeInt c = a - b; Assert.AreEqual("333", c.ToString()); }
public void CanAddHugeInt() { HugeInt a = new HugeInt(123); HugeInt b = new HugeInt(456); HugeInt c = a + b; Assert.AreEqual("579", c.ToString()); }
public void IntFindBit() { using (var a = new HugeInt("0xA0000000000000000000800000000001")) { var max = Platform.Ui(ulong.MaxValue, uint.MaxValue); Assert.AreEqual(0UL, a.FindBit(true, 0)); Assert.AreEqual(47UL, a.FindBit(true, 1)); Assert.AreEqual(47UL, a.FindBit(true, 47)); Assert.AreEqual(125UL, a.FindBit(true, 48)); Assert.AreEqual(127UL, a.FindBit(true, 126)); Assert.AreEqual(max, a.FindBit(true, 128)); Assert.AreEqual(1UL, a.FindBit(false, 0)); Assert.AreEqual(1UL, a.FindBit(false, 1)); Assert.AreEqual(9UL, a.FindBit(false, 9)); Assert.AreEqual(128UL, a.FindBit(false, 127)); Assert.AreEqual(227UL, a.FindBit(false, 227)); a.Value = ~a; Assert.AreEqual(0UL, a.FindBit(false, 0)); Assert.AreEqual(47UL, a.FindBit(false, 1)); Assert.AreEqual(47UL, a.FindBit(false, 47)); Assert.AreEqual(125UL, a.FindBit(false, 48)); Assert.AreEqual(127UL, a.FindBit(false, 126)); Assert.AreEqual(max, a.FindBit(false, 128)); Assert.AreEqual(1UL, a.FindBit(true, 0)); Assert.AreEqual(1UL, a.FindBit(true, 1)); Assert.AreEqual(9UL, a.FindBit(true, 9)); Assert.AreEqual(128UL, a.FindBit(true, 127)); Assert.AreEqual(227UL, a.FindBit(true, 227)); } }
public void RationalCompareToHugeInt() { using (var a = new HugeRational("-222509832503450298345029835740293845721/115756986668303657898962467957")) using (var b = new HugeInt("115756986668303657898962467957")) using (var c = new HugeRational("115756986668303657898962467957/1")) using (var d = new HugeInt(1922215141)) { Assert.AreEqual(-1, System.Math.Sign(a.CompareTo(d))); Assert.AreEqual(1, System.Math.Sign((-a).CompareTo(d))); Assert.AreEqual(-1, System.Math.Sign((-a).CompareTo(d + 1))); Assert.AreEqual(1, System.Math.Sign(d.CompareTo(a))); Assert.AreEqual(-1, System.Math.Sign(d.CompareTo(-a))); Assert.AreEqual(1, System.Math.Sign((d + 1).CompareTo(-a))); Assert.AreEqual(0, System.Math.Sign(b.CompareTo(c))); Assert.AreEqual(0, System.Math.Sign(c.CompareTo(b))); Assert.AreEqual(0, System.Math.Sign((-b).CompareTo(-c))); Assert.AreEqual(0, System.Math.Sign((-c).CompareTo(-b))); Assert.AreEqual(1, System.Math.Sign(b.CompareTo(c - 1))); Assert.AreEqual(1, System.Math.Sign(c.CompareTo(b - 1))); Assert.AreEqual(-1, System.Math.Sign((-b).CompareTo(1 - c))); Assert.AreEqual(-1, System.Math.Sign((-c).CompareTo(1 - b))); } }
public void IntPowerLimb() { using (var a = new HugeInt("9785412309485720938412983404349")) { a.Value = a ^ 4; Assert.AreEqual("9168884832199547717402442404668238841010784738902226284286664833331445628675177089723224507720724521226586825967635414667601", a.ToString()); } }
public void IntGetLimb() { using (var a = new HugeInt("-0x10123456789ABCDEFA123456789ABCDEF0123456789ABCDEF")) { Assert.AreEqual(Platform.Ui(0x0123456789ABCDEFUL, 0x89ABCDEFU), a.GetLimb(0)); Assert.AreEqual(Platform.Ui(0xA123456789ABCDEFUL, 0x01234567U), a.GetLimb(1)); } }
public void IntCompoundOperators() { using (var a = new HugeInt("938475092834705928347523452345")) { a.Value += 1; a.Value *= 10; Assert.AreEqual("9384750928347059283475234523460", a.ToString()); } }
public void IntAssignRational() { using (var a = new HugeRational("222509832503450298345029835740293845720/7")) using (var b = new HugeInt()) { b.SetTo(a); Assert.AreEqual("31787118929064328335004262248613406531", b.ToString()); } }
public void IntAssignCopy() { using (var a = new HugeInt("-222509832503450298345029835740293845720")) using (var b = new HugeInt()) { b.Value = a; Assert.AreEqual("-222509832503450298345029835740293845720", b.ToString()); } }
public void IntAddLimb() { using (var a = new HugeInt("222509832503450298345029835740293845720")) { var b = Platform.Ui(4288574029879874539UL, 4288574029U); a.Value = a + b; Assert.AreEqual(Platform.Select("222509832503450298349318409770173720259", "222509832503450298345029835744582419749"), a.ToString()); } }
public void RationalAssignInt() { using (var a = new HugeInt("222509832503450298345029835740293845720")) using (var b = new HugeRational("1/3")) { b.SetTo(a); Assert.AreEqual("222509832503450298345029835740293845720/1", b.ToString()); } }
public void FloatAssignInt() { using (var a = new HugeInt("222509832503450298345029835740293845720")) using (var b = new HugeFloat()) { b.SetTo(a); FloatAssert.AreEqual("222509832503450298345029835740293845720.", b); } }
public void IntPowerModHugeInt() { using (var a = new HugeInt("2835698356928736487698769283645293409781234")) using (var b = new HugeInt("3")) using (var c = new HugeInt("9786459872639458729387304958673243509870923452745892673402935742456")) { a.Value = a.PowerMod(b, c); Assert.AreEqual("5346078446724436806099093819990997994355321605000165187447171753448", a.ToString()); } }
public void IntBinomial() { using (var a = new HugeInt(HugeInt.Binomial(40, 15))) using (var b = new HugeInt("41")) using (var c = new HugeInt(HugeInt.Binomial(b, 15))) { Assert.AreEqual(HugeInt.Factorial(40).DivideExactly(HugeInt.Factorial(15) * HugeInt.Factorial(25)), a); Assert.AreEqual(a * 41 / 26, c); } }
public void IntAddHugeInt() { using (var a = new HugeInt("222509832503450298345029835740293845720")) using (var b = new HugeInt("222987435987982730594288574029879874539")) using (var c = new HugeInt()) { c.Value = a + b; Assert.AreEqual("445497268491433028939318409770173720259", c.ToString()); } }
public void IntAndHugeInt() { using (var a = new HugeInt("0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF")) using (var b = new HugeInt("0x100000000000000000123456789ABCDEFFFFFFFFFFFFFFFFF")) using (var c = new HugeInt()) { c.Value = a & b; Assert.AreEqual("100000000000000000123456789ABCDEF0123456789ABCDEF", c.ToString(16)); } }
public void IntAddProductHugeInt2() { using (var a = new HugeInt("98750293847520938457029384572093480498357")) using (var c = new HugeInt("23094582093845093574093845093485039450934")) using (var b = new HugeInt("-394580293847502987609283945873594873409587")) { var expr = c * b + a; a.Value = expr; Assert.AreEqual("-9112666988874677841199955832262586145147830205230375090322356322089362221491205901", a.ToString()); } }
public void IntApproximateSizeInBase() { using (var a = new HugeInt("2983475029834750293429834750298347502934298347502983475029342983475029834750293429834750298347502934")) { AssertEither(100, 101, a.ApproximateSizeInBase(10)); AssertEither(331, 331, a.ApproximateSizeInBase(2)); AssertEither(83, 83, a.ApproximateSizeInBase(16)); AssertEither(64, 65, a.ApproximateSizeInBase(36)); AssertEither(56, 57, a.ApproximateSizeInBase(62)); } }
public void IntToAndFromLong() { using (var a = new HugeInt()) { long b = -0x784739ABCDEF4876; a.SetTo(b); Assert.AreEqual(b.ToString(), a.ToString()); long c = a.ToLong(); Assert.AreEqual(b.ToString(), c.ToString()); } }
public void IntEqualsSignedLimb() { var source = Platform.Select("-222509832505", "-225032505"); var b = Platform.Si(-222509832504, -225032504); using (var a = new HugeInt(source)) { Assert.IsFalse(a.Equals(b + 1)); Assert.IsTrue(a.Equals(b - 1)); Assert.IsTrue((a + 1).Equals(b)); } }
public void IntEqualsLimb() { var source = Platform.Select("222509832503", "2225032503"); var b = Platform.Ui(222509832504, 2225032504); using (var a = new HugeInt(source)) { Assert.IsFalse(a.Equals(b + 1)); Assert.IsTrue(a.Equals(b - 1)); Assert.IsTrue((a + 1).Equals(b)); } }
public void IntEqualsHugeInt() { using (var a = new HugeInt("-222509832503450298345029835740293845721")) using (var b = new HugeInt("222509832503450298345029835740293845720")) { Assert.IsFalse(b.Equals(a)); Assert.IsFalse(a.Equals(b + 1)); Assert.IsTrue((a + 1).Equals(-b)); Assert.IsFalse(a.Equals(null)); Assert.IsTrue(Equals(a + 1, -b)); } }
public void IntOperatorGreaterThanDouble() { using (var a = new HugeInt("-3845721")) { double c = -543254325432; double b = -9587; Assert.IsFalse(a > b); Assert.IsTrue(b > a); Assert.IsTrue(a > c); Assert.IsFalse(c > a); } }
public void IntOperatorLessThanSignedLimb() { using (var a = new HugeInt("-3845721")) { long c = -543254325432; long b = -9587; Assert.IsTrue(a < b); Assert.IsFalse(b < a); Assert.IsFalse(a < c); Assert.IsTrue(c < a); } }
public void IntOperatorGreaterThanLimb() { using (var a = new HugeInt("3845721")) { ulong c = 5432; ulong b = 5432349587; Assert.IsFalse(a > b); Assert.IsTrue(b > a); Assert.IsTrue(a > c); Assert.IsFalse(c > a); } }
public void IntOperatorLessThanLimb() { using (var a = new HugeInt("3845721")) { ulong c = 5432; ulong b = 5432349587; Assert.IsTrue(a < b); Assert.IsFalse(b < a); Assert.IsFalse(a < c); Assert.IsTrue(c < a); } }
public void IntCompareToSignedDouble() { using (var a = new HugeInt("-222509821")) { double b = -222509820; Assert.AreEqual(-1, System.Math.Sign(a.CompareTo(b))); Assert.AreEqual(-1, System.Math.Sign(a.CompareTo(b + 1))); Assert.AreEqual(0, System.Math.Sign((a + 1).CompareTo(b))); Assert.AreEqual(0, System.Math.Sign(a.CompareTo(b - 1))); Assert.AreEqual(1, System.Math.Sign(a.CompareTo(b - 1.1))); } }
public void IntCompareToSignedLimb() { using (var a = new HugeInt("-222509821")) { var b = Platform.Si(-222509820, -222509820); Assert.AreEqual(-1, System.Math.Sign(a.CompareTo(b))); Assert.AreEqual(-1, System.Math.Sign(a.CompareTo(b + 1))); Assert.AreEqual(0, System.Math.Sign((a + 1).CompareTo(b))); Assert.AreEqual(0, System.Math.Sign(a.CompareTo(b - 1))); Assert.AreEqual(1, System.Math.Sign(a.CompareTo(b - 2))); } }
public void IntToAndFromInt() { using (var a = new HugeInt()) { int b = -0x784739AB; a.SetTo(b); Assert.AreEqual(b.ToString(), a.ToString()); long c = a.ToInt(); Assert.AreEqual(b.ToString(), c.ToString()); } }
public void IntComplementBit() { using (var a = new HugeInt("0xA0000000000000000000800000000001")) { a.ComplementBit(46); Assert.AreEqual("A0000000000000000000C00000000001", a.ToString(16)); a.ComplementBit(47); Assert.AreEqual("A0000000000000000000400000000001", a.ToString(16)); a.ComplementBit(131); Assert.AreEqual("8A0000000000000000000400000000001", a.ToString(16)); } }
public void IntOperatorGreaterThanSignedLimb() { using (var a = new HugeInt("-3845721")) { long c = -543254325432; long b = -9587; Assert.IsFalse(a > b); Assert.IsTrue(b > a); Assert.IsTrue(a > c); Assert.IsFalse(c > a); } }
public void IntToStringTruncated() { var n = string.Concat("123456789".Select(c => new string(c, 30))); using (var a = new HugeInt(n)) { Assert.AreEqual(n, a.ToString(10)); Assert.AreEqual("..." + n.Substring(n.Length - 256), a.ToString()); a.Value = -a; Assert.AreEqual("-..." + n.Substring(n.Length - 256), a.ToString()); } }
public void IntOperatorLessThanDouble() { using (var a = new HugeInt("-3845721")) { double c = -543254325432; double b = -9587; Assert.IsTrue(a < b); Assert.IsFalse(b < a); Assert.IsFalse(a < c); Assert.IsTrue(c < a); } }
public void IntHammingDistance() { using (var a = new HugeInt("0x1ABCDE08984948281360922385394772450147012613851354F03")) using (var b = new HugeInt("0x1ABCDEF8984948281360922345394772450147012613851354303")) { var max = Platform.Ui(ulong.MaxValue, uint.MaxValue); Assert.AreEqual(8U, a.HammingDistance(b)); Assert.AreEqual(8U, (-b).HammingDistance(-a)); Assert.AreEqual(max, (-a).HammingDistance(b)); Assert.AreEqual(max, b.HammingDistance(-a)); } }
public void IntCompareAbsToHugeInt() { using (var a = new HugeInt("-222509832503450298345029835740293845721")) using (var b = new HugeInt("222509832503450298345029835740293845720")) { Assert.AreEqual(1, System.Math.Sign(a.CompareAbsTo(b))); Assert.AreEqual(-1, System.Math.Sign(b.CompareAbsTo(a))); Assert.AreEqual(0, System.Math.Sign(a.CompareAbsTo(b + 1))); Assert.AreEqual(0, System.Math.Sign((a + 1).CompareAbsTo(b))); Assert.AreEqual(0, System.Math.Sign((a + 1).CompareAbsTo(-b))); } }
internal static int NumberOfLimbsUsed(this HugeInt x) { if (_value(x) == IntPtr.Zero) { return(0); } unsafe { return(((int *)_value(x).ToPointer())[1]); } }
public void IntFitsUint() { using (var a = new HugeInt(uint.MaxValue)) { Assert.IsTrue(a.FitsUint()); a.Value = a + 1; Assert.IsFalse(a.FitsUint()); a.SetTo(0); Assert.IsTrue(a.FitsUint()); a.Value = a - 1; Assert.IsFalse(a.FitsUint()); } }
public void IntFitsShort() { using (var a = new HugeInt(short.MaxValue)) { Assert.IsTrue(a.FitsShort()); a.Value = a + 1; Assert.IsFalse(a.FitsShort()); a.SetTo(short.MinValue); Assert.IsTrue(a.FitsShort()); a.Value = a - 1; Assert.IsFalse(a.FitsShort()); } }
public void IntStringAssignmentHexPrefix() { var n = "143210ABCDEF32123457ACDB324598799"; using (var a = new HugeInt("0x" + n)) { Assert.AreEqual(n, a.ToString(16)); Assert.AreEqual(n, a.ToString(16, false)); Assert.AreEqual(n.ToLower(), a.ToString(16, true)); a.SetTo("-0x" + n); Assert.AreEqual("-" + n, a.ToString(16)); } }
public void IntToAndFromUlong() { using (var a = new HugeInt()) { ulong b = 0xF84739ABCDEF4876; a.SetTo(b); Assert.AreEqual(b.ToString(), a.ToString()); a.Value = -a; ulong c = a.ToUlong(); Assert.AreEqual(b.ToString(), c.ToString()); } }
public void IntToAndFromUint() { using (var a = new HugeInt()) { uint b = 0xF84739AB; a.SetTo(b); Assert.AreEqual(b.ToString(), a.ToString()); a.Value = -a; uint c = a.ToUint(); Assert.AreEqual(b.ToString(), c.ToString()); } }
public void RationalStringConstructorHexPrefix() { using (var i = new HugeInt("362736035870515331128527330659")) { var d = i.ToString(16); var n = "143210ABCDEF32123457ACDB324598799"; using (var a = new HugeRational("0x" + n + "/0x" + d)) { Assert.AreEqual(n + "/" + d, a.ToString(16)); Assert.AreEqual(i, a.Denominator); } } }
public void IntFromString() { using (var a = new HugeInt()) { var n = "98762934876529834765234123984761"; a.SetTo(n); Assert.AreEqual(n, a.ToString()); n = "-98ABCDEF876529834765234123984761"; a.SetTo(n, 16); Assert.AreEqual(n, a.ToString(16)); } }
public void IntCompareAbsToLimb() { using (var a = new HugeInt("-222509821")) { ulong b = 222509820; Assert.AreEqual(1, System.Math.Sign(a.CompareAbsTo(b))); Assert.AreEqual(0, System.Math.Sign(a.CompareAbsTo(b + 1))); Assert.AreEqual(0, System.Math.Sign((-a).CompareAbsTo(b + 1))); Assert.AreEqual(0, System.Math.Sign((a + 1).CompareAbsTo(b))); Assert.AreEqual(1, System.Math.Sign(a.CompareAbsTo(b))); Assert.AreEqual(1, System.Math.Sign((-a).CompareAbsTo(b))); } }
public void RationalAssignInt2() { using (var a = new HugeInt("222509832503450298345029835740293845719")) using (var d = new HugeInt("115756986668303657898962467957")) using (var b = new HugeRational("1/3")) { b.SetTo(a, d); Assert.AreEqual("222509832503450298345029835740293845719/115756986668303657898962467957", b.ToString()); b.SetTo(b.Numerator - b.Denominator, b.Denominator * 5); Assert.AreEqual(a - d, b.Numerator); Assert.AreEqual(d * 5, b.Denominator); } }
public void RationalAddHugeInt() { using (var a = new HugeRational("222509832503450298345029835740293845720/115756986668303657898962467957")) using (var b = new HugeInt("222987435987982730594288574029879874539")) using (var c = new HugeRational(a + b)) { Assert.AreEqual(a.Numerator + b * a.Denominator, c.Numerator); Assert.AreEqual(a.Denominator, c.Denominator); c.Value = (b + 1) + a; Assert.AreEqual(a.Numerator + (b + 1) * a.Denominator, c.Numerator); Assert.AreEqual(a.Denominator, c.Denominator); } }
public void IntKronecker() { using (var a = new HugeInt("9288562863495827364985273645298367452")) using (var b = new HugeInt("29927402397991286489627837734179186385188296382227")) { Assert.AreEqual(-1, HugeInt.Kronecker(a, b)); Assert.AreEqual(0, HugeInt.Kronecker(a, 2)); Assert.AreEqual(-1, HugeInt.Kronecker(b, 2)); Assert.AreEqual(-1, HugeInt.Kronecker(2, b)); Assert.AreEqual(-1, HugeInt.Kronecker(b, 2U)); Assert.AreEqual(-1, HugeInt.Kronecker(2U, b)); } }
public void IntGcdExt() { using (var a = new HugeInt(12)) using (var b = new HugeInt(21)) using (var g = new HugeInt()) using (var s = new HugeInt()) using (var t = new HugeInt()) { g.Value = a.Gcd(b).SavingDiophantineMultipliersTo(s, t); Assert.AreEqual("3", g.ToString()); Assert.AreEqual("2", s.ToString()); Assert.AreEqual("-1", t.ToString()); } }
public void FloatTestAllExpressions() { var baseExpr = typeof(FloatExpression); var allExpressions = baseExpr.Assembly.GetTypes() .Where(x => baseExpr.IsAssignableFrom(x) && !x.IsAbstract) .ToList(); var one = Platform.Ui(1UL, 1U); using (var a = new HugeFloat(-9)) using (var b = new HugeFloat(4)) using (var c = new HugeInt(3)) using(var r = MpirRandom.Default()) { var expr = a + (-a * 2) * 3 * (a.Abs() * -2 + -64 + a * a) + (one * 116U) + a; VerifyPartialResult(r, expr, 44); expr = expr + a * 5 + (a+b) * (b + 1) * (b + -3) * b + (b * -a) - (b * (one * 25U)) - a + (b << 3) - ((a*b) << 1); VerifyPartialResult(r, expr, -52); expr = expr - 2 - 3U + (b - (a << 1)) + (b * b - 15U) * (b - a) * (a - 11) * (b - (one * 3U)) - (-340 - a) + ((one * 20U) - b); VerifyPartialResult(r, expr, 52); expr = expr + (-7 - 2 * a) + (28U - 4 * b) + -(a + b * 2) + (3 * a).Abs(); VerifyPartialResult(r, expr, 103); expr = 36 * (expr / a + expr / (3 * b) - a / b) - b / (a + 10) + 6; VerifyPartialResult(r, expr, -20); expr = expr + (b >> 1) + ((b / -7) + (a / (one * 7U))) * 7 + (7 / a) - ((one * 2U) / (b + 5)); VerifyPartialResult(r, expr, -32); expr = expr - (b + 13 + 64) / a / -3; VerifyPartialResult(r, expr, -35); expr = expr + b.SquareRoot() + HugeFloat.SquareRoot(25) + ((b - 2) ^ 3) - (-b).RelativeDifferenceFrom(a + 1); VerifyPartialResult(r, expr, -19); expr = expr - (a / 4).Floor() + (b / 3).Ceiling() - (a / b).Truncate(); VerifyPartialResult(r, expr, -12); expr = expr + (r.GetFloatBits(64) * 10).Ceiling(); VerifyPartialResult(r, expr, -10); //float random generation seems to give different results in Win32 and Win64. Thus, we're having to adjust the results for Win32. expr = expr + (r.GetFloatLimbsChunky(128 / MpirSettings.BITS_PER_LIMB, 256 / MpirSettings.BITS_PER_LIMB) << 233 >> Platform.Ui(0, 480)).Ceiling(); VerifyPartialResult(r, expr, -6); expr = expr + (r.GetFloat() * 10).Floor() - Platform.Ui(0, 3); VerifyPartialResult(r, expr, -2); expr = expr + (r.GetFloatChunky(3) << 101 >> Platform.Ui(177, 23)).Truncate(); VerifyPartialResult(r, expr, 13); MarkExpressionsUsed(allExpressions, expr); } Assert.AreEqual(0, allExpressions.Count, "Expression types not exercised: " + string.Join("", allExpressions.Select(x => Environment.NewLine + x.Name).OrderBy(x => x))); }
public void IntIsPerfectSquare() { using (var a = new HugeInt("8984948281360922385394772450147012613851354303")) using (var b = new HugeInt()) { b.Value = a * a * a; Assert.IsFalse(b.IsPerfectSquare()); b.Value = a * a; Assert.IsTrue(b.IsPerfectSquare()); b.Value = a * a * a + 1; Assert.IsFalse(b.IsPerfectSquare()); b.Value = a * a + 1; Assert.IsFalse(b.IsPerfectSquare()); } }
public void IntAllocatedSize() { using (var a = new HugeInt("-0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF")) { var allocated = a.AllocatedSize; Assert.IsTrue(allocated >= (int)a.Size()); a.Value = -a; Assert.AreEqual(allocated, a.AllocatedSize); Assert.AreEqual(192U / MpirSettings.BITS_PER_LIMB + 1, a.Size()); a.Value >>= 64; Assert.AreEqual(128U / MpirSettings.BITS_PER_LIMB + 1, a.Size()); Assert.AreEqual(allocated, a.AllocatedSize); } }
public void IntSwap() { var strA = "-222509832503450298345029835740293845720"; var strB = "2039847290878794872059384789347534534"; using (var a = new HugeInt(strA)) using (var b = new HugeInt(strB)) { var aValue = a._value(); var bValue = b._value(); a.Swap(b); Assert.AreEqual(aValue, a._value()); Assert.AreEqual(bValue, b._value()); Assert.AreEqual(strA, b.ToString()); Assert.AreEqual(strB, a.ToString()); } }
public void IntTestAllExpressions() { var baseExpr = typeof(IntegerExpression); var allExpressions = baseExpr.Assembly.GetTypes() .Where(x => baseExpr.IsAssignableFrom(x) && !x.IsAbstract) .ToList(); var one = Platform.Ui(1, 1); using (var a = new HugeInt(-9L)) using (var b = new HugeInt(4L)) using (var c = new HugeRational(6, 7)) using (var r = MpirRandom.Default()) { var expr = a + (-a * 2) * 3 * (a.Abs() * -2 + -64 + a * a) + (one * 116U) + a; VerifyPartialResult(r, expr, 44); expr = expr + a * 5 + (a+b) * (b + 1) * (b + -3) * b + (b * -a) - (b * (one * 25U)) - a + (b << 3) - ((a*b) << 1); VerifyPartialResult(r, expr, -52); expr = expr - 2 - 3U + (b - (a << 1)) + (b * b - (one * 15U)) * (b - a) * (a - 11) * (b - 3U) - (-340 - a) + ((one * 20U) - b); VerifyPartialResult(r, expr, 52); expr = expr + (-7 - 2 * a) + (28U - 4 * b) + -(a + b * 2) + (3 * a).Abs(); VerifyPartialResult(r, expr, 103); expr = expr / a + expr / (3 * b) - a / b - b / (a + 10) + a % b - (3 * b) % a + a % (2 * b) - (12 * b) % (-5 * a) + (a * 4 / 8).Rounding(RoundingModes.Floor) + (b * 3 % 7).Rounding(RoundingModes.Ceiling); VerifyPartialResult(r, expr, -20); expr = expr - (a * 5).DivideExactly(a) + (b * 7 * 5432198).DivideExactly(5432198) + (b >> 1); VerifyPartialResult(r, expr, 5); expr = expr + (b ^ 3) + a.PowerMod(2, b) + (a + 6).PowerMod(b - 1, b * 5) + (a * a * a).Root(3) + (b * b).SquareRoot(); VerifyPartialResult(r, expr, 78); expr = expr + ((b + 1) & -a) + (b | -a) - (b ^ a) + ~b; VerifyPartialResult(r, expr, 100); expr = expr + r.GetInt(b + 1) + r.GetIntBits(3) + r.GetIntBitsChunky(3) + (b * 2).NextPrimeCandidate(r) - b.Gcd(a - 1); VerifyPartialResult(r, expr, 124); expr = expr - a.Lcm(b * 3) - (b + 1).Lcm(2) - (-a).Invert(b + 7) - (1-a).RemoveFactors(b / 2) - HugeInt.Power(2, 3) - HugeInt.Factorial(4); VerifyPartialResult(r, expr, 36); expr = expr - HugeInt.Primorial(6) + HugeInt.Binomial(4, 2) + HugeInt.Binomial(b, 3) + HugeInt.Fibonacci(6) + HugeInt.Lucas(7); VerifyPartialResult(r, expr, 53); expr = expr + c.Numerator + c.Denominator; VerifyPartialResult(r, expr, 66); MarkExpressionsUsed(allExpressions, expr); } Assert.AreEqual(0, allExpressions.Count, "Expression types not exercised: " + string.Join("", allExpressions.Select(x => Environment.NewLine + x.Name).OrderBy(x => x))); }
public void IntFibonacci() { using (var a = new HugeInt(HugeInt.Fibonacci(300))) using (var b = new HugeInt()) using (var c = new HugeInt(HugeInt.Fibonacci(300).SavingPreviousTo(b))) using (var even = new HugeInt("1")) using (var odd = new HugeInt("1")) { for(var i = 3; i <= 299; i += 2) { odd.Value += even; even.Value += odd; } Assert.AreEqual(even, a); Assert.AreEqual(odd, b); Assert.AreEqual(even, c); } }
public void IntFactorial() { using (var a = new HugeInt(HugeInt.Factorial(30))) using (var b = new HugeInt("50")) using (var c = new HugeInt("70")) using (var x = new HugeInt()) { for (x.Value = b - 2; x > 0; x.Value -= 2) b.Value *= x; for (x.Value = c - 3; x > 0; x.Value -= 3) c.Value *= x; Assert.AreEqual("265252859812191058636308480000000", a.ToString()); Assert.AreEqual(b, HugeInt.Factorial(50, 2)); Assert.AreEqual(c, HugeInt.Factorial(70, 3)); } }