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 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 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 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 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 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 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 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 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));
}
}
