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 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 FloatCompareToNonExpression()
{
using (var a = new HugeFloat("-222509832503450298345029835740293845721.57898962467957"))
{
a.CompareTo("abc");
}
}
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());
}
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);
}
}
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 RationalAssignFloat()
{
using (var a = new HugeFloat("9363833093638312937.25"))
using (var b = new HugeRational())
{
b.SetTo(a);
Assert.AreEqual("37455332374553251749/4", b.ToString());
}
}
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 RationalConstructorFromFloatExpression()
{
using (var a = new HugeFloat("2340958273409578234.25"))
using (var b = new HugeRational(a + 1))
{
Assert.AreEqual("9363833093638312941/4", b.ToString());
}
}
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 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 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);
}