C# Rational类代码示例

 public void TestAdd_WithOtherRational_Passed()
 {
     var rat = new Rational(625, 5);
     var other = new Rational(338, 13);
     var sum = rat + other;
     Assert.AreEqual(151, (double)sum, "Invalid Sum operation");
 }

 public void TestGetReciprocal()
 {
     var rational = new Rational(1, 3);
     var reciprocal = rational.Reciprocal;
     Assert.Equal(new Rational(3, 1), reciprocal);
     Assert.Equal(new Rational(1, 3), rational);
 }

 /// <summary>Initializes a new instance of the <see cref="DisplayMode"/> class.</summary>
 /// <param name="pixelFormat">The pixel format.</param>
 /// <param name="width">The width.</param>
 /// <param name="height">The height.</param>
 /// <param name="refreshRate">The refresh rate.</param>
 public DisplayMode(Format pixelFormat, int width, int height, Rational refreshRate)
 {
     this.pixelFormat = pixelFormat;
     this.width = width;
     this.height = height;
     this.refreshRate = refreshRate;
 }

 public override Rational EvaluateRational(int Precision)
 {
     if (this.power == 0)
     {
         return 1;
     }
     else if (this.power == 1)
     {
         return this.PiSeries(Precision);
     }
     else if (this.power == -1)
     {
         return 1 / this.PiSeries(Precision);
     }
     else if (this.power < -1)
     {
         Rational newpower = new Rational(this.power.Numerator.Number, this.power.Denominator.Number);
         Rational flippedpiseries = 1 / this.PiSeries(Precision);
         return PowerEvaluation.EvaluateRationalPower(flippedpiseries, newpower, Precision);
     }
     else
     {
         return PowerEvaluation.EvaluateRationalPower(this.PiSeries(Precision), this.power, Precision);
     }
 }

        public void TestToSimpleString()
        {
            var third1 = new Rational(1, 3);
            var third2 = new Rational(2, 6);
            Assert.Equal("1/3", third1.ToSimpleString());
            Assert.Equal("1/3", third2.ToSimpleString());
            Assert.Equal(third1, third2);

            var twoThirds = new Rational(10, 15);
            Assert.Equal("2/3", twoThirds.ToSimpleString());

            var two = new Rational(10, 5);
            Assert.True(two.IsInteger);
            Assert.Equal("2", two.ToSimpleString());
            Assert.Equal("2", two.ToSimpleString(allowDecimal: false));

            var twoFifths = new Rational(4, 10);
            Assert.Equal("0.4", twoFifths.ToSimpleString());
            Assert.Equal("2/5", twoFifths.ToSimpleString(allowDecimal: false));

            var threeEighths = new Rational(3, 8);
            Assert.Equal("3/8", threeEighths.ToSimpleString());

            var zero = new Rational(0, 8);
            Assert.True(zero.IsInteger);
            Assert.Equal("0", zero.ToSimpleString());
            Assert.Equal("0", zero.ToSimpleString(allowDecimal: false));

            zero = new Rational(0, 0);
            Assert.True(zero.IsInteger);
            Assert.Equal("0", zero.ToSimpleString());
            Assert.Equal("0", zero.ToSimpleString(allowDecimal: false));
        }

 private static Datum[] Generate(int count, Rational w0, Rational[] w)
 {
     return Enumerable.Range(1, count)
     .Select(_ => GetX())
     .Select(ex => new Datum{x=ex, y=GetY(ex, w0, w)})
     .ToArray();
 }

 public static Rational Normalize(Rational a)
 {
     int numenator = a.GetNumenator();
     int denumenator = a.GetDenumenator();
     int gcd = GCD(numenator, denumenator);
     return new Rational(numenator / gcd, denumenator / gcd);
 }

 public void TestMinus_WithOtherRational_Passed()
 {
     var rat = new Rational(625, 5);
     var other = new Rational(338, 13);
     var minus = rat - other;
     Assert.AreEqual(99, (double)minus, "Invalid minus operation");
 }

 public void CompareToTest()
 {
     Rational target = new Rational(1, 3);
     Assert.AreEqual(target.CompareTo(new Rational(1, 2)), -1);
     Assert.AreEqual(target.CompareTo(new Rational(1, 3)), 0);
     Assert.AreEqual(target.CompareTo(new Rational(1, 4)), 1);
 }

 private static void TestValue(ExifValue value, Rational[] expected)
 {
   Assert.IsNotNull(value);
   Rational[] values = (Rational[])value.Value;
   Assert.IsNotNull(values);
   CollectionAssert.AreEqual(expected, values);
 }

 public void TestMultiply_WithOtherRational_Passed()
 {
     var rat = new Rational(625, 5);
     var other = new Rational(338, 13);
     var mult = rat * other;
     Assert.AreEqual(3250, (double)mult, "Invalid multiply operation");
 }

 public void TestCompare_withDoubleFloatInt_Passed()
 {
     var rat = new Rational(625, 5);
     Assert.AreEqual(125, (double)rat, "Invalid cast to double");
     Assert.AreEqual(125, (float)rat, "Invalid cast to float");
     Assert.AreEqual(125, (int)rat, "Invalid cast to int");
 }

        public static void ProcessFiles(FileInfo[] files, int speedupFactor, Rational outputFramesPerSecond)
        {
            var i = 1;
            var filesCount = files.Count();
            var engine = new HyperlapseEngine();

            engine.ProcessingCancelled += OnEngineProcessingCancelled;
            engine.ProcessingFailed += OnEngineProcessingFailed;
            engine.ProcessingFinished += OnEngineProcessingFinished;
            engine.ProgressChanged += OnEngineProgressChanged;
            engine.TrialStatusChanged += OnEngineTrialStatusChanged;

            foreach (var file in files)
            {
                var processingMsg = "[Processing file " + i++ + " of " + filesCount + "] - " + file.Name;
                Console.Title = processingMsg;
                Console.WriteLine(processingMsg);

                var fileOutput = new FileInfo(Path.Combine(file.DirectoryName, "Output", file.Name));
                if (!fileOutput.Directory.Exists)
                {
                    fileOutput.Directory.Create(); // create output dir
                }

                Process(engine, file, fileOutput, speedupFactor, outputFramesPerSecond);
            }

            engine.Dispose();
        }

    public void Test_ToDouble()
    {
      Rational rational = new Rational(0, 0);
      Assert.AreEqual(double.NaN, rational.ToDouble());

      rational = new Rational(2, 0);
      Assert.AreEqual(double.PositiveInfinity, rational.ToDouble());
    }

        public void TestCreateRational()
        {
            var rational = new Rational(1, 3);

            Assert.Equal(1, rational.Numerator);
            Assert.Equal(3, rational.Denominator);
            Assert.Equal(1d / 3d, rational.ToDouble(), 4);
        }