Полноценный класс дроби (работа с обычными дробями) C#

class Factor
{
    public int Enumerator { get { return _enum; } set { _enum = value; } }
    public int Denumerator { get { return _denum; } set { _denum = value; } }
 
    int _enum;
    int _denum;
 
    public Factor(int e, int d)
    {
        SetED(e, d);
    }
    public Factor(string fact)
    {
        var s = fact.Split('/');
        SetED(int.Parse(s[0]), int.Parse(s[1]));
    }
    public Factor(double d)
    {
        int i = 0;
        while (d % 1 != 0)
        {
            d *= 10;
            i++;
        }
        SetED((int)d, (int)Math.Pow(10, i));
    }
    void SetED(int e, int d)
    {
 
        _enum = e;
        if (d == 0) throw new DivideByZeroException();
        _denum = d;
        Optimize();
    }
    void Optimize()
    {
        if (_denum == 1) return;
        else if (_enum % _denum == 0)
        {
            _enum /= _denum;
            _denum = 1;
        }
        else if (isSimple(_enum)) return;
        else
        {
            int min = Abs(_enum) > Abs(_denum) ? _denum : _enum;
            for (int i = 2; i < min; i++)
                if (isSimple(i))
                    if (_enum % i == 0 && _denum % i == 0)
                    {
                        _enum /= i;
                        _denum /= i;
                        Optimize();
                    }
        }
    }
    bool isSimple(int val)
    {
        val = Abs(val);
        for (int i = 2; i <= val / 2; i++)
            if (val % i == 0) return false;
        return true;
    }
    int Abs(int i)
    {
        if (i >= 0) return i;
        else return -i;
    }
    
    public override string ToString()
    {
        return _denum != 1 ? String.Format("{0}/{1}",
            Enumerator, _denum) : (Enumerator / _denum).ToString();
    }
    public static Factor operator +(Factor f1, Factor f2)
    {
        return new Factor(f1.Enumerator * f2._denum + f2.Enumerator * f1._denum,
            f1._denum * f2._denum);
    }
    public static Factor operator -(Factor f1, Factor f2)
    {
        return new Factor(f1.Enumerator * f2._denum - f2.Enumerator * f1._denum,
            f1._denum * f2._denum);
    }
    public static Factor operator *(Factor f1, Factor f2)
    {
        return new Factor(f1.Enumerator * f2.Enumerator, f1._denum * f2._denum);
    }
    public static Factor operator /(Factor f1, Factor f2)
    {
        return new Factor(f1.Enumerator * f2._denum, f1._denum * f2.Enumerator);
    }
    public static Factor operator +(Factor f1, int i)
    {
        return new Factor(f1.Enumerator + i * f1._denum, f1._denum);
    }
    public static Factor operator -(Factor f1, int i)
    {
        return new Factor(f1.Enumerator - i * f1._denum, f1._denum);
    }
    public static Factor operator *(Factor f1, int i)
    {
        return new Factor(f1.Enumerator * i, f1._denum);
    }
    public static Factor operator /(Factor f1, int i)
    {
        return new Factor(f1.Enumerator, f1._denum * i);
    }
    public static explicit operator double (Factor f)
    {
        return (double)f.Enumerator / (double)f.Denumerator;
    }
    public static explicit operator int(Factor f)
    {
        return (int)(double)f;
    }
}