public void Adding_0_to_a_rational_returns_the_same_value(Rational x)
{
Assert.Equal(x, x + Rational.Zero);
Assert.Equal(x, Rational.Zero + x);
Assert.Equal(x, Rational.Add(x, Rational.Zero));
Assert.Equal(x, Rational.Add(Rational.Zero, x));
}
static void Main(string[] args)
{
Console.WriteLine("Enter two integers (numerator and denominator): ");
int num = int.Parse(Console.ReadLine());
int denom = int.Parse(Console.ReadLine());
var rationalOne = new Rational();
rationalOne.SetFraction(num, denom);
Console.WriteLine("Enter two more integers: ");
num = int.Parse(Console.ReadLine());
denom = int.Parse(Console.ReadLine());
var rationalTwo = new Rational();
rationalTwo.SetFraction(num, denom);
Console.WriteLine("\nHow many digits to you want to display in past the decimal?");
int digits = int.Parse(Console.ReadLine());
Console.WriteLine("\nReduced first fraction: ");
Console.WriteLine($"{rationalOne.ToRationalString()}");
Console.WriteLine("Reduced second fraction: ");
Console.WriteLine($"{rationalTwo.ToRationalString()}");
Console.WriteLine($"Added rational numbers = {Rational.Add(rationalOne.ToFloat(), rationalTwo.ToFloat())}");
Console.WriteLine($"Subtracted rational numbers = {Rational.Subtract(rationalOne.ToFloat(), rationalTwo.ToFloat())}");
Console.WriteLine($"Multiplied rational numbers = {Rational.Multiply(rationalOne.ToFloat(), rationalTwo.ToFloat())}");
Console.WriteLine($"Divided rational numbers = {Rational.Divide(rationalOne.ToFloat(), rationalTwo.ToFloat())}");
Console.WriteLine("\nPress any key to end program.");
Console.ReadKey();
}
public void Case1()
{
// The statement:
// Rational number = Int64.MaxValue + Int32.MaxValue;
// produces compiler error CS0220: The operation overflows at compile time in checked mode.
// The alternative:
Rational number = Rational.Add(Int64.MaxValue, Int32.MaxValue);
}
public void Case1()
{
byte byteValue = 254;
Rational number = byteValue;
number = Rational.Add(number, byteValue);
Console.WriteLine(number > byteValue); // Displays True
}
public void Add(Rational r1, Rational r2)
{
RationalBase result = r1.Add(r2);
Assert.True(r1 != result && r2 != result);
int n1 = r1.Numerator, d1 = r1.Denominator, n2 = r2.Numerator, d2 = r2.Denominator;
Assert.Equal(new Rational(n1 * d2 + n2 * d1, d1 * d2), result);
}
static void Main(string[] args)
{
Rational a = new Rational(3, 4);
Rational b = new Rational(4, 5);
Rational c = a.Add(b);
Console.WriteLine(c.StrVal());
c = b.Subtract(a);
Console.WriteLine(c.StrVal());
}
public void NumbersAreZero()
{
var num1 = new Rational {
Numerator = 0, Denominator = 1
};
var num2 = num1;
var result = num1.Add(num2);
Assert.AreEqual(0, result.Numerator);
Assert.AreEqual(1, result.Denominator);
}
public void DifferentDenominators()
{
var num1 = new Rational {
Numerator = 1, Denominator = 2
};
var num2 = new Rational {
Numerator = 2, Denominator = 3
};
var result = num1.Add(num2);
Assert.AreEqual(7, result.Numerator);
Assert.AreEqual(6, result.Denominator);
}
public void SameDenominators()
{
var num1 = new Rational {
Numerator = 1, Denominator = 2
};
var num2 = new Rational {
Numerator = 2, Denominator = 2
};
var result = num1.Add(num2);
Assert.AreEqual(3, result.Numerator);
Assert.AreEqual(2, result.Denominator);
}
static void Main()
{
Rational a = new Rational(3, 4);
Rational b = new Rational(4, 5);
Rational c = a.Add(b);
Console.WriteLine(c.StrVal());
c = a.Subtract(b);
Console.WriteLine(c.StrVal());
}
public void Case1()
{
// Initialize a Rational value.
Rational value = Rational.Add(UInt64.MaxValue, 1024);
// Display value using the default ToString method.
Console.WriteLine(value.ToString());
// Display value using some standard format specifiers.
Console.WriteLine(value.ToString("G"));
Console.WriteLine(value.ToString("C"));
Console.WriteLine(value.ToString("D"));
Console.WriteLine(value.ToString("F"));
Console.WriteLine(value.ToString("N"));
// The example displays the following output on a system whose current
// culture is en-US:
// 18446744073709552639
// 18446744073709552639
// $18,446,744,073,709,552,639.00
// 18446744073709552639
// 18446744073709552639.00
// 18,446,744,073,709,552,639.00
}
internal override Rational Op(Rational lhs, Rational rhs)
{
return(lhs.Add(rhs));
}
public void Dividing_the_sum_is_the_same_as_dividing_each_and_then_adding_the_result(NonZeroRational x, Rational y, Rational z)
{
Assert.Equal((y + z) / x, (y / x) + (z / x));
Assert.Equal(Rational.Divide(Rational.Add(y, z), x), Rational.Add(Rational.Divide(y, x), Rational.Divide(z, x)));
}
public void Substracting_y_to_x_is_the_same_as_adding_opposite_of_y_to_x(Rational x, Rational y)
{
Assert.Equal(x - y, x + (-y));
Assert.Equal(Rational.Subtract(x, y), Rational.Add(x, Rational.Negate(y)));
}
private static BigDecimal BroadhurstBbp(int n, int p, int[] a, MathContext mc)
{
/* Explore the actual magnitude of the result first with a quick estimate.
*/
double x = 0.0;
for (int k = 1; k < 10; k++)
x += a[(k - 1)%8]/System.Math.Pow(2d, p*(k + 1)/2d)/System.Math.Pow(k, n);
/* Convert the relative precision and estimate of the result into an absolute precision.
*/
double eps = PrecisionToError(x, mc.Precision);
/* Divide this through the number of terms in the sum to account for error accumulation
* The divisor 2^(p(k+1)/2) means that on the average each 8th term in k has shrunk by
* relative to the 8th predecessor by 1/2^(4p). 1/2^(4pc) = 10^(-precision) with c the 8term
* cycles yields c=log_2( 10^precision)/4p = 3.3*precision/4p with k=8c
*/
var kmax = (int) (6.6*mc.Precision/p);
/* Now eps is the absolute error in each term */
eps /= kmax;
BigDecimal res = BigDecimal.Zero;
for (int c = 0;; c++) {
var r = new Rational();
for (int k = 0; k < 8; k++) {
var tmp = new Rational(BigInteger.ValueOf(a[k]), (BigInteger.ValueOf((1 + 8*c + k))).Pow(n));
/* floor( (pk+p)/2)
*/
int pk1h = p*(2 + 8*c + k)/2;
tmp = tmp.Divide(BigInteger.One.ShiftLeft(pk1h));
r = r.Add(tmp);
}
if (System.Math.Abs(r.ToDouble()) < eps)
break;
var mcloc = new MathContext(1 + ErrorToPrecision(r.ToDouble(), eps));
res = res.Add(r.ToBigDecimal(mcloc));
}
return res.Round(mc);
}
public static BigDecimal Zeta(int n, MathContext mc)
{
if (n <= 0)
throw new NotSupportedException("Zeta at negative argument " + n + " not supported");
if (n == 1)
throw new ArithmeticException("Pole at zeta(1) ");
if (n%2 == 0) {
/* Even indices. Abramowitz-Stegun 23.2.16. Start with 2^(n-1)*B(n)/n!
*/
Rational b = Bernoulli.Default[n].Abs();
b = b.Divide(Factorial.Default[n]);
b = b.Multiply(BigInteger.One.ShiftLeft(n - 1));
/* to be multiplied by pi^n. Absolute error in the result of pi^n is n times
* error in pi times pi^(n-1). Relative error is n*error(pi)/pi, requested by mc.
* Need one more digit in pi if n=10, two digits if n=100 etc, and add one extra digit.
*/
var mcpi = new MathContext(mc.Precision + (int) (System.Math.Log10(10.0*n)));
BigDecimal piton = PiRound(mcpi).Pow(n, mc);
return MultiplyRound(piton, b);
}
if (n == 3) {
/* Broadhurst BBP <a href="http://arxiv.org/abs/math/9803067">arXiv:math/9803067</a>
* Error propagation: S31 is roughly 0.087, S33 roughly 0.131
*/
int[] a31 = {1, -7, -1, 10, -1, -7, 1, 0};
int[] a33 = {1, 1, -1, -2, -1, 1, 1, 0};
BigDecimal S31 = BroadhurstBbp(3, 1, a31, mc);
BigDecimal S33 = BroadhurstBbp(3, 3, a33, mc);
S31 = S31.Multiply(new BigDecimal(48));
S33 = S33.Multiply(new BigDecimal(32));
return S31.Add(S33).Divide(new BigDecimal(7), mc);
}
if (n == 5) {
/* Broadhurst BBP <a href=http://arxiv.org/abs/math/9803067">arXiv:math/9803067</a>
* Error propagation: S51 is roughly -11.15, S53 roughly 22.165, S55 is roughly 0.031
* 9*2048*S51/6265 = -3.28. 7*2038*S53/61651= 5.07. 738*2048*S55/61651= 0.747.
* The result is of the order 1.03, so we add 2 digits to S51 and S52 and one digit to S55.
*/
int[] a51 = {31, -1614, -31, -6212, -31, -1614, 31, 74552};
int[] a53 = {173, 284, -173, -457, -173, 284, 173, -111};
int[] a55 = {1, 0, -1, -1, -1, 0, 1, 1};
BigDecimal S51 = BroadhurstBbp(5, 1, a51, new MathContext(2 + mc.Precision));
BigDecimal S53 = BroadhurstBbp(5, 3, a53, new MathContext(2 + mc.Precision));
BigDecimal S55 = BroadhurstBbp(5, 5, a55, new MathContext(1 + mc.Precision));
S51 = S51.Multiply(new BigDecimal(18432));
S53 = S53.Multiply(new BigDecimal(14336));
S55 = S55.Multiply(new BigDecimal(1511424));
return S51.Add(S53).Subtract(S55).Divide(new BigDecimal(62651), mc);
}
/* Cohen et al Exp Math 1 (1) (1992) 25
*/
var betsum = new Rational();
var bern = new Bernoulli();
var fact = new Factorial();
for (int npr = 0; npr <= (n + 1)/2; npr++) {
Rational b = bern[2*npr].Multiply(bern[n + 1 - 2*npr]);
b = b.Divide(fact[2*npr]).Divide(fact[n + 1 - 2*npr]);
b = b.Multiply(1 - 2*npr);
if (npr%2 == 0)
betsum = betsum.Add(b);
else
betsum = betsum.Subtract(b);
}
betsum = betsum.Divide(n - 1);
/* The first term, including the facor (2pi)^n, is essentially most
* of the result, near one. The second term below is roughly in the range 0.003 to 0.009.
* So the precision here is matching the precisionn requested by mc, and the precision
* requested for 2*pi is in absolute terms adjusted.
*/
var mcloc = new MathContext(2 + mc.Precision + (int) (System.Math.Log10(n)));
BigDecimal ftrm = PiRound(mcloc).Multiply(new BigDecimal(2));
ftrm = ftrm.Pow(n);
ftrm = MultiplyRound(ftrm, betsum.ToBigDecimal(mcloc));
var exps = new BigDecimal(0);
/* the basic accuracy of the accumulated terms before multiplication with 2
*/
double eps = System.Math.Pow(10d, -mc.Precision);
if (n%4 == 3) {
/* since the argument n is at least 7 here, the drop
* of the terms is at rather constant pace at least 10^-3, for example
* 0.0018, 0.2e-7, 0.29e-11, 0.74e-15 etc for npr=1,2,3.... We want 2 times these terms
* fall below eps/10.
*/
int kmax = mc.Precision/3;
eps /= kmax;
/* need an error of eps for 2/(exp(2pi)-1) = 0.0037
* The absolute error is 4*exp(2pi)*err(pi)/(exp(2pi)-1)^2=0.0075*err(pi)
*/
BigDecimal exp2p = PiRound(new MathContext(3 + ErrorToPrecision(3.14, eps/0.0075)));
exp2p = Exp(exp2p.Multiply(new BigDecimal(2)));
BigDecimal c = exp2p.Subtract(BigDecimal.One);
exps = DivideRound(1, c);
for (int npr = 2; npr <= kmax; npr++) {
/* the error estimate above for npr=1 is the worst case of
* the absolute error created by an error in 2pi. So we can
* safely re-use the exp2p value computed above without
* reassessment of its error.
*/
c = PowRound(exp2p, npr).Subtract(BigDecimal.One);
c = MultiplyRound(c, (BigInteger.ValueOf(npr)).Pow(n));
c = DivideRound(1, c);
exps = exps.Add(c);
}
} else {
/* since the argument n is at least 9 here, the drop
* of the terms is at rather constant pace at least 10^-3, for example
* 0.0096, 0.5e-7, 0.3e-11, 0.6e-15 etc. We want these terms
* fall below eps/10.
*/
int kmax = (1 + mc.Precision)/3;
eps /= kmax;
/* need an error of eps for 2/(exp(2pi)-1)*(1+4*Pi/8/(1-exp(-2pi)) = 0.0096
* at k=7 or = 0.00766 at k=13 for example.
* The absolute error is 0.017*err(pi) at k=9, 0.013*err(pi) at k=13, 0.012 at k=17
*/
BigDecimal twop = PiRound(new MathContext(3 + ErrorToPrecision(3.14, eps/0.017)));
twop = twop.Multiply(new BigDecimal(2));
BigDecimal exp2p = Exp(twop);
BigDecimal c = exp2p.Subtract(BigDecimal.One);
exps = DivideRound(1, c);
c = BigDecimal.One.Subtract(DivideRound(1, exp2p));
c = DivideRound(twop, c).Multiply(new BigDecimal(2));
c = DivideRound(c, n - 1).Add(BigDecimal.One);
exps = MultiplyRound(exps, c);
for (int npr = 2; npr <= kmax; npr++) {
c = PowRound(exp2p, npr).Subtract(BigDecimal.One);
c = MultiplyRound(c, (BigInteger.ValueOf(npr)).Pow(n));
BigDecimal d = DivideRound(1, exp2p.Pow(npr));
d = BigDecimal.One.Subtract(d);
d = DivideRound(twop, d).Multiply(new BigDecimal(2*npr));
d = DivideRound(d, n - 1).Add(BigDecimal.One);
d = DivideRound(d, c);
exps = exps.Add(d);
}
}
exps = exps.Multiply(new BigDecimal(2));
return ftrm.Subtract(exps, mc);
}
public void Multiplying_the_sum_is_the_same_as_multiplying_each_one_and_then_adding_the_result(Rational x, Rational y, Rational z)
{
Assert.Equal((y + z) * x, y * x + z * x);
Assert.Equal(Rational.Multiply(Rational.Add(y, z), x), Rational.Add(Rational.Multiply(y, x), Rational.Multiply(z, x)));
}
public void Case1()
{
Rational number1 = Rational.Add(Int64.MaxValue, Int32.MaxValue);
Rational number2 = Math.Pow(Byte.MaxValue, 10);
Rational result = number1 & number2;
}
public void Adding_the_opposite_returns_0(Rational x)
{
Assert.Equal(Rational.Zero, x + (-x));
Assert.Equal(Rational.Zero, Rational.Add(x, Rational.Negate(x)));
}
public void Adding_NaN_returns_NaN(Rational x)
{
Assert.Equal(Rational.NaN, x + Rational.NaN);
Assert.Equal(Rational.NaN, Rational.Add(x, Rational.NaN));
}
public void Adding_3_rationals_in_any_order_returns_the_same_result(Rational x, Rational y, Rational z)
{
Assert.Equal(x + y + z, x + (y + z));
Assert.Equal(Rational.Add(Rational.Add(x, y), z), Rational.Add(x, Rational.Add(y, z)));
}
public void AddFail(Rational r, int n, int d)
{
Assert.Throws <InvalidOperationException>(() => r.Add(null));
}
public void Case1()
{
Rational number1 = Rational.Add(Int64.MaxValue, Int32.MaxValue);
Rational number2 = Math.Pow(Byte.MaxValue, 10);
Rational result = Rational.BitwiseAnd(number1, number2);
}
public void Adding_x_to_y_is_the_same_as_adding_y_to_x(Rational x, Rational y)
{
Assert.Equal(x + y, y + x);
Assert.Equal(Rational.Add(x, y), Rational.Add(y, x));
}