public void TestParseSuccessful(string from, int numerator, int denominator)
{
var expected = new BigRational(numerator, denominator);
var actual = BigRational.Parse(from);
AssertEqual(expected, actual);
}
public void UnaryMinus(string input, string expected)
{
var rational = BigRational.Parse(input);
AssertEqual(
BigRational.Parse(expected),
-rational);
}
public void DecrementTest(string input, string expected)
{
var rational = BigRational.Parse(input);
AssertEqual(
BigRational.Parse(expected),
--rational);
}
public void TestParseMixedNumber()
{
string toParse = "-1 + 1/3";
BigRational result = BigRational.Parse(toParse);
BigRational expectedValue = new BigRational(-1, 1, 3);
Assert.AreEqual(expectedValue, result);
}
public void TestParseFraction()
{
string toParse = "1/3";
BigRational result = BigRational.Parse(toParse);
BigRational expectedValue = new BigRational(0, 1, 3);
Assert.AreEqual(expectedValue, result);
}
public void TestParseWholeNumber()
{
string toParse = "3";
BigRational result = BigRational.Parse(toParse);
BigRational expectedValue = new BigRational(3, 0, 1);
Assert.AreEqual(expectedValue, result);
}
public void ConstructorDecimalTest_CompareWithParse_BothEquals()
{
//Arrange
const decimal d = 1234.1234m;
//Act
var brs = BigRational.Parse(d.ToString(CultureInfo.InvariantCulture));
var brd = new BigRational(d);
//Assert
Assert.Equal(brs, brd);
Assert.Equal(brs.ToString(), brd.ToString());
}
//Rational.
public static AlgoValue ConvertRat(ParserRuleContext context, params AlgoValue[] args)
{
//Is it a string?
if (args[0].Type == AlgoValueType.String)
{
//Return a parsed bigint.
return(new AlgoValue()
{
Type = AlgoValueType.Rational,
Value = BigRational.Parse((string)args[0].Value)
});
}
//Nah, then just cast.
return(AlgoOperators.ConvertType(context, args[0], AlgoValueType.Rational));
}
public void CompareToInteger(string left, int right, int expected)
{
var rational = BigRational.Parse(left);
Assert.AreEqual(expected, rational.CompareTo((BigInteger)right));
Assert.AreEqual(expected, rational.CompareTo((long)right));
Assert.AreEqual(expected, rational.CompareTo((int)right));
Assert.AreEqual(expected, rational.CompareTo((short)right));
Assert.AreEqual(expected, rational.CompareTo((sbyte)right));
if (right >= 0)
{
Assert.AreEqual(expected, rational.CompareTo((ulong)right));
Assert.AreEqual(expected, rational.CompareTo((uint)right));
Assert.AreEqual(expected, rational.CompareTo((ushort)right));
Assert.AreEqual(expected, rational.CompareTo((byte)right));
}
}
public void TestRoundToTickAtMidPoint(string unrounded, string tick, MidpointRoundingMode mode, string expected)
{
AssertEqual(
BigRational.RoundToTick(BigRational.Parse(unrounded), BigRational.Parse(tick), mode),
BigRational.Parse(expected));
}
public void FloorWithTick(string input, string tick, string expected)
{
AssertEqual(
BigRational.Floor(BigRational.Parse(input), BigRational.Parse(tick)),
BigRational.Parse(expected));
}
public void Floor(string rational, int rounded)
{
AssertEqual(
BigRational.Floor(BigRational.Parse(rational)),
new BigInteger(rounded));
}
public void CeilingWithTick(string input, string tick, string expected)
{
AssertEqual(
BigRational.Ceiling(BigRational.Parse(input), BigRational.Parse(tick)),
BigRational.Parse(expected));
}
public void Ceiling(string input, string expected)
{
AssertEqual(
BigRational.Ceiling(BigRational.Parse(input)),
BigRational.Parse(expected));
}
public void RoundToIntAtMidPoint(string rational, MidpointRoundingMode mode, int rounded)
{
Assert.AreEqual(
BigRational.RoundToInt(BigRational.Parse(rational), mode),
new BigInteger(rounded));
}
public void UnaryPlus(string input)
{
var rational = BigRational.Parse(input);
AssertEqual(rational, +rational);
}
public void TestParseNull()
{
Assert.Throws <ArgumentNullException>(
() => BigRational.Parse(null));
}
public void TestDivision(string left, string right, string expected)
{
AssertEqual(
BigRational.Parse(expected),
BigRational.Parse(left) / BigRational.Parse(right));
}
public void TestMultiplication(string left, string right, string expected)
{
AssertEqual(
BigRational.Parse(expected),
BigRational.Parse(left) * BigRational.Parse(right));
}
public void TestSubtraction(string left, string right, string expected)
{
AssertEqual(
BigRational.Parse(expected),
BigRational.Parse(left) - BigRational.Parse(right));
}
public void DecimalToRational(string dec, string expected)
{
AssertEqual(
BigRational.Parse(expected),
(BigRational)ParseDecimal(dec));
}
public void RationalToDecimalWithRecurringDigit(string rational, string expected)
{
Assert.AreEqual(
ParseDecimal(expected),
(decimal)BigRational.Parse(rational));
}
public void TestParseUnsuccessful(string from)
{
Assert.Throws <FormatException>(
() => BigRational.Parse(from));
}
public void TestModulus(string left, string right, string expected)
{
AssertEqual(
BigRational.Parse(expected),
BigRational.Parse(left) % BigRational.Parse(right));
}
