Frazioni

// https://pastebin.com/u/nellorizzo
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Rationals
{
    /*
     * Gestione delle operazioni tra frazioni aritmetiche.
     * Cosa intendiamo con frazione? Come si svolgono le operazioni tra frazioni?
     * Una [frazione] è costituita da [numeratore] e [denominatore], entrambi numeri interi.
     * Una frazione può essere <ridotta ai minimi termini> (MCD - altro algoritmo).
     * Una frazione può essere <trasformata in numero reale>.
     * Un numero reale può essere <trasformato in frazione>.
     * Una frazione può essere <rappresentata sotto forma di stringa>.
     * <Operazioni:
     * - Addizione
     * - Sottrazione
     * - Moltiplicazione
     * - Divisione
     * - Inverso
     * - Cambio segno
     * - Uguaglianza tra frazioni (?)>
     * */
    class Fraction
    {
        public int Numerator { get; private set; }
        public int Denominator { get; private set; }
        public int Sign { get; private set; }
        // creazione di frazione
        //   come possiamo creare una frazione?
        //     1. a partire da numeratore e denominatore
        public Fraction(int numerator, int denominator)
        {
            //if (numerator * denominator < 0) Sign = -1; else Sign = 1;
            Sign = (numerator * denominator < 0) ? -1 : 1;
            Numerator = Math.Abs(numerator);
            Denominator = Math.Abs(denominator);
            // TODO: Se il denominatore è 0 cosa succede???

            // riduco ai minimi termini
            Normalize();
        }
        //     2. a partire da un numero intero
        public Fraction(int number) : this(numerator: number, denominator: 1)
        {
            // richiama l'altro costruttore passando 1 come denominatore...
            //Numerator = number;
            //Denominator = 1;
        }
        //     3. a partire da un numero con la virgola
        public Fraction(float number, int digits)
        {
            int power = (int)Math.Pow(10, digits); // 10 ^ digits
            Sign = (number < 0) ? -1 : 1;
            Numerator = (int)Math.Truncate(Math.Abs(number) * power);
            Denominator = power;
            Normalize();
        }
        //     4. la frazione unitaria? (il numero 1 potrebbe essere una frazione 1/1)
        public Fraction() : this(1, 1) { }
        //     5. esiste uno zero? - non lo prendo in considerazione (almeno per ora)

        // implementazione dell'algoritmo di Euclide per calcolare il M.C.D.
        // con la tecnica ricorsiva.
        // TODO: Chi potrà, in futuro, utilizzare il metodo MCD?
        int MCD(int a, int b)
        {
            if (a < b) { int t = a; a = b; b = t; }
            if (b == 0) return a;
            return MCD(b, a % b);
        }
        // riduzione ai minimi termini
        private void Normalize()
        {
            // prendo il Massimo Comune Divisore tra il Numeratore e il Denominatore
            int mcd = MCD(Numerator, Denominator);
            // divido il numeratore per il m.c.d.
            Numerator /= mcd;
            // divido il denominatore per il m.c.d.
            Denominator /= mcd;
        }
        // trasformazione in numero reale
        public double ToReal() { return Sign * (double)Numerator / Denominator; }
        // rappresentazione come stringa
        public override string ToString()
        {
            // TODO: Queste concatenazioni di stringhe non mi piacciono...
            string result = "";
            if (Sign < 0) result = "-";
            result += Numerator.ToString();
            if (Denominator != 1)
                result += "/" + Denominator.ToString();
            return result;
        }
        // operazioni...
        // Addizione tra frazioni
        // Ho la frazione sulla quale viene applicato il metodo Add
        // che deve essere addizionata ad un'altra frazione passata come parametro
        // Primo problema: cosa restituisco? La soluzione più semplice è quella di restituire
        //                 una terza frazione SOMMA che contiene appunto la somma delle due frazioni
        public Fraction Add(Fraction other)
        {
            int n = this.Sign * this.Numerator * other.Denominator +
                other.Sign * this.Denominator * other.Numerator;
            int d = this.Denominator * other.Denominator;

            return new Fraction(n, d);
        }
        // opposto di una frazione...
        public Fraction Opposite() { return new Fraction(-Sign * Numerator, Denominator); }
        // Sottrazione = Addizione con l'opposto della seconda...
        public Fraction Sub(Fraction other)
        {
            return Add(other.Opposite());
        }
        public Fraction Mul(Fraction other)
        {
            int n = this.Numerator * this.Sign * other.Sign * other.Numerator;
            int d = this.Denominator * other.Denominator;
            return new Fraction(n, d);
        }
        public Fraction Inverse() { return new Fraction(Sign * Denominator, Numerator); }
        public Fraction Div(Fraction other)
        {
            return Mul(other.Inverse());
        }

        // L'eleganza del C#:
        public static explicit operator Fraction(double d) { return new Fraction((float)d, 5); }

        public static explicit operator double(Fraction f) { return f.ToReal(); }
        public static Fraction operator +(Fraction f1, Fraction f2) { return f1.Add(f2); }
        public static Fraction operator +(Fraction f, double d) { return f.Add((Fraction)d); }
        public static Fraction operator +(double d, Fraction f) { return f + d; }
        public static Fraction operator -(Fraction f1, Fraction f2) { return f1.Sub(f2); }
        public static Fraction operator -(Fraction f1, double f2) { return f1.Sub((Fraction)f2); }
        public static Fraction operator -(double d, Fraction f) { return f.Opposite() + d; }
        public static Fraction operator *(Fraction f1, Fraction f2) { return f1.Mul(f2); }
        public static Fraction operator *(Fraction f, double d) { var t= f.Mul((Fraction)d); return t; }
        public static Fraction operator *(double d, Fraction f) { return f.Mul((Fraction)d); }
        public static Fraction operator /(Fraction f1, Fraction f2) { return f1.Div(f2); }
        public static Fraction operator /(Fraction f, double d) { return f.Div((Fraction)d); }
        public static Fraction operator /(double d, Fraction f) { return ((Fraction)d).Div(f); }
    }
}