using System;

using System.Collections.Generic;

​

Rationnel r0 = new (2, 3),

          r1 = new (5, 2);

Console.WriteLine($"{r0}, {r1}"); // utilise Rationnel.ToString()

Console.WriteLine("{0}", new Rationnel(3, 6).Simplifier());

r0 = new (3, 6);

r1 = new (1, 2);

Console.WriteLine($"{r0} {(r0 == r1 ? "==" : "!=")} {r1}");

r0 = new (1, 4);

r1 = new (1, 2);

Console.WriteLine($"{r0} {(r0 == r1 ? "==" : "!=")} {r1}");

Console.WriteLine($"Symbolique : {r0 + r1}, décimal : {(float)(r0 + r1)}");

class DivisionParZéroException : Exception { }

class Rationnel : IEquatable<Rationnel>

{

   //

   // pour faciliter la simplification

   //

   private static int Pgcd(int a, int b) =>

      b != 0 ? Pgcd(a, a % b) : a;

   private int dénominateur;

   public int Numérateur { get; init; }

   public int Dénominateur

   {

      get => dénominateur;

      init

      {

         if (value == 0)

            throw new DivisionParZéroException();

         dénominateur = value;

      }

   }

   public Rationnel(int num, int dénom)

   {

      Numérateur = num;

      Dénominateur = dénom;

   }

   public Rationnel(int num)

   {

      Numérateur = num;

      Dénominateur = 1;

   }

   public Rationnel Simplifier()

   {

      int pgcd = Pgcd(Numérateur, Dénominateur);

      return new Rationnel(Numérateur / pgcd, Dénominateur / pgcd);

   }

   public static bool operator ==(Rationnel r0, Rationnel r1) =>

         r0.Equals(r1);

      //

      // écrire == oblige d'écrire !=

      //

      public static bool operator !=(Rationnel r0, Rationnel r1) =>

         !(r0 == r1);

      //

      // écrire == exige d'écrire Equals(object) pour qui

      // ne se limitera pas à C# sur la plateforme .NET

      // Notez que la surcharge polymorphique doit être explicite

      //

      public override bool Equals(object obj) =>

         obj is Rationnel r && Equals(r);

      //

      // IEquatable<Rationnel>

      //

      public bool Equals(Rationnel r)

      {

         Rationnel r0 = Simplifier(),

                   r1 = r.Simplifier();

         return r0.Numérateur == r1.Numérateur &&

                r0.Dénominateur == r1.Dénominateur;

      }

      //

      // écrire Equals(object) mène à écrire GetHashCode()... >soupir!<

      // Notez que la surcharge polymorphique doit être explicite

      //

      public override int GetHashCode() =>

         Numérateur.GetHashCode() ^ Dénominateur.GetHashCode(); // bof

// ...

      public static bool operator <(Rationnel r0, Rationnel r1) =>

         r0.Numérateur * r1.Dénominateur < r1.Numérateur * r0.Dénominateur;

      public static bool operator >(Rationnel r0, Rationnel r1) =>

         r1 < r0;

      public static bool operator <=(Rationnel r0, Rationnel r1) =>

         !(r1 < r0);

      public static bool operator >=(Rationnel r0, Rationnel r1) =>

         !(r0 < r1);

// ...

      public static Rationnel operator +(Rationnel r0, Rationnel r1) =>

         new

         (

            r0.Numérateur * r1.Dénominateur + r1.Numérateur * r0.Dénominateur,

            r0.Dénominateur * r1.Dénominateur

         );

// ...

      //

      // Traiter un Rationnel comme une string

      //

      public override string ToString() =>

         $"{Numérateur}/{Dénominateur}";

// ...

      //

      // Traiter un Rationnel comme un float ou comme un double

      //

      static public explicit operator float(Rationnel r) =>

         ((float)r.Numérateur) / r.Dénominateur;

      static public explicit operator double(Rationnel r) =>

         ((double)r.Numérateur) / r.Dénominateur;

   }

​