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