public void FloatFromInvalidString() { using (var a = new HugeFloat()) { a.SetTo("12345A"); } }
public void FloatConstructorFromDoubleNegative() { using (var a = new HugeFloat(-123456789123456.75)) { FloatAssert.AreEqual("-123456789123456.75", a); } }
public void FloatCompareToNonExpression() { using (var a = new HugeFloat("-222509832503450298345029835740293845721.57898962467957")) { a.CompareTo("abc"); } }
public void CompareToCalculatedToDefaultPrecision() { using (var a = new HugeFloat(1)) using (var b = new HugeFloat(13)) using (var c = new HugeFloat("12345234589234059823475029384572323")) using (var d = HugeFloat.Allocate(256)) { ShiftLeftBy62(c); d.Value = c; var expr = a / b + c; Assert.AreEqual(0, c.CompareTo(expr)); //to precision of c Assert.AreEqual(0, expr.CompareTo(c)); //to precision of c Assert.IsFalse(expr > c); //to precision of c Assert.IsTrue(c == expr); //to precision of c Assert.AreEqual(0, (c + 0).CompareTo(expr)); //to default precision Assert.AreEqual(0, expr.CompareTo(c + 0)); //to default precision Assert.IsFalse(expr > c + 0); //to default precision Assert.IsTrue(c + 0 == expr); //to default precision HugeFloat.DefaultPrecision = 256; Assert.AreEqual(0, c.CompareTo(expr)); //to precision of c Assert.AreEqual(0, expr.CompareTo(c)); //to precision of c Assert.IsTrue(c == expr); //to precision of c Assert.IsFalse(expr > c); //to precision of c Assert.AreEqual(-1, d.CompareTo(expr)); //to precision of d Assert.AreEqual(1, expr.CompareTo(d)); //to precision of d Assert.IsFalse(d == expr); //to precision of d Assert.IsTrue(expr > d); //to precision of d Assert.AreEqual(-1, (c * 1).CompareTo(expr)); //to default precision Assert.AreEqual(1, expr.CompareTo(c + 0)); //to default precision Assert.IsFalse(c + 0 == expr); //to default precision Assert.IsTrue(expr > c + 0); //to default precision HugeFloat.DefaultPrecision = 128; } }
public void FloatEqualsNonExpression() { using (var a = new HugeFloat("-2225098325034502983450.29835740293845721")) { Assert.IsFalse(a.Equals("abc")); } }
public void FloatSettingPrecisionOverAllocated() { using (var a = new HugeFloat()) { a.Precision++; } }
public void FloatSetPrecision() { using (var a = new HugeFloat(1)) using (var b = new HugeFloat()) { a.Value = a / 3; b.Value = a; Assert.AreEqual(128UL, a._allocatedPrecision); Assert.AreEqual(128UL, a.Precision); Assert.AreEqual("0.3333333333333333333333333333333333333333@0", a.ToString()); a.Precision = 64; Assert.AreEqual(128UL, a._allocatedPrecision); Assert.AreEqual(64UL, a.Precision); Assert.AreEqual("0.333333333333333333333@0", a.ToString()); Assert.AreEqual(a, b); a.Precision = 128; Assert.AreEqual("0.3333333333333333333333333333333333333333@0", a.ToString()); a.Precision = 64; a.SetTo(1); a.Value = a / 3; Assert.AreNotEqual(a, b); Assert.AreEqual("0.333333333333333333333@0", a.ToString()); a.Precision = 128; Assert.AreNotEqual(a, b); } }
public void FloatAssignDouble() { using (var a = new HugeFloat()) { a.SetTo(22250983250345.125); Assert.IsTrue(a == 22250983250345.125); } }
public void FloatConstructorFromIntExpression() { using (var a = new HugeInt("2340958273409578234095823045723490587")) using (var b = new HugeFloat(a + 1)) { FloatAssert.AreEqual("2340958273409578234095823045723490588.", b); } }
public void FloatPower() { using (var a = new HugeFloat("-902340.945098345")) { a.Value = a ^ 5; FloatAssert.AreEqual("-598209523815275040074985233466.4619735146023546465747916785912044", a); } }
public void RationalConstructorFromFloatExpression() { using (var a = new HugeFloat("2340958273409578234.25")) using (var b = new HugeRational(a + 1)) { Assert.AreEqual("9363833093638312941/4", b.ToString()); } }
public void FloatConstructorFromExpression() { using (var a = new HugeFloat("29340273582305894258424059.2345293574")) using (var b = new HugeFloat(a + 1)) { Assert.AreEqual(a + 1, b); } }
public void FloatSqrt() { using (var a = new HugeFloat("9023404035982394058230584.9434590783455098345")) { a.Value = a.SquareRoot(); FloatAssert.AreEqual("3003898140081.0504277325488426221152130989784856425363142756", a); } }
public void FloatAssignDouble() { using(var a = new HugeFloat()) { a.SetTo(22250983250345.125); Assert.IsTrue(a == 22250983250345.125); } }
public void FloatAssignRational() { using (var a = new HugeRational(1, 3)) using (var b = new HugeFloat()) { b.SetTo(a); FloatAssert.AreEqual(".33333333333333333333333333333333333333333333333333333333333333333333333333333333333", b); } }
public void FloatAssignInt() { using (var a = new HugeInt("222509832503450298345029835740293845720")) using (var b = new HugeFloat()) { b.SetTo(a); FloatAssert.AreEqual("222509832503450298345029835740293845720.", b); } }
public void FloatDispose() { var a = new HugeFloat(); a.Dispose(); Assert.AreEqual(0, a.NumberOfLimbsUsed()); Assert.AreEqual(IntPtr.Zero, a.Limbs()); }
private static void ShiftLeftBy62(HugeFloat c) { #if WIN64 c.Value *= 0x4000000000000000L; #else c.Value *= 0x80000000; c.Value *= 0x80000000; #endif }
public void RationalAssignFloat2() { using(var a = new HugeFloat("222509832503450298342455029.125")) using(var b = new HugeRational("1/3")) { b.SetTo(a); Assert.AreEqual("1780078660027602386739640233/8", b.ToString()); } }
public void FloatStringConstructorHexExponentDecimal() { var n = "143210ABCDEF32123457ACDB324.59879@10"; using (var a = new HugeFloat(n, 16)) { Assert.AreEqual("0.143210ABCDEF32123457ACDB32459879@37", a.ToString(16, false, true)); } }
public void RationalAssignFloat() { using (var a = new HugeFloat("9363833093638312937.25")) using (var b = new HugeRational()) { b.SetTo(a); Assert.AreEqual("37455332374553251749/4", b.ToString()); } }
public void FloatDivideLimb() { using (var a = new HugeFloat("1157569866683036578989624354347957.394580293847")) { var b = Platform.Ui(5931690917503076532, 3931690917); a.Value = a / b; FloatAssert.AreEqual(Platform.Select("195150064759326.89956625512472902395197480398952074748799190", "294420362922703412240180.51527521877035185414779643015361677"), a); } }
public void FloatDivideHugeFloat() { using (var a = new HugeFloat("1157569866683036578989624354347957.394580293847")) using (var b = new HugeFloat("593169091750307653294.549782395235784")) { a.Value = a / b; FloatAssert.AreEqual("1951500647593.2689953514865540344827449639493356367018584357", a); } }
public void FloatDivideLimbBy() { using (var a = new HugeFloat("115756986.6683039458029384723405203984572")) { var b = Platform.Ui(5931690917503076532, 3931690917); a.Value = b / a; FloatAssert.AreEqual(Platform.Select("51242616866.833708737257760720580856722540469109813901673959", "33.96504202606854669329208733080818384500235983519843605"), a); } }
public void FloatDivideSignedLimb() { using (var a = new HugeFloat("1157569866683036578989624354347957.394580293847")) { var b = Platform.Si(-5931690917503076532, -1288574029); a.Value = a / b; FloatAssert.AreEqual(Platform.Select("-195150064759326.89956625512472902395197480398952074748799190", "-898334003814565921993779.6482998629445295873233838084750038"), a); } }
public void FloatGetHashCodeTest() { using (var a = new HugeFloat("-2225098325034502983450298357.40293845721")) { Assert.AreNotEqual(0, a.GetHashCode()); Assert.AreEqual(a.GetHashCode(), (a + 0).GetHashCode()); Assert.AreNotEqual(a.GetHashCode(), (-a).GetHashCode()); } }
public void FloatDivideSignedLimbBy() { using (var a = new HugeFloat("115756986.6683039458029384723405203984572")) { var b = Platform.Si(-5931690917503076532, -1288574029); a.Value = b / a; FloatAssert.AreEqual(Platform.Select("-51242616866.833708737257760720580856722540469109813901673959", "-11.13171710915684632967551560098368670502676808644707224"), a); } }
public void FloatSign() { using (var a = new HugeFloat("-22250983250345029834.502983574029384572134354")) { Assert.AreEqual(-1, a.Sign()); Assert.AreEqual(1, (-a).Sign()); Assert.AreEqual(0, (a - a).Sign()); } }
public void RationalAssignFloat2() { using (var a = new HugeFloat("222509832503450298342455029.125")) using (var b = new HugeRational("1/3")) { b.SetTo(a); Assert.AreEqual("1780078660027602386739640233/8", b.ToString()); } }
public void FloatFromLong() { using (var a = new HugeFloat()) { var b = Platform.Si(-0x784739ABCDEF4876, -0x784739AB); a.SetTo(b); FloatAssert.AreEqual(b + ".", a); } }
public void FloatToStringDecimal() { var n = "-234293847562.98357462983476598345623984756"; using (var a = new HugeFloat(n)) { FloatAssert.AreEqual(n, a); } }
public void FloatIsInteger() { using (var a = new HugeFloat("-233454059287409285742345.125")) { Assert.IsFalse(a.IsInteger()); a.Value = a * 8; Assert.IsTrue(a.IsInteger()); } }
public void FloatAssignCopy() { var s = "-1.22250983250345029834502983574029384572"; using (var a = new HugeFloat(s)) using (var b = new HugeFloat()) { b.Value = a; FloatAssert.AreEqual(s, b); } }
public void FloatCompareToHugeFloat() { using (var a = new HugeFloat("-22250983250345029834503.9835740293845721345345354")) using (var b = new HugeFloat("22250983250345029834502.9835740293845721345345354")) { Assert.AreEqual(1, Math.Sign(b.CompareTo(a))); Assert.AreEqual(-1,Math.Sign(a.CompareTo(b + 1))); Assert.AreEqual(0, Math.Sign((a + 1).CompareTo(-b))); Assert.AreEqual(1, Math.Sign(a.CompareTo(null))); } }
public void FloatAddHugeFloat() { using (var a = new HugeFloat("22250983250345029834502983.5740293845720")) using (var b = new HugeFloat("2229874359879827.30594288574029879874539")) using (var c = new HugeFloat(a + b)) { FloatAssert.AreEqual("22250983252574904194382810.87997227031229879874539", c); c.Value = a + (b + 1); FloatAssert.AreEqual("22250983252574904194382811.87997227031229879874539", c); } }
public void FloatCompareToExpression() { using (var a = new HugeFloat("-22250983250345029834503.9835740293845721345345354")) using (var b = new HugeFloat("22250983250345029834502.9835740293845721345345354")) { Assert.AreEqual(1, Math.Sign(((IComparable<FloatExpression>)b).CompareTo(a))); Assert.AreEqual(-1,Math.Sign(((IComparable<FloatExpression>)a).CompareTo(b))); Assert.AreEqual(1, Math.Sign(((IComparable<FloatExpression>)a).CompareTo(null))); Assert.AreEqual(0, Math.Sign(((IComparable<FloatExpression>)(a + 1)).CompareTo(-b))); } }
public void FloatTruncate() { using(var a = new HugeFloat("-9023409872309847509847.9385345098345")) using(var b = new HugeFloat()) { b.Value = a.Truncate(); FloatAssert.AreEqual("-9023409872309847509847", b); b.Value = (-a).Truncate(); FloatAssert.AreEqual("9023409872309847509847", b); } }
public void FloatCompareToLimb() { using (var a = new HugeFloat(Platform.Select("-22250982876541", "-222509821"))) { var b = Platform.Ui(22250982876540, 222509820); Assert.AreEqual(-1,Math.Sign(a.CompareTo(b))); Assert.AreEqual(-1,Math.Sign(a.CompareTo(b + 1))); Assert.AreEqual(0, Math.Sign((-(a + 1)).CompareTo(b))); Assert.AreEqual(0, Math.Sign((-a).CompareTo(b + 1))); Assert.AreEqual(1, Math.Sign((-a).CompareTo(b))); } }
public void FloatAddLimb() { using (var a = new HugeFloat("22250983250345029834502983.5740293845720")) using (var c = new HugeFloat()) { var b = Platform.Ui(4288574029879874539UL, 4288574029U); var expected = Platform.Select("22250987538919059714377522.5740293845720", "22250983250345034123077012.5740293845720"); c.Value = a + b; FloatAssert.AreEqual(expected, c); c.Value = b + a; FloatAssert.AreEqual(expected, c); } }
public void FloatAddSignedLimb() { using (var a = new HugeFloat("22250983250345029834502983.5740293845720")) using (var c = new HugeFloat()) { var b = Platform.Si(-4288574029879874539, -1288574029); var expected = Platform.Select("22250978961770999954628444.5740293845720", "22250983250345028545928954.5740293845720"); c.Value = a + b; FloatAssert.AreEqual(expected, c); c.Value = b + a; FloatAssert.AreEqual(expected, c); } }
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 FloatInputOutputStr62() { using(var a = new HugeFloat("10123456789ABCDEF012345.6789ABCDE", 16)) using(var b = HugeFloat.Allocate(12800)) using(var ms = new MemoryStream()) { a.Reallocate(12800); a.Value = a ^ 100; using(var writer = new StreamWriter(ms, Encoding.UTF8, 1024, true)) a.Write(writer, 62, 0, false, false); ms.Position = 0; using(var reader = new StreamReader(ms, Encoding.UTF8, false, 1024, true)) b.Read(reader, 62, false); Assert.AreEqual(a.ToString(62), b.ToString(62)); Assert.AreEqual(ms.Length, ms.Position); Assert.AreEqual((char)0xFEFF + a.ToString(62), Encoding.UTF8.GetString(ms.ToArray())); } }
public void FloatSqrtLimb() { using(var a = new HugeFloat()) { var source = Platform.Ui(2540928740928357403U, 254092874U); var expected = Platform.Select("1594029090.3645257511790832426801336140951314995369452070983", "15940.290900733273631771121246631364490515292845317661757570"); a.Value = HugeFloat.SquareRoot(source); FloatAssert.AreEqual(expected, a); } }
public void FloatMultiplyBySignedLimb() { using (var a = new HugeFloat("9023409872309847509847.9385345098345")) using (var c = new HugeFloat()) { var b = Platform.Si(-7390538260286101342, -1500450271); var expected = Platform.Select("66687855899549252270180812533806115649174.746962647899", "13539177788251386092120014542896.6240276901495"); c.Value = a * b; FloatAssert.AreEqual("-" + expected, c); c.Value = b * -a; FloatAssert.AreEqual(expected, c); } }
public void FloatNegate() { using(var a = new HugeFloat("9023409872309847509847.9385345098345")) { a.Value = -a; FloatAssert.AreEqual("-9023409872309847509847.9385345098345", a); a.Value = -a; FloatAssert.AreEqual("9023409872309847509847.9385345098345", a); } }
public void FloatPower() { using(var a = new HugeFloat("-902340.945098345")) { a.Value = a ^ 5; FloatAssert.AreEqual("-598209523815275040074985233466.4619735146023546465747916785912044", a); } }
public void FloatShiftRight() { using (var a = new HugeFloat("-12345700987ABA24523094817607.EF", 16)) using (var e = new HugeFloat("-12345700987ABA245230948.17607EF", 16)) { uint b = 20; a.Value = a >> b; Assert.AreEqual(e, a); } }
public void FloatSubtractSignedLimb() { using(var a = new HugeFloat("22250983250345029834502983.5740293845720")) using(var c = new HugeFloat()) { var b = Platform.Si(-4288574029879874539, -1885740298); var expected = Platform.Select("22250987538919059714377522.5740293845720", "22250983250345031720243281.5740293845720"); c.Value = a - b; FloatAssert.AreEqual(expected, c); c.Value = b - a; FloatAssert.AreEqual("-" + expected, c); } }
public void FloatSubtractHugeFloat() { using (var a = new HugeFloat("22250983250345029834502983.5740293845720")) using (var b = new HugeFloat("2229874359879827.30594288574029879874539")) using (var c = new HugeFloat(a - b)) { FloatAssert.AreEqual("22250983248115155474623156.26808649883170120125461", c); c.Value = b - (a + 1); FloatAssert.AreEqual("-22250983248115155474623157.26808649883170120125461", c); } }
public void FloatSubtractLimb() { using(var a = new HugeFloat("22250983250345029834502983.5740293845720")) using(var c = new HugeFloat()) { var b = Platform.Ui(4288574029879874539UL, 2885740298U); var expected = Platform.Select("22250978961770999954628444.5740293845720", "22250983250345026948762685.5740293845720"); c.Value = a - b; FloatAssert.AreEqual(expected, c); c.Value = b - a; FloatAssert.AreEqual("-" + expected, c); } }
public void FloatSqrt() { using(var a = new HugeFloat("9023404035982394058230584.9434590783455098345")) { a.Value = a.SquareRoot(); FloatAssert.AreEqual("3003898140081.0504277325488426221152130989784856425363142756", a); } }
public static void AreEqual(string expected, HugeFloat actual) { var actualStr = actual.ToString(); if(expected[0] == '-') { Assert.AreEqual(expected[0], actualStr[0]); actualStr = actualStr.TrimStart('-'); expected = expected.TrimStart('-'); } var exponent = expected.IndexOf('.'); if(exponent < 0) exponent = expected.Length; expected = expected.Replace(".", ""); var exponentStr = "@" + exponent; Assert.IsTrue(actualStr.StartsWith("0.")); actualStr = actualStr.Substring(2); Assert.IsTrue(actualStr.EndsWith(exponentStr)); actualStr = actualStr.Substring(0, actualStr.Length - exponentStr.Length); if (expected.Length > actualStr.Length) { var roundedUp = expected[actualStr.Length] >= '5'; expected = expected.Substring(0, actualStr.Length); if(roundedUp) { using (var a = new HugeInt(expected)) { a.Value += 1; expected = a.ToString(10); } } } Assert.AreEqual(expected, actualStr); }