public void konstruktorDwuArgumentowy_Poprawnie(int l, int m, int ExpectedNumerator, int ExpectedDominator)
{
Rational32 u = new Rational32(l, m);
Assert.AreEqual(ExpectedNumerator, u.Numerator);
Assert.AreEqual(ExpectedDominator, u.Denominator);
}
public void GetHashCodeTest()
{
Rational32 a = new Rational32(42, 666);
Rational32 b = new Rational32(42, 666);
Assert.Equal(a.GetHashCode(), b.GetHashCode());
}
public static Dynamic Simplify(Rational32 rational)
{
rational = rational.Simplify();
return(rational.Denominator == 1
? new Integer(rational.Numerator)
: (Dynamic) new Rational(rational));
}
public void floating_point_conversion()
{
double sum = 0.0;
double upper = 0.0;
double lower = 2.0;
for (int i = 0; i < fuzzcount; i++)
{
var original = (float)((rnd.NextDouble() - 0.5) * rnd.Next(1, Rational32.MaxInt / 8));
var subject = Rational32.FromFloat(original);
var result = subject.ToFloat();
// we can only approximate the exact float value
var scale = original / result;
sum += scale;
upper = Math.Max(scale, upper);
lower = Math.Min(scale, lower);
Assert.That(scale, Is.LessThan(1.3), $"Original = {original}; Result = {result}; Scale = {scale}; (attempt {i})");
Assert.That(scale, Is.GreaterThan(0.7), $"Original = {original}; Result = {result}; Scale = {scale}; (attempt {i})");
}
Console.WriteLine($"Average = {sum/fuzzcount}; Upper = {upper}; Lower = {lower};");
}
public void ToStringTest()
{
Rational32 target = new Rational32(42, 666);
string expected = "42/666";
string actual = target.ToString();
Assert.Equal(expected, actual);
}
public void can_convert_an_integer_into_a_rational_into_a_float()
{
var subject = Rational32.FromInt(1234);
var result = subject.ToFloat();
Assert.That(result, Is.EqualTo(1234));
}
public void KonstruktorDwuArgumentowy_Poprawnie(int numerator, int denominator, int expectedNumerator, int expectedDenominator)
{
//AAA
Rational32 u = new Rational32(numerator, denominator);
Assert.AreEqual(expectedNumerator, u.Numerator);
Assert.AreEqual(expectedDenominator, u.Denominator);
}
static void Main(string[] args)
{
Rational32 u = new Rational32(1, 2);
var w = new Rational32(0, 0);
Console.WriteLine(u);
Console.WriteLine(w);
}
public void Rational32ConstructorTest1()
{
int numerator = 0;
int denominator = 0;
Rational32 target = new Rational32(numerator, denominator);
Assert.Equal(numerator, target.Numerator);
Assert.Equal(denominator, target.Denominator);
}
public void ReduceTest2()
{
Rational32 target = new Rational32(9, 25);
Rational32 expected = new Rational32(9, 25);
Rational32 actual;
actual = target.Reduce();
Assert.Equal(expected, actual);
}
public void ReduceTest()
{
Rational32 target = new Rational32(1207959552, 16777216);
Rational32 expected = new Rational32(72, 1);
Rational32 actual;
actual = target.Reduce();
Assert.Equal(expected, actual);
}
public void converting_an_negative_oversize_int_results_in_saturation()
{
var max = (1 << 26) - 1;
var subject = Rational32.FromInt(-123456789);
var result = subject.ToFloat();
Assert.That(result, Is.EqualTo(-max));
}
public void can_convert_a_large_integer_into_a_rational_into_a_float()
{
var max = (1 << 26) - 1;
var subject = Rational32.FromInt(max);
var result = subject.ToFloat();
Assert.That(result, Is.EqualTo(max));
}
public void InverseTest()
{
Rational32 target = new Rational32(1207959552, 16777216);
Rational32 expected = new Rational32(16777216, 1207959552);
Rational32 actual;
actual = target.Inverse();
Assert.Equal(expected, actual);
}
public void EqualsTest()
{
Rational32 target = new Rational32();
object obj = null;
bool expected = false;
bool actual;
actual = target.Equals(obj);
Assert.Equal(expected, actual);
}
public void op_InequalityTest()
{
Rational32 value1 = new Rational32(1, 2);
Rational32 value2 = new Rational32(2, 4);
bool expected = true;
bool actual;
actual = (value1 != value2);
Assert.Equal(expected, actual);
}
public void GetBytesTest()
{
Rational32 test = new Rational32(42, 666);
byte[] data = new byte[8];
Array.Copy(BitConverter.GetBytes((int)42), data, 4);
Array.Copy(BitConverter.GetBytes((int)666), 0, data, 4, 4);
int startIndex = 0;
Rational32 target = new Rational32(data, startIndex);
Assert.Equal(data, target.GetBytes());
}
public void can_round_trip_a_rational_float()
{
var original = 500.125;
var subject = Rational32.FromFloat(original);
Console.WriteLine("Ended up with " + subject);
var result = subject.ToFloat();
Assert.That(result, Is.EqualTo(original));
}
static void Main(string[] args)
{
Rational32 u = new Rational32(1, 2);
var w = new Rational32();
var v = new Rational32(5);
var x = Rational32.ZERO;
Console.WriteLine(u);
Console.WriteLine(w);
Console.WriteLine(v);
Console.WriteLine(x);
}
public Rational(Rational32 value)
{
this.value = value;
}
public void reciprocals_work_as_expected()
{
Assert.That(Rational32.FromInt(1).Reciprocal().ToFloat(), Is.EqualTo(1));
Assert.That(Rational32.FromInt(2).Reciprocal().ToFloat(), Is.EqualTo(0.5));
Assert.That(Rational32.FromInt(4).Reciprocal().ToFloat(), Is.EqualTo(0.25));
}
public void reciprocal_of_zero_is_NAN()
{
Assert.That(Rational32.FromInt(0).Reciprocal().IsNaN(), Is.True);
}
/// <summary>
/// Initializes a rational constant.
/// </summary>
/// <param name="value">The constant's value</param>
public Constant(Rational32 value)
{
this.value = new Rational(value);
}
public Rational(int numerator)
{
value = new Rational32(numerator);
}
public void DenominatorTest()
{
Rational32 target = new Rational32(42, 666);
Assert.Equal(666, target.Denominator);
}
public Rational(int numerator, int denominator)
{
value = new Rational32(numerator, denominator);
}
public void NumeratorTest()
{
Rational32 target = new Rational32(42, 666);
Assert.Equal(42, target.Numerator);
}
