public override bool Equals(BigNum other)
{
// assuming both rationals are normalised, just check for equality of num and dec
BigRational rat = Ensure(other);
return(_num.Equals(rat._num) && _den.Equals(rat._den));
}
public override int CompareTo(BigNum other)
{
BigRational rat = Ensure(other);
// I think the best way to do this is just to evaluate the Rational...
return(Evaluate().CompareTo(rat.Evaluate()));
}
public static BigNum Tan(BigNum theta)
{
// using Tan(x) == Sin(x) / Cos(x)
BigNum sine = Sin(theta);
BigNum cosi = Cos(theta);
return(sine / cosi);
}
private static void TestStore(Double value)
{
Double ai = value;
BigNum ab = ai; // implicit conversion
String bi = ai.ToString();
String bn = ab.ToString();
Console.WriteLine("{0,18} : {1,18} -> {2}", ai, bn, bi == bn ? "Pass" : "Fail");
}
/// <summary>Always returns a BigInt representation of the input. If the input is a BigInt it is simply returned.</summary>
private BigInt E(BigNum other)
{
BigInt o = other as BigInt;
if (o != null)
{
return(o);
}
return((BigInt)Factory.Create(other));
}
public static BigNum Sin(BigNum theta)
{
BigNumFactory f = theta.Factory;
// calculate sine using the taylor series, the infinite sum of x^r/r! but to n iterations
BigNum retVal = f.Zero;
// first, reduce this to between 0 and 2Pi
if (theta > f.TwoPi || theta < f.Zero)
{
theta = theta % f.TwoPi;
}
Boolean subtract = false;
// using bignums for sine computation is too heavy. It's faster (and just as accurate) to use Doubles
#if DoubleTrig
Double thetaDbl = Double.Parse(theta.ToString(), Cult.InvariantCulture);
for (Int32 r = 0; r < 20; r++) // 20 iterations is enough, any more just yields inaccurate less-significant digits
{
Double xPowerR = Math.Pow(thetaDbl, 2 * r + 1);
Double factori = BigMath.Factorial((double)(2 * r + 1));
Double element = xPowerR / factori;
Double addThis = subtract ? -element : element;
BigNum addThisBig = f.Create(addThis);
retVal += addThisBig;
subtract = !subtract;
}
#else
for (Int32 r = 0; r < _iterations; r++)
{
BigNum xPowerR = theta.Power(2 * r + 1);
BigNum factori = Factorial(2 * r + 1);
BigNum element = xPowerR / factori;
retVal += subtract ? -element : element;
subtract = !subtract;
}
#endif
// TODO: This calculation generates useless and inaccurate trailing digits that must be truncated
// so truncate them, when I figure out how many digits can be removed
retVal.Truncate(10);
return(retVal);
}
private static void EvaluateExpression(String expression)
{
try {
Expression expr = new Expression(expression, Factory);
BigNum ret = expr.Evaluate(_symbols);
Console.WriteLine("Result: " + ret.ToString());
} catch (Exception ex) {
PrintException(ex);
}
}
public override bool Equals(BigNum other)
{
// if( !other.Floor().Equals( other ) ) { // check it's an integer
//
// return false;
// }
BigInt o = E(other);
return(_v.Equals(o._v));
}
protected override BigNum Modulo(BigNum divisor)
{
if (divisor.IsZero)
{
throw new DivideByZeroException("Cannot divide by zero");
}
BigInt o = E(divisor);
return(new BigInt(_v % o._v));
}
private static BigRational Ensure(BigNum number)
{
BigRational rational = number as BigRational;
if (rational != null)
{
return(rational);
}
return((BigRational)BigRationalFactory.Instance.Create(number));
}
/////////////////////////////////////////
public virtual Boolean TryParse(String value, out BigNum number)
{
try {
number = Create(value);
} catch (FormatException) {
number = null;
return(false);
}
return(true);
}
private static void TestCompare(Double a, Double b)
{
String di = a.CompareTo(b).ToString() + ' ' + b.CompareTo(a).ToString();
BigNum na = a;
BigNum nb = b;
String ni = na.CompareTo(nb).ToString() + ' ' + nb.CompareTo(na).ToString();
Console.WriteLine("{0,18} comp {1,18} = {2,18} : {3,18} -> {4}", a, b, di, ni, di == ni ? "Pass" : "Fail");
}
public override Int32 CompareTo(BigNum other)
{
BigFloat o = other as BigFloat;
if (o == null)
{
o = (BigFloat)Factory.Create(other);
}
return(CompareTo(o));
}
/// <summary>Computes Euler's number raised to the specified exponent</summary>
public static BigNum Exp(BigNum exponent)
{
const int iterations = 25;
// E^x ~= sum(int i = 0 to inf, x^i/i!)
// ~= 1 + x + x^2/2! + x^3/3! + etc
BigNum ret = exponent.Factory.Unity;
ret += exponent;
for (int i = 2; i < iterations; i++)
{
BigNum numerator = exponent.Power(i);
BigNum denominat = exponent.Factory.Create(Factorial(i));
BigNum addThis = numerator / denominat;
ret += addThis;
}
return(ret);
}
public override BigNum Create(BigNum value)
{
throw new NotImplementedException();
}
public static Boolean IsInteger(BigNum x)
{
return(x.Floor() == x);
}
public static BigNum Pow(BigNum num, Int32 exponent)
{
return(num.Power(exponent));
}
public static BigNum Cot(BigNum theta)
{
return(Tan(theta).Power(-1));
}
public static BigNum Min(BigNum x, BigNum y)
{
return(x > y ? y : x);
}
public static BigNum Csc(BigNum theta)
{
return(Sin(theta).Power(-1));
}
public static BigNum Sec(BigNum theta)
{
return(Cos(theta).Power(-1));
}
public static BigNum Max(BigNum x, BigNum y)
{
return(x < y ? y : x);
}
protected override BigNum Add(BigNum other)
{
BigInt o = E(other);
return(new BigInt(_v + o._v));
}
protected override BigNum Multiply(BigNum multiplicand)
{
BigInt o = E(multiplicand);
return(new BigInt(_v * o._v));
}
public static BigNum Ceiling(BigNum num)
{
return(num.Ceiling());
}
public static BigNum Floor(BigNum num)
{
return(num.Floor());
}
/// <summary>Computes the Logarithm of x for base b. So log10(100) is Log(10,100)</summary>
public static BigNum Log(BigNum x, BigNum b)
{
return(Log(x) / Log(b));
}
public static BigNum Abs(BigNum num)
{
return(num.Absolute());
}
protected override BigNum Divide(BigNum divisor)
{
BigInt o = E(divisor);
return(new BigInt(_v / o._v));
}
public Variable(String name, BigNum value)
{
Name = name;
Value = value;
}
