using System;

using System.Numerics;

​

public class C {

    public static void Main() {

        Console.WriteLine(new BigRational(64e-5));      

        Console.WriteLine(new BigRational(64e-5).ToStringDecimal());

        //Console.WriteLine(new BigRational((int)1e2));

        Console.WriteLine(1e2);

        Console.WriteLine((int)new BigInteger((long)int.MaxValue + 5));

        Console.WriteLine(new BigRational(15, 15464).ToStringDecimal());

        Console.WriteLine(new BigRational(1546464565, 165465).ToStringDecimal());

    }

}

​

/// <summary>

    /// Immutable representation of a rational number of arbitrary length and precition.

    /// </summary>

    public readonly partial struct BigRational : IEquatable<BigRational>, IComparable<BigRational>

    {

        /// <summary>

        /// Gets the value that represents the number 1.

        /// </summary>

        public static readonly BigRational One = new BigRational(BigInteger.One, BigInteger.One);

​

        /// <summary>

        /// Gets the value that represents the number 0.

        /// </summary>

        public static readonly BigRational Zero = new BigRational(BigInteger.Zero, BigInteger.One);

​

        /// <summary>

        /// Numerator part.

        /// </summary>

        public readonly BigInteger Numerator;

​

        /// <summary>

        /// Denominator part.

        /// </summary>

        public readonly BigInteger Denominator;

​

        /// <summary>

        /// Recudes the fraction to its simplest form.

        /// </summary>

        public BigRational Reduced {

            get {

                if (Denominator == 1)

                    return this;

                BigInteger gcd = BigInteger.GreatestCommonDivisor(Numerator, Denominator);

                BigInteger numerator = Numerator / gcd;

                BigInteger denominator = Denominator / gcd;

                if (denominator < 0)

                {

                    denominator = BigInteger.Abs(denominator);

                    numerator *= -1;

                }

                return new BigRational(numerator, denominator);

            }

        }

​

        /// <summary>

        /// <c><see cref="Numerator"/> / <see cref="Denominator"/></c>.

        /// </summary>

        public BigInteger Quotient => Numerator / Denominator;

​

        /// <summary>

        /// <c><see cref="Numerator"/> % <see cref="Denominator"/></c>.

        /// </summary>

        public BigInteger Remainder => Numerator % Denominator;

​

        /// <inheritdoc cref="BigRational(BigInteger)"/>

        /// <param name="denominator">Denominator of this number.</param>

        /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="denominator"/> is 0.</exception>

        public BigRational(BigInteger numerator, BigInteger denominator)

        {

            if (denominator == 0) throw new ArgumentOutOfRangeException(nameof(denominator), denominator, "Can't be 0.");

            Numerator = numerator;

            Denominator = denominator;

        }

​

        /// <summary>

        /// Produces a representation of a rational number of arbitrary length and precition.

        /// </summary>

        /// <param name="numerator">Numerator of this number.</param>

        public BigRational(BigInteger numerator) : this(numerator, BigInteger.One) { }

​

        /// <summary>

        /// Compares <paramref name="other"/> with the current instance.

        /// </summary>

        /// <param name="other">Element to compare.</param>

        /// <returns>Comparison value.</returns>

        public int CompareTo(BigRational other)

        {

            BigInteger integer = BigInteger.DivRem(Numerator, Denominator, out BigInteger remainder);

            BigInteger otherInteger = BigInteger.DivRem(other.Numerator, other.Denominator, out BigInteger otherRemainder);

​

            int comparison = integer.CompareTo(otherInteger);

            if (comparison == 0)

                comparison = remainder.CompareTo(otherRemainder);

            return comparison;

        }

​

        /// <summary>

        /// Determines whenever the instance <paramref name="obj"/> is equals to the current instance.

        /// </summary>

        /// <param name="obj">Object to compare.</param>

        /// <returns><see langword="true"/> if <paramref name="obj"/> and this instance are equal. Otherwise <see langword="false"/>.</returns>

        public override bool Equals(object obj) => obj is BigRational rational && Equals(rational);

​

        /// <inheritdoc cref="Equals(object)"/> 

        public bool Equals(BigRational other)

        {

            BigRational reduced = Reduced;

            other = other.Reduced;

            return reduced.Numerator == other.Numerator && Numerator == other.Numerator;

        }

​

        /// <summary>

        /// Produces the hash code of this instance.

        /// </summary>

        /// <returns>Hash value of this instance.</returns>

        public override int GetHashCode() => HashCode.Combine(Numerator, Denominator);

​

        /// <summary>

        /// Produces an <see cref="string"/> representation of this instance as a fraction.

        /// </summary>

        /// <returns><see cref="string"/> representation of this instance.</returns>

        public override string ToString()

        {

            BigRational reduced = Reduced;

            if (reduced.Denominator == 1)

                return reduced.Numerator.ToString();

            return $"{reduced.Numerator}/{reduced.Denominator}";

        }

​

        /// <summary>

        /// Produces an <see cref="string"/> representation of this instance as a fraction.

        /// </summary>

        /// <returns><see cref="string"/> representation of this instance.</returns>

        public string ToStringMixedFraction()

        {

            BigRational reduced = Reduced;

​

            BigInteger quotient = reduced.Quotient;

            if (quotient == 0)

                return ToString();

​

            BigInteger remainder = reduced.Remainder;

            if (remainder == 0)

                return quotient.ToString();

​

            return $"{quotient} {reduced.Remainder}/{reduced.Denominator}";

        }

​

        /// <summary>

        /// Produces an <see cref="string"/> representation of this instance as a decimal.

        /// </summary>

        /// <returns><see cref="string"/> representation of this instance.</returns>

        public string ToStringDecimal()

        {

            BigRational reduced = Reduced;

​

            BigInteger quotient = reduced.Quotient;

            if (quotient == 0)

                return $"0.{(((decimal)reduced.Numerator) / ((decimal)reduced.Denominator)).ToString().Substring(2)}";

​

            BigInteger remainder = reduced.Remainder;

            if (remainder == 0)

                return quotient.ToString();

​

            return $"{quotient}.{(((decimal)reduced.Remainder) / ((decimal)reduced.Denominator)).ToString().Substring(2)}";

        }

        private static readonly BigInteger ten = new BigInteger(10);

        public BigRational(double value)

        {

            if (value == 0)

            {

                Numerator = BigInteger.Zero;

                Denominator = BigInteger.One;

            }

​

            int sign = Math.Sign(value);

            value = Math.Abs(value);

            BigInteger numerator = new BigInteger(value);

            BigInteger denominator = BigInteger.One;

​

            while (true)

            {

                value = (value - Math.Floor(value)) * 10;

                if (value == 0)

                    break;

                numerator *= ten;

                numerator += new BigInteger(value);

                denominator *= ten;

            }

​

            numerator *= sign;

​

            BigInteger gcd = BigInteger.GreatestCommonDivisor(numerator, denominator);

​

            Numerator = numerator / gcd;

            Denominator = denominator / gcd;

        }

    }