C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
public class Program{
	public static void Main(){
		ImaginaryInt i = 1;
		ComplexInt z1 = 7479 + 10667 * i;
		ComplexInt z2 = 5274 + 9553 * i;
		ComplexFraction zF1 = new ComplexFraction(z1, z2);
		ComplexFraction zF2 = 1;
		Console.WriteLine(z2 * z2);
		Console.WriteLine(z2.SquaredNorm());
		Console.WriteLine("");
		Console.WriteLine(zF1);
		Console.WriteLine(zF1.reciprocal());
		Console.WriteLine("");
		Console.WriteLine((ComplexDouble) zF1);
		Console.WriteLine((ComplexDouble) zF1.reciprocal());
	}
}
public class ComplexDouble {
    public double A { get; set; }
    public ImaginaryDouble B { get; set; }
    public ComplexDouble(double real_, double imag_) {
        A = real_;
        B = imag_;
    }
    public ComplexDouble(double real_, ImaginaryDouble imag_) {
        A = real_;
        B = imag_;
    }
    //If the object is initiated to a double or imaginary double, convert to a complex double with the other number at 0
    public static implicit operator ComplexDouble(int real_) => new ComplexDouble(real_, 0);
    public static implicit operator ComplexDouble(ImaginaryInt imag_) => new ComplexDouble(0, imag_);
    public static implicit operator ComplexDouble(float real_) => new ComplexDouble(real_, 0);
    public static implicit operator ComplexDouble(ImaginaryFloat imag_) => new ComplexDouble(0, imag_);
    public static implicit operator ComplexDouble(double real_) => new ComplexDouble(real_, 0);
    public static implicit operator ComplexDouble(ImaginaryDouble imag_) => new ComplexDouble(0, imag_);
    public static implicit operator ComplexDouble(ComplexInt z) => new ComplexDouble(z.A, z.B);
    public static implicit operator ComplexDouble(ComplexFloat z) => new ComplexDouble(z.A, z.B);
    //Cast to float to get the norm part of the complex number
    public static explicit operator int(ComplexDouble z) => (int)Math.Sqrt(z.SquaredNorm());
    public static explicit operator float(ComplexDouble z) => (float)Math.Sqrt(z.SquaredNorm());
    public static explicit operator double(ComplexDouble z) => (double)Math.Sqrt(z.SquaredNorm());
    public static explicit operator ComplexInt(ComplexDouble z) => new ComplexInt((int)z.A, (int)z.B);
    public static explicit operator ComplexFloat(ComplexDouble z) => new ComplexFloat((float)z.A, (float)z.B);
    //Addition operators
    public static ComplexDouble operator +(ComplexDouble z1, ComplexDouble z2) => new ComplexDouble(z1.A + z2.A, z1.B + z2.B);
    public static ComplexDouble operator ++(ComplexDouble z) {
        if (z == 0) {
            return 1;
        } else {
            return z + new ComplexDouble(Math.Abs(z.A) / ((double)z), ComplexMath.Abs(z.B) / ((double)z));
        }
    }
    //Unary+
    public static ComplexDouble operator +(ComplexDouble z) => z;
    //Subtraction operators
    public static ComplexDouble operator -(ComplexDouble z1, ComplexDouble z2) => new ComplexDouble(z1.A - z2.A, z1.B - z2.B);
    public static ComplexDouble operator --(ComplexDouble z) {
        if (z == 0) {
            return -1;
        } else {
            return z - new ComplexDouble(Math.Abs(z.A) / ((double)z), ComplexMath.Abs(z.B) / ((double)z));
        }
    }
    //Negation operator
    public static ComplexDouble operator -(ComplexDouble z) => new ComplexDouble(-z.A, -z.B);
    //Multiplication operators (a+bi)(c+di)=(ac-bd)+i(bc+ad)
    public static ComplexDouble operator *(ComplexDouble z1, ComplexDouble z2) => new ComplexDouble(z1.A * z2.A + z1.B * z2.B, z1.B * z2.A + z1.A * z2.B);
    //Division operators
    public static ComplexDouble operator /(ComplexDouble z1, ComplexDouble z2) => new ComplexDouble((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    //Remainder operators
    public static ComplexDouble operator %(ComplexDouble z1, ComplexDouble z2) => z1 - ((ComplexInt)(z1 / z2)) * z2;
    //Non-static mathematical functions
    public ComplexDouble Conjugate() => new ComplexDouble(A, -B);
    public double SquaredNorm() => A * A - B * B;
    public double SquaredNormSigns() => Math.Abs(A) * A + Math.Abs(B.Value) * B.Value;
    //Complex number comparisons, for greater than / less than, which point is further from the origin
    public static bool operator ==(ComplexDouble z1, ComplexDouble z2) => z1.A == z2.A && z1.B == z2.B;
    public static bool operator !=(ComplexDouble z1, ComplexDouble z2) => !(z1 == z2);
    public static bool operator >=(ComplexDouble z1, ComplexDouble z2) => z1.SquaredNorm() >= z2.SquaredNorm();
    public static bool operator <=(ComplexDouble z1, ComplexDouble z2) => z1.SquaredNorm() <= z2.SquaredNorm();
    public static bool operator >(ComplexDouble z1, ComplexDouble z2) => z1.SquaredNorm() > z2.SquaredNorm();
    public static bool operator <(ComplexDouble z1, ComplexDouble z2) => z1.SquaredNorm() < z2.SquaredNorm();
    public override bool Equals(object obj) {
        if (obj is ComplexDouble z) {
            return new ComplexDouble(A, B) == z;
        } else {
            return false;
        }
    }
    //Out methods
    public void GetRealAndImag(out double a, out double b) {
        a = A;
        b = (int)B;
    }
    //Hash code
    public override int GetHashCode() => (int)A & (int)B;
    //Deconstruction
    public void Deconstruct(out double real_, out ImaginaryDouble imag_) {
        real_ = A;
        imag_ = B;
    }
    //String representation
    public override string ToString() {
        string sign = B < 0 ? "-" : (B > 0 ? "+" : "-");
        if (A == 0) {
            return B == 0 ? "0" : $"{B}";
        } else {
            return B == 0 ? $"{A}" : Math.Abs(B.Value) == 1 ? $"{A} {sign} i" : $"{A} {sign} {Math.Abs(B.Value)}i";
        }
    }
}
public class ImaginaryDouble {
    public double Value { get; set; }
    private ImaginaryDouble(double imag_) {
        Value = imag_;
    }
    //If imaginary is initiated with a float, convert to imaginary number
    public static implicit operator ImaginaryDouble(double num) => new ImaginaryDouble(num);
    public static implicit operator ImaginaryDouble(ImaginaryInt z) => new ImaginaryDouble(z.Value);
    public static implicit operator ImaginaryDouble(ImaginaryFloat z) => new ImaginaryDouble(z.Value);
    //Cast imaginary number to other number types
    public static explicit operator int(ImaginaryDouble num) => (int)num.Value;
    public static explicit operator float(ImaginaryDouble num) => (float)num.Value;
    public static explicit operator double(ImaginaryDouble num) => num.Value;
    public static explicit operator decimal(ImaginaryDouble num) => (decimal)num.Value;
    public static explicit operator ImaginaryInt(ImaginaryDouble num) => (int)num.Value;
    public static explicit operator ImaginaryFloat(ImaginaryDouble num) => (float)num.Value;
    //Addition operators
    public static ImaginaryDouble operator +(ImaginaryDouble i1, ImaginaryDouble i2) => new ImaginaryDouble(i1.Value + i2.Value);
    public static ComplexDouble operator +(ImaginaryDouble i, double r) => new ComplexDouble(r, i);
    public static ComplexDouble operator +(double r, ImaginaryDouble i) => new ComplexDouble(r, i);
    //Unary +
    public static ImaginaryDouble operator +(ImaginaryDouble i) => i;
    //Increment operator
    public static ImaginaryDouble operator ++(ImaginaryDouble z1) => new ImaginaryDouble(z1.Value + 1);
    //Subtraction operators
    public static ImaginaryDouble operator -(ImaginaryDouble i1, ImaginaryDouble i2) => new ImaginaryDouble(i1.Value - i2.Value);
    public static ComplexDouble operator -(ImaginaryDouble i, double r) => new ComplexDouble(-r, i);
    public static ComplexDouble operator -(double r, ImaginaryDouble i) => new ComplexDouble(r, -i);
    //Decrement operator
    public static ImaginaryDouble operator --(ImaginaryDouble z1) => new ImaginaryDouble(z1.Value - 1);
    //Negation operator
    public static ImaginaryDouble operator -(ImaginaryDouble i) => new ImaginaryDouble(-i.Value);
    //Multiplication operators
    public static double operator *(ImaginaryDouble i1, ImaginaryDouble i2) => -i1.Value * i2.Value;
    public static ImaginaryDouble operator *(ImaginaryDouble i, double other) => new ImaginaryDouble(i.Value * other);
    public static ImaginaryDouble operator *(double other, ImaginaryDouble i) => new ImaginaryDouble(i.Value * other);
    //Division operators
    public static double operator /(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value / i2.Value;
    public static ImaginaryDouble operator /(ImaginaryDouble i, double other) => new ImaginaryDouble(i.Value / other);
    public static ImaginaryDouble operator /(double other, ImaginaryDouble i) => new ImaginaryDouble(-other / i.Value);
    //Comparison operators
    public static bool operator <(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value < i2.Value;
    public static bool operator >(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value > i2.Value;
    public static bool operator ==(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value == i2.Value;
    public static bool operator !=(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value != i2.Value;
    public static bool operator <=(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value <= i2.Value;
    public static bool operator >=(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value >= i2.Value;
    public override bool Equals(object obj) => obj is ImaginaryDouble @doubleObj && Value == @doubleObj;
    //Hash code
    public override int GetHashCode() => (int)Value;
    //Static mathematical operations
    //String representation
    public override string ToString() => Value == 0 ? "0" : (Math.Abs(Value) == 1 ? $"{(Value < 0 ? "-" : "")}i" : $"{(Value < 0 ? "-" : "")}{Math.Abs(Value)}i");
}
public class ComplexFloat {
    public float A { get; set; }
    public ImaginaryFloat B { get; set; }
    public ComplexFloat(float real_, float imag_) {
        A = real_;
        B = imag_;
    }
    public ComplexFloat(float real_, ImaginaryFloat imag_) {
        A = real_;
        B = imag_;
    }
    //If the object is initiated to a double or imaginary double, convert to a complex double with the other number at 0
    public static implicit operator ComplexFloat(int real_) => new ComplexFloat(real_, 0);
    public static implicit operator ComplexFloat(ImaginaryInt imag_) => new ComplexFloat(0, imag_);
    public static implicit operator ComplexFloat(float real_) => new ComplexFloat(real_, 0);
    public static implicit operator ComplexFloat(ImaginaryFloat imag_) => new ComplexFloat(0, imag_);
    public static implicit operator ComplexFloat(ComplexInt z) => new ComplexFloat(z.A, z.B);
    //Cast to types to get the norm part of the complex number
    public static explicit operator int(ComplexFloat z) => (int)Math.Sqrt(z.SquaredNorm());
    public static explicit operator float(ComplexFloat z) => (float)Math.Sqrt(z.SquaredNorm());
    public static explicit operator double(ComplexFloat z) => Math.Sqrt(z.SquaredNorm());
    public static explicit operator ComplexInt(ComplexFloat z) => new ComplexInt((int)z.A, (int)z.B);
    //Addition operators
    public static ComplexFloat operator +(ComplexFloat z1, ComplexFloat z2) => new ComplexFloat(z1.A + z2.A, z1.B + z2.B);
    public static ComplexDouble operator +(ComplexFloat z1, ComplexDouble z2) => new ComplexDouble(z1.A + z2.A, z1.B + z2.B);
    public static ComplexDouble operator +(ComplexDouble z1, ComplexFloat z2) => new ComplexDouble(z1.A + z2.A, z1.B + z2.B);
    public static ComplexFloat operator ++(ComplexFloat z) {
        if (z == 0) {
            return 1;
        } else {
            return z + new ComplexFloat(Math.Abs(z.A) / ((float)z), (float)(ComplexMath.Abs(z.B) / ((float)z)));
        }
    }
    //Unary +
    public static ComplexFloat operator +(ComplexFloat z) => z;
    //Subtraction operators
    public static ComplexFloat operator -(ComplexFloat z1, ComplexFloat z2) => new ComplexFloat(z1.A - z2.A, z1.B - z2.B);
    public static ComplexDouble operator -(ComplexFloat z1, ComplexDouble z2) => new ComplexDouble(z1.A - z2.A, z1.B - z2.B);
    public static ComplexDouble operator -(ComplexDouble z1, ComplexFloat z2) => new ComplexDouble(z1.A - z2.A, z1.B - z2.B);
    public static ComplexFloat operator --(ComplexFloat z) {
        if (z == 0) {
            return -1;
        } else {
            return z - new ComplexFloat(Math.Abs(z.A) / ((float)z), (float)(ComplexMath.Abs(z.B) / ((float)z)));
        }
    }
    //Negation operator
    public static ComplexFloat operator -(ComplexFloat z) => new ComplexFloat(-z.A, -z.B);
    //Multiplication operators (a+bi)(c+di)=(ac-bd)+i(bc+ad)
    public static ComplexFloat operator *(ComplexFloat z1, ComplexFloat z2) => new ComplexFloat(z1.A * z2.A + z1.B * z2.B, z1.B * z2.A + z1.A * z2.B);
    public static ComplexDouble operator *(ComplexFloat z1, ComplexDouble z2) => new ComplexDouble(z1.A * z2.A + z1.B * z2.B, z1.B * z2.A + z1.A * z2.B);
    public static ComplexDouble operator *(ComplexDouble z1, ComplexFloat z2) => new ComplexDouble(z1.A * z2.A + z1.B * z2.B, z1.B * z2.A + z1.A * z2.B);
    //Division operators
    public static ComplexFloat operator /(ComplexFloat z1, ComplexFloat z2) => new ComplexFloat((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    public static ComplexDouble operator /(ComplexFloat z1, ComplexDouble z2) => new ComplexDouble((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    public static ComplexDouble operator /(ComplexDouble z1, ComplexFloat z2) => new ComplexDouble((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    //Remainder operators
    public static ComplexFloat operator %(ComplexFloat z1, ComplexFloat z2) => z1 - ((ComplexInt)(z1 / z2)) * z2;
    //Non-static mathematical functions
    public ComplexDouble Conjugate() => new ComplexDouble(A, -B);
    public float SquaredNorm() => A * A - B * B;
    public float SquaredNormSigns() => Math.Abs(A) * A + Math.Abs(B.Value) * B.Value;
    //Complex number comparisons, for greater than / less than, which point is further from the origin
    public static bool operator ==(ComplexFloat z1, ComplexFloat z2) => z1.A == z2.A && z1.B == z2.B;
    public static bool operator !=(ComplexFloat z1, ComplexFloat z2) => !(z1 == z2);
    public static bool operator >=(ComplexFloat z1, ComplexFloat z2) => z1.SquaredNorm() >= z2.SquaredNorm();
    public static bool operator <=(ComplexFloat z1, ComplexFloat z2) => z1.SquaredNorm() <= z2.SquaredNorm();
    public static bool operator >(ComplexFloat z1, ComplexFloat z2) => z1.SquaredNorm() > z2.SquaredNorm();
    public static bool operator <(ComplexFloat z1, ComplexFloat z2) => z1.SquaredNorm() < z2.SquaredNorm();
    public override bool Equals(object obj) {
        if (obj is ComplexDouble z) {
            return new ComplexDouble(A, B) == z;
        } else {
            return false;
        }
    }
    //Out methods
    public void GetRealAndImag(out float a, out float b) {
        a = A;
        b = (int)B;
    }
    //Hash code
    public override int GetHashCode() => (int)A & (int)B;
    //Deconstruction
    public void Deconstruct(out float real_, out ImaginaryFloat imag_) {
        real_ = A;
        imag_ = B;
    }
    //String representation
    public override string ToString() {
        string sign = B < 0 ? "-" : (B > 0 ? "+" : "-");
        if (A == 0) {
            return B == 0 ? "0" : $"{B}";
        } else {
            return B == 0 ? $"{A}" : Math.Abs(B.Value) == 1 ? $"{A} {sign} i" : $"{A} {sign} {Math.Abs(B.Value)}i";
        }
    }
}
public class ImaginaryFloat {
    public float Value { get; set; }
    private ImaginaryFloat(float imag_) {
        Value = imag_;
    }
    //If imaginary is initiated with a float, convert to imaginary number
    public static implicit operator ImaginaryFloat(float num) => new ImaginaryFloat(num);
    public static implicit operator ImaginaryFloat(ImaginaryInt num) => new ImaginaryFloat(num.Value);
    //Cast imaginary number to other number types
    public static explicit operator int(ImaginaryFloat num) => (int)num.Value;
    public static explicit operator float(ImaginaryFloat num) => num.Value;
    public static explicit operator double(ImaginaryFloat num) => num.Value;
    public static explicit operator decimal(ImaginaryFloat num) => (decimal)num.Value;
    //Addition operators
    public static ImaginaryFloat operator +(ImaginaryFloat i1, ImaginaryFloat i2) => new ImaginaryFloat(i1.Value + i2.Value);
    public static ComplexFloat operator +(ImaginaryFloat i, float r) => new ComplexFloat(r, i);
    public static ComplexFloat operator +(float r, ImaginaryFloat i) => new ComplexFloat(r, i);
    public static ComplexDouble operator +(ImaginaryFloat i, double r) => new ComplexDouble(r, i);
    public static ComplexDouble operator +(double r, ImaginaryFloat i) => new ComplexDouble(r, i);
    //Increment operator
    public static ImaginaryFloat operator ++(ImaginaryFloat z1) => new ImaginaryFloat(z1.Value + 1);
    //Unary +
    public static ImaginaryFloat operator +(ImaginaryFloat i) => i;
    //Subtraction operators
    public static ImaginaryFloat operator -(ImaginaryFloat i1, ImaginaryFloat i2) => new ImaginaryFloat(i1.Value - i2.Value);
    public static ComplexFloat operator -(ImaginaryFloat i, float r) => new ComplexFloat(-r, i);
    public static ComplexFloat operator -(float r, ImaginaryFloat i) => new ComplexFloat(r, -i);
    public static ComplexDouble operator -(ImaginaryFloat i, double r) => new ComplexDouble(-r, i);
    public static ComplexDouble operator -(double r, ImaginaryFloat i) => new ComplexDouble(r, -i);
    //Decrement operator
    public static ImaginaryFloat operator --(ImaginaryFloat z1) => new ImaginaryFloat(z1.Value - 1);
    //Negation operator
    public static ImaginaryFloat operator -(ImaginaryFloat i) => new ImaginaryFloat(-i.Value);
    //Multiplication operators
    public static float operator *(ImaginaryFloat i1, ImaginaryFloat i2) => -i1.Value * i2.Value;
    public static ImaginaryFloat operator *(ImaginaryFloat i, float other) => new ImaginaryFloat(i.Value * other);
    public static ImaginaryFloat operator *(float other, ImaginaryFloat i) => new ImaginaryFloat(i.Value * other);
    public static ImaginaryDouble operator *(ImaginaryFloat i, double other) => i.Value * other;
    public static ImaginaryDouble operator *(double other, ImaginaryFloat i) => i.Value * other;
    //Division operators
    public static float operator /(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value / i2.Value;
    public static ImaginaryFloat operator /(ImaginaryFloat i, float other) => new ImaginaryFloat(i.Value / other);
    public static ImaginaryFloat operator /(float other, ImaginaryFloat i) => new ImaginaryFloat(-other / i.Value);
    public static ImaginaryDouble operator /(ImaginaryFloat i, double other) => i.Value / other;
    public static ImaginaryDouble operator /(double other, ImaginaryFloat i) => -other / i.Value;
    //Comparison operators
    public static bool operator <(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value < i2.Value;
    public static bool operator >(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value > i2.Value;
    public static bool operator ==(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value == i2.Value;
    public static bool operator !=(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value != i2.Value;
    public static bool operator <=(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value <= i2.Value;
    public static bool operator >=(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value >= i2.Value;
    public override bool Equals(object obj) => obj is ImaginaryDouble @doubleObj && Value == @doubleObj;
    //Hash code
    public override int GetHashCode() => (int)Value;
    //Static mathematical operations
    //String representation
    public override string ToString() => Value == 0 ? "0" : (Math.Abs(Value) == 1 ? $"{(Value < 0 ? "-" : "")}i" : $"{(Value < 0 ? "-" : "")}{Math.Abs(Value)}i");
}
public class ComplexInt {
    public int A { get; set; }
    public ImaginaryInt B { get; set; }
    public ComplexInt(int a_, int b_) {
        A = a_;
        B = b_;
    }
    public ComplexInt(int a_, ImaginaryInt b_) {
        A = a_;
        B = b_;
    }
    //Implicit operators
    public static implicit operator ComplexInt(int d) => new ComplexInt(d, 0);
    public static implicit operator ComplexInt(ImaginaryInt d) => new ComplexInt(0, d);
    //Explicit operators
    public static explicit operator int(ComplexInt d) => (int)Math.Sqrt(d.A * ((double)d.A) + ((double)d.B) * ((double)d.B));
    public static explicit operator float(ComplexInt d) => (float)Math.Sqrt(d.A * ((double)d.A) + ((double)d.B) * ((double)d.B));
    public static explicit operator double(ComplexInt d) => Math.Sqrt(d.A * ((double)d.A) + ((double)d.B) * ((double)d.B));
    //Addition operators
    public static ComplexInt operator +(ComplexInt z1, ComplexInt z2) => new ComplexInt(z1.A + z2.A, z1.B + z2.B);
    public static ComplexFloat operator +(ComplexInt z1, ComplexFloat z2) => new ComplexFloat(z1.A + z2.A, z1.B + z2.B);
    public static ComplexFloat operator +(ComplexFloat z1, ComplexInt z2) => new ComplexFloat(z1.A + z2.A, z1.B + z2.B);
    public static ComplexDouble operator +(ComplexInt z1, ComplexDouble z2) => new ComplexDouble(z1.A + z2.A, z1.B + z2.B);
    public static ComplexDouble operator +(ComplexDouble z1, ComplexInt z2) => new ComplexDouble(z1.A + z2.A, z1.B + z2.B);
    public static ComplexInt operator ++(ComplexInt z1) {
        if (z1 == 0) {
            return 1;
        } else {
            return z1 + (ComplexInt)(new ComplexDouble((int)(Math.Abs(z1.A) * 1.99999999), (int)(z1.B * 1.99999999)) / ((double)z1));
        }
    }
    //Unary +
    public static ComplexInt operator +(ComplexInt i) => i;
    //Subtraction operators
    public static ComplexInt operator --(ComplexInt z1) => z1 - new ComplexInt((int)(Math.Abs(z1.A) * 1.99999999), (int)(z1.B * 1.99999999)) / ((int)z1);
    public static ComplexInt operator -(ComplexInt z1, ComplexInt z2) => new ComplexInt(z1.A - z2.A, z1.B - z2.B);
    public static ComplexFloat operator -(ComplexInt z1, ComplexFloat z2) => new ComplexFloat(z1.A - z2.A, z1.B - z2.B);
    public static ComplexFloat operator -(ComplexFloat z1, ComplexInt z2) => new ComplexFloat(z1.A - z2.A, z1.B - z2.B);
    public static ComplexDouble operator -(ComplexInt z1, ComplexDouble z2) => new ComplexDouble(z1.A - z2.A, z1.B - z2.B);
    public static ComplexDouble operator -(ComplexDouble z1, ComplexInt z2) => new ComplexDouble(z1.A - z2.A, z1.B - z2.B);
    //Negation Operator
    public static ComplexInt operator -(ComplexInt z1) => new ComplexInt(-z1.A, -z1.B);
    //Multiplication operators
    public static ComplexInt operator *(ComplexInt z1, ComplexInt z2) => new ComplexInt(z1.B * z2.B + z1.A * z2.A, z1.A * z2.B + z1.B * z2.A);
    public static ComplexFloat operator *(ComplexInt z1, ComplexFloat z2) => new ComplexFloat(z1.B * z2.B + z1.A * z2.A, z1.A * z2.B + z1.B * z2.A);
    public static ComplexFloat operator *(ComplexFloat z1, ComplexInt z2) => new ComplexFloat(z1.B * z2.B + z1.A * z2.A, z1.A * z2.B + z1.B * z2.A);
    public static ComplexDouble operator *(ComplexInt z1, ComplexDouble z2) => new ComplexDouble(z1.B * z2.B + z1.A * z2.A, z1.A * z2.B + z1.B * z2.A);
    public static ComplexDouble operator *(ComplexDouble z1, ComplexInt z2) => new ComplexDouble(z1.B * z2.B + z1.A * z2.A, z1.A * z2.B + z1.B * z2.A);
    //Division operators
    public static ComplexInt operator /(ComplexInt z1, ComplexInt z2) => new ComplexInt((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    public static ComplexFloat operator /(ComplexInt z1, ComplexFloat z2) => new ComplexFloat((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    public static ComplexFloat operator /(ComplexFloat z1, ComplexInt z2) => new ComplexFloat((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    public static ComplexDouble operator /(ComplexInt z1, ComplexDouble z2) => new ComplexDouble((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    public static ComplexDouble operator /(ComplexDouble z1, ComplexInt z2) => new ComplexDouble((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    //Remainder operators
    public static ComplexInt operator %(ComplexInt z1, ComplexInt z2) => z1 - (z1 / z2) * z2;
    //Bitwise operators
    public static ComplexInt operator <<(ComplexInt z, int d) => new ComplexInt(z.A << d, z.B << d);
    public static ComplexInt operator >>(ComplexInt z, int d) => new ComplexInt(z.A >> d, z.B >> d);
	//Non-static mathematical functions
    public ComplexInt Conjugate() => new ComplexInt(A, -B);
    public int SquaredNorm() => A * A - B * B;
    public int SquaredNormSigns() => Math.Abs(A) * A + Math.Abs(B.Value) * B.Value;
    //Complex number comparisons, for greater than / less than, which point is further from the origin
    public static bool operator ==(ComplexInt z1, ComplexInt z2) => z1.A == z2.A && z1.B == z2.B;
    public static bool operator !=(ComplexInt z1, ComplexInt z2) => !(z1 == z2);
    public static bool operator >=(ComplexInt z1, ComplexInt z2) => z1.SquaredNorm() >= z2.SquaredNorm();
    public static bool operator <=(ComplexInt z1, ComplexInt z2) => z1.SquaredNorm() <= z2.SquaredNorm();
    public static bool operator >(ComplexInt z1, ComplexInt z2) => z1.SquaredNorm() > z2.SquaredNorm();
    public static bool operator <(ComplexInt z1, ComplexInt z2) => z1.SquaredNorm() < z2.SquaredNorm();
    public override bool Equals(object obj) {
        if (obj is ComplexInt z) {
            return new ComplexInt(A, B) == z;
        } else {
            return false;
        }
    }
    //Out methods
    public void GetRealAndImag(out int a, out int b) {
        a = A;
        b = (int)B;
    }
    //Hash code
    public override int GetHashCode() => A & (int)B;
    //Deconstruction
    public void Deconstruct(out int real_, out ImaginaryInt imag_) {
        real_ = A;
        imag_ = B;
    }
    //String
    public override string ToString() {
        string sign = B < 0 ? "-" : (B > 0 ? "+" : "-");
        if (A == 0) {
            return B == 0 ? "0" : $"{B}";
        } else {
            return B == 0 ? $"{A}" : Math.Abs(B.Value) == 1 ? $"{A} {sign} i" : $"{A} {sign} {Math.Abs(B.Value)}i";
        }
    }
}
public class ImaginaryInt {
    public int Value { get; set; }
    private ImaginaryInt(int b_) {
        Value = b_;
    }
    //Implicit conversions
    public static implicit operator ImaginaryInt(int d) => new ImaginaryInt(d);
    //Explicit conversions
    public static explicit operator ImaginaryInt(float a) => new ImaginaryInt((int)a);
    public static explicit operator ImaginaryInt(double a) => new ImaginaryInt((int)a);
    public static explicit operator int(ImaginaryInt a) => a.Value;
    public static explicit operator float(ImaginaryInt a) => a.Value;
    public static explicit operator double(ImaginaryInt a) => a.Value;
    //Addition operators
    public static ImaginaryInt operator +(ImaginaryInt a1, ImaginaryInt a2) => a1.Value + a2.Value;
    public static ComplexInt operator +(ImaginaryInt a, int r) => new ComplexInt(r, a.Value);
    public static ComplexInt operator +(int r, ImaginaryInt a) => new ComplexInt(r, a.Value);
    public static ComplexFloat operator +(ImaginaryInt a, float r) => new ComplexFloat(r, a.Value);
    public static ComplexFloat operator +(float r, ImaginaryInt a) => new ComplexFloat(r, a.Value);
    public static ComplexDouble operator +(ImaginaryInt a, double r) => new ComplexDouble(r, a.Value);
    public static ComplexDouble operator +(double r, ImaginaryInt a) => new ComplexDouble(r, a.Value);
    //Unary +
    public static ImaginaryInt operator +(ImaginaryInt i) => i;
    //Increment operator
    public static ImaginaryInt operator ++(ImaginaryInt z1) => z1.Value + 1;
    //Subtraction operators
    public static ImaginaryInt operator -(ImaginaryInt a1, ImaginaryInt a2) => a1.Value - a2.Value;
    public static ComplexInt operator -(ImaginaryInt a, int r) => new ComplexInt(-r, a.Value);
    public static ComplexInt operator -(int r, ImaginaryInt a) => new ComplexInt(r, -a.Value);
    public static ComplexFloat operator -(ImaginaryInt a, float r) => new ComplexFloat(-r, a.Value);
    public static ComplexFloat operator -(float r, ImaginaryInt a) => new ComplexFloat(r, -a.Value);
    public static ComplexDouble operator -(ImaginaryInt a, double r) => new ComplexDouble(-r, a.Value);
    public static ComplexDouble operator -(double r, ImaginaryInt a) => new ComplexDouble(r, -a.Value);
    //Decrement operator
    public static ImaginaryInt operator --(ImaginaryInt z1) => z1.Value - 1;
    //Negation operator
    public static ImaginaryInt operator -(ImaginaryInt a) => -a.Value;
    //Multiplication operators
    public static int operator *(ImaginaryInt a1, ImaginaryInt a2) => -a1.Value * a2.Value;
    public static ImaginaryInt operator *(int d, ImaginaryInt a) => a.Value * d;
    public static ImaginaryInt operator *(ImaginaryInt a, int d) => a.Value * d;
    public static ImaginaryFloat operator *(float d, ImaginaryInt a) => a.Value * d;
    public static ImaginaryFloat operator *(ImaginaryInt a, float d) => a.Value * d;
    public static ImaginaryDouble operator *(double d, ImaginaryInt a) => a.Value * d;
    public static ImaginaryDouble operator *(ImaginaryInt a, double d) => a.Value * d;
    //Division operators
    public static int operator /(ImaginaryInt a1, ImaginaryInt a2) => a1.Value / a2.Value;
    public static ImaginaryInt operator /(ImaginaryInt a, int d) => a.Value / d;
    public static ImaginaryInt operator /(int d, ImaginaryInt a) => -d / a.Value;
    public static ImaginaryFloat operator /(ImaginaryInt a, float d) => a.Value / d;
    public static ImaginaryFloat operator /(float d, ImaginaryInt a) => -d / a.Value;
    public static ImaginaryDouble operator /(ImaginaryInt a, double d) => a.Value / d;
    public static ImaginaryDouble operator /(double d, ImaginaryInt a) => -d / a.Value;
    //Bitwise operators
    public static ImaginaryInt operator <<(ImaginaryInt a, int d) => a.Value << d;
    public static ImaginaryInt operator >>(ImaginaryInt a, int d) => a.Value >> d;
    //Comparison operators
    public static bool operator ==(ImaginaryInt a1, ImaginaryInt a2) => a1.Value == a2.Value;
    public static bool operator !=(ImaginaryInt a1, ImaginaryInt a2) => a1.Value != a2.Value;
    public static bool operator >(ImaginaryInt a1, ImaginaryInt a2) => a1.Value > a2.Value;
    public static bool operator <(ImaginaryInt a1, ImaginaryInt a2) => a1.Value < a2.Value;
    public static bool operator >=(ImaginaryInt a1, ImaginaryInt a2) => a1.Value >= a2.Value;
    public static bool operator <=(ImaginaryInt a1, ImaginaryInt a2) => a1.Value <= a2.Value;
    public override bool Equals(object obj) => obj is ImaginaryInt intObj && Value == intObj;
    //Hash code
    public override int GetHashCode() => Value;
    //String
    public override string ToString() => Value == 0 ? "0" : (Math.Abs(Value) == 1 ? $"{(Value < 0 ? "-" : "")}i" : $"{(Value < 0 ? "-" : "")}{Math.Abs(Value)}i");
}
public class ComplexFraction{
	public readonly ComplexInt num;
	public readonly int den;
	private readonly ComplexInt originalNum;
	private readonly ComplexInt originalDen;
	public ComplexFraction(ComplexInt num, ComplexInt den){
		long largeDen = 1;
		originalNum = num;
		originalDen = den;
		if(den.B == 0){
			this.num = num;
			this.den = den.A;
		}else{
			this.num = (num * den.Conjugate());
			largeDen = den.SquaredNorm();
		}
		while(largeDen > Int32.MaxValue){
			this.num /= 2;
			largeDen /= 2;
		}
		this.den = (int)(largeDen);
		int commonFactor = GCD(GCD(this.num.A, this.den), this.num.B.Value);
		this.num /= commonFactor;
		this.den /= commonFactor;
		originalNum /= commonFactor;
		originalDen /= commonFactor;
		if(this.den < 0){
			this.num *= -1;
			this.den *= -1;
		}
	}
	//Implicit operators
	public static implicit operator ComplexFraction(int n) => new ComplexFraction(n, 1);
	public static implicit operator ComplexFraction(ImaginaryInt n) => new ComplexFraction(n, 1);
	public static implicit operator ComplexFraction(ComplexInt n) => new ComplexFraction(n, 1);
	//Explicit operators
	public static explicit operator ComplexDouble(ComplexFraction n) => n.num / (n.den * 1.0);
	public static explicit operator ComplexFloat(ComplexFraction n) => n.num / (n.den * 1f);
	//Addition operator
	public static ComplexFraction operator +(ComplexFraction a, ComplexFraction b) => new ComplexFraction(a.num * b.den + a.den * b.num, a.den * b.den);
	public static ComplexFraction operator ++(ComplexFraction a) => a + 1;
	public static ComplexFraction operator +(ComplexFraction a) => a;
	//Subtraction operator
	public static ComplexFraction operator -(ComplexFraction a, ComplexFraction b) => new ComplexFraction(a.num * b.den - a.den * b.num, a.den * b.den);
	public static ComplexFraction operator --(ComplexFraction a) => a - 1;
	public static ComplexFraction operator -(ComplexFraction a) => new ComplexFraction(-a.num, -a.den);
	//Multiplication operator
	public static ComplexFraction operator *(ComplexFraction a, ComplexFraction b) => new ComplexFraction(a.num * b.num, a.den * b.den);
	//Division operator
	public static ComplexFraction operator /(ComplexFraction a, ComplexFraction b) => new ComplexFraction(a.num * b.den, a.den * b.num);
	//Other
	public ComplexFraction reciprocal() => new ComplexFraction(originalDen, originalNum);
	public static int GCD(int a, int b) => b == 0 ? a : GCD(b, a % b);
	public override string ToString() => $"({num}){(den == 1 ? "" : $" / {den}")}";
}
//Other mathematical functions
public class ComplexMath {
	public readonly ImaginaryInt I = 1;
    //Return the absolute value of an imaginary and complex number
    public static int Abs(ImaginaryInt i) => Math.Abs(i.Value);
    public static double Abs(ImaginaryDouble i) => Math.Abs(i.Value);
    public static double Abs(ComplexDouble z) => (float)z;
    /// <summary>
    /// Returns the natural logarithm (base e) of a complex number.
    /// </summary>
    /// <returns>
    /// ln(<c>z</c>)
    /// </returns>
    public static ComplexDouble Log(ComplexDouble z) => Math.Log(z.SquaredNorm()) / 2 + (ImaginaryDouble)Math.Atan2(z.B.Value, z.A);
    /// <summary>
    /// Returns the log of a complex valued base of a complex number.
    /// </summary>
    /// <returns>
    /// ln(<c>z</c>) / ln(<c>log_base</c>)
    /// </returns>
    public static ComplexDouble Log(ComplexDouble z, ComplexDouble log_base) => Log(z) / Log(log_base);
    public static ComplexDouble Exp(ComplexDouble z) => Math.Pow(Math.E, z.A) * new ComplexDouble(Math.Cos(z.B.Value), Math.Sin(z.B.Value));
    /// <summary>
    /// Returns a specified complex number to the power of a specified complex number.
    /// </summary>
    /// <returns>
    /// A complex number <c>z1</c> to the power of <c>z2</c>
    /// </returns>
    public static ComplexDouble Pow(ComplexDouble z1, ComplexDouble z2) => Exp(Log(z1) * z2);

    /// <summary>
    /// Returns a specified imaginary number to the power of a specified integer.
    /// </summary>
    /// <returns>
    /// A complex double <c>z</c> to the power of <c>n</c>
    /// </returns>
    public static ComplexDouble Pow(ImaginaryDouble z, int n) {
        if (n % 2 == 0) {
            return Math.Pow(z.Value, n) * (n % 4 == 0 ? 1 : -1);
        } else {
            return (ImaginaryDouble)(Math.Pow(z.Value, n) * (n % 4 == 1 ? 1 : -1));
        }
    }
    /// <summary>
    /// Returns the square root of a complex number.
    /// </summary>
    /// <returns>
    /// The positive integer solution of the square root
    /// </returns>
    public static ComplexDouble Sqrt(ComplexDouble z) {
        if (z.B.Value == 0) {
            if (z.A >= 0) {
                return Math.Sqrt(z.A);
            } else {
                return (ImaginaryDouble)Math.Sqrt(-z.A);
            }
        } else {
            return Pow(z, 0.5);
        }
    }
	public static ComplexDouble Root(ComplexDouble z, int n) => Pow(z, 1.0 / n);
	public static ComplexDouble Root(ComplexDouble z, int n, int rootID) => Pow(z, 1.0 / n) * Exp(((ImaginaryDouble) rootID * Math.PI * 2) / n);
    /// <summary>
    /// Returns the sine of a complex number.
    /// </summary>
    /// <returns>
    /// The sine of <c>z</c>
    /// </returns>
    public static ComplexDouble Sin(ComplexDouble z) => new ComplexDouble(Math.Sin(z.A) * Math.Cosh(z.B.Value), Math.Cos(z.A) * Math.Sinh(z.B.Value));
    /// <summary>
    /// Returns the hyperbolic sine of a complex number.
    /// </summary>
    /// <returns>
    /// The hyperbolic sine of <c>z</c>
    /// </returns>
    public static ComplexDouble Sinh(ComplexDouble z) => new ComplexDouble(Math.Sinh(z.A) * Math.Cos(z.B.Value), Math.Cosh(z.A) * Math.Sin(z.B.Value));
    public static ComplexDouble Cos(ComplexDouble z) => new ComplexDouble(Math.Cos(z.A) * Math.Cosh(z.B.Value), -Math.Sin(z.A) * Math.Sinh(z.B.Value));
    public static ComplexDouble Cosh(ComplexDouble z) => new ComplexDouble(Math.Cosh(z.A) * Math.Cos(z.B.Value), Math.Sinh(z.A) * Math.Sin(z.B.Value));
    public static ComplexDouble Tan(ComplexDouble z) => Sin(z) / Cos(z);
    public static ComplexDouble Tanh(ComplexDouble z) => Sinh(z) / Cosh(z);
    public static ComplexInt Round(ComplexDouble z) => new ComplexInt((int)Math.Round(z.A), (int)Math.Round(z.B.Value));
    public static ComplexInt Floor(ComplexDouble z) => new ComplexInt((int)z.A, (int)z.B.Value);
    public static ComplexInt Ceiling(ComplexDouble z) => new ComplexInt((int)Math.Ceiling(z.A), (int)Math.Ceiling(z.B.Value));
    public static ComplexInt IntSqrt(ComplexInt z) {
        if (z.B.Value == 0) {
            return (ComplexInt)(z.A >= 0 ? Math.Sqrt(z.A) : Math.Sqrt(-z.A));
        } else {
            return (ComplexInt)(Pow(z, 0.5) + (0.00000000001 + (ImaginaryDouble)0.00000000001));
        }
    }
}

​x
 
using System;
public class Program{
    public static void Main(){
        ImaginaryInt i = 1;
        ComplexInt z1 = 7479 + 10667 * i;
        ComplexInt z2 = 5274 + 9553 * i;
        ComplexFraction zF1 = new ComplexFraction(z1, z2);
        ComplexFraction zF2 = 1;
        Console.WriteLine(z2 * z2);
        Console.WriteLine(z2.SquaredNorm());
        Console.WriteLine("");
        Console.WriteLine(zF1);
        Console.WriteLine(zF1.reciprocal());
        Console.WriteLine("");
        Console.WriteLine((ComplexDouble) zF1);
        Console.WriteLine((ComplexDouble) zF1.reciprocal());
    }
}
public class ComplexDouble {
    public double A { get; set; }
    public ImaginaryDouble B { get; set; }
    public ComplexDouble(double real_, double imag_) {
        A = real_;
        B = imag_;
    }
    public ComplexDouble(double real_, ImaginaryDouble imag_) {
        A = real_;
        B = imag_;
    }
    //If the object is initiated to a double or imaginary double, convert to a complex double with the other number at 0
    public static implicit operator ComplexDouble(int real_) => new ComplexDouble(real_, 0);
    public static implicit operator ComplexDouble(ImaginaryInt imag_) => new ComplexDouble(0, imag_);
    public static implicit operator ComplexDouble(float real_) => new ComplexDouble(real_, 0);
    public static implicit operator ComplexDouble(ImaginaryFloat imag_) => new ComplexDouble(0, imag_);
    public static implicit operator ComplexDouble(double real_) => new ComplexDouble(real_, 0);
    public static implicit operator ComplexDouble(ImaginaryDouble imag_) => new ComplexDouble(0, imag_);
    public static implicit operator ComplexDouble(ComplexInt z) => new ComplexDouble(z.A, z.B);
    public static implicit operator ComplexDouble(ComplexFloat z) => new ComplexDouble(z.A, z.B);
    //Cast to float to get the norm part of the complex number
    public static explicit operator int(ComplexDouble z) => (int)Math.Sqrt(z.SquaredNorm());
    public static explicit operator float(ComplexDouble z) => (float)Math.Sqrt(z.SquaredNorm());
    public static explicit operator double(ComplexDouble z) => (double)Math.Sqrt(z.SquaredNorm());
    public static explicit operator ComplexInt(ComplexDouble z) => new ComplexInt((int)z.A, (int)z.B);
    public static explicit operator ComplexFloat(ComplexDouble z) => new ComplexFloat((float)z.A, (float)z.B);
    //Addition operators
    public static ComplexDouble operator +(ComplexDouble z1, ComplexDouble z2) => new ComplexDouble(z1.A + z2.A, z1.B + z2.B);
    public static ComplexDouble operator ++(ComplexDouble z) {
        if (z == 0) {
            return 1;
        } else {
            return z + new ComplexDouble(Math.Abs(z.A) / ((double)z), ComplexMath.Abs(z.B) / ((double)z));
        }
    }
    //Unary+
    public static ComplexDouble operator +(ComplexDouble z) => z;
    //Subtraction operators
    public static ComplexDouble operator -(ComplexDouble z1, ComplexDouble z2) => new ComplexDouble(z1.A - z2.A, z1.B - z2.B);
    public static ComplexDouble operator --(ComplexDouble z) {
        if (z == 0) {
            return -1;
        } else {
            return z - new ComplexDouble(Math.Abs(z.A) / ((double)z), ComplexMath.Abs(z.B) / ((double)z));
        }
    }
    //Negation operator
    public static ComplexDouble operator -(ComplexDouble z) => new ComplexDouble(-z.A, -z.B);
    //Multiplication operators (a+bi)(c+di)=(ac-bd)+i(bc+ad)
    public static ComplexDouble operator *(ComplexDouble z1, ComplexDouble z2) => new ComplexDouble(z1.A * z2.A + z1.B * z2.B, z1.B * z2.A + z1.A * z2.B);
    //Division operators
    public static ComplexDouble operator /(ComplexDouble z1, ComplexDouble z2) => new ComplexDouble((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    //Remainder operators
    public static ComplexDouble operator %(ComplexDouble z1, ComplexDouble z2) => z1 - ((ComplexInt)(z1 / z2)) * z2;
    //Non-static mathematical functions
    public ComplexDouble Conjugate() => new ComplexDouble(A, -B);
    public double SquaredNorm() => A * A - B * B;
    public double SquaredNormSigns() => Math.Abs(A) * A + Math.Abs(B.Value) * B.Value;
    //Complex number comparisons, for greater than / less than, which point is further from the origin
    public static bool operator ==(ComplexDouble z1, ComplexDouble z2) => z1.A == z2.A && z1.B == z2.B;
    public static bool operator !=(ComplexDouble z1, ComplexDouble z2) => !(z1 == z2);
    public static bool operator >=(ComplexDouble z1, ComplexDouble z2) => z1.SquaredNorm() >= z2.SquaredNorm();
    public static bool operator <=(ComplexDouble z1, ComplexDouble z2) => z1.SquaredNorm() <= z2.SquaredNorm();
    public static bool operator >(ComplexDouble z1, ComplexDouble z2) => z1.SquaredNorm() > z2.SquaredNorm();
    public static bool operator <(ComplexDouble z1, ComplexDouble z2) => z1.SquaredNorm() < z2.SquaredNorm();
    public override bool Equals(object obj) {
        if (obj is ComplexDouble z) {
            return new ComplexDouble(A, B) == z;
        } else {
            return false;
        }
    }
    //Out methods
    public void GetRealAndImag(out double a, out double b) {
        a = A;
        b = (int)B;
    }
    //Hash code
    public override int GetHashCode() => (int)A & (int)B;
    //Deconstruction
    public void Deconstruct(out double real_, out ImaginaryDouble imag_) {
        real_ = A;
        imag_ = B;
    }
    //String representation
    public override string ToString() {
        string sign = B < 0 ? "-" : (B > 0 ? "+" : "-");
        if (A == 0) {
            return B == 0 ? "0" : $"{B}";
        } else {
            return B == 0 ? $"{A}" : Math.Abs(B.Value) == 1 ? $"{A} {sign} i" : $"{A} {sign} {Math.Abs(B.Value)}i";
        }
    }
}
public class ImaginaryDouble {
    public double Value { get; set; }
    private ImaginaryDouble(double imag_) {
        Value = imag_;
    }
    //If imaginary is initiated with a float, convert to imaginary number
    public static implicit operator ImaginaryDouble(double num) => new ImaginaryDouble(num);
    public static implicit operator ImaginaryDouble(ImaginaryInt z) => new ImaginaryDouble(z.Value);
    public static implicit operator ImaginaryDouble(ImaginaryFloat z) => new ImaginaryDouble(z.Value);
    //Cast imaginary number to other number types
    public static explicit operator int(ImaginaryDouble num) => (int)num.Value;
    public static explicit operator float(ImaginaryDouble num) => (float)num.Value;
    public static explicit operator double(ImaginaryDouble num) => num.Value;
    public static explicit operator decimal(ImaginaryDouble num) => (decimal)num.Value;
    public static explicit operator ImaginaryInt(ImaginaryDouble num) => (int)num.Value;
    public static explicit operator ImaginaryFloat(ImaginaryDouble num) => (float)num.Value;
    //Addition operators
    public static ImaginaryDouble operator +(ImaginaryDouble i1, ImaginaryDouble i2) => new ImaginaryDouble(i1.Value + i2.Value);
    public static ComplexDouble operator +(ImaginaryDouble i, double r) => new ComplexDouble(r, i);
    public static ComplexDouble operator +(double r, ImaginaryDouble i) => new ComplexDouble(r, i);
    //Unary +
    public static ImaginaryDouble operator +(ImaginaryDouble i) => i;
    //Increment operator
    public static ImaginaryDouble operator ++(ImaginaryDouble z1) => new ImaginaryDouble(z1.Value + 1);
    //Subtraction operators
    public static ImaginaryDouble operator -(ImaginaryDouble i1, ImaginaryDouble i2) => new ImaginaryDouble(i1.Value - i2.Value);
    public static ComplexDouble operator -(ImaginaryDouble i, double r) => new ComplexDouble(-r, i);
    public static ComplexDouble operator -(double r, ImaginaryDouble i) => new ComplexDouble(r, -i);
    //Decrement operator
    public static ImaginaryDouble operator --(ImaginaryDouble z1) => new ImaginaryDouble(z1.Value - 1);
    //Negation operator
    public static ImaginaryDouble operator -(ImaginaryDouble i) => new ImaginaryDouble(-i.Value);
    //Multiplication operators
    public static double operator *(ImaginaryDouble i1, ImaginaryDouble i2) => -i1.Value * i2.Value;
    public static ImaginaryDouble operator *(ImaginaryDouble i, double other) => new ImaginaryDouble(i.Value * other);
    public static ImaginaryDouble operator *(double other, ImaginaryDouble i) => new ImaginaryDouble(i.Value * other);
    //Division operators
    public static double operator /(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value / i2.Value;
    public static ImaginaryDouble operator /(ImaginaryDouble i, double other) => new ImaginaryDouble(i.Value / other);
    public static ImaginaryDouble operator /(double other, ImaginaryDouble i) => new ImaginaryDouble(-other / i.Value);
    //Comparison operators
    public static bool operator <(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value < i2.Value;
    public static bool operator >(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value > i2.Value;
    public static bool operator ==(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value == i2.Value;
    public static bool operator !=(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value != i2.Value;
    public static bool operator <=(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value <= i2.Value;
    public static bool operator >=(ImaginaryDouble i1, ImaginaryDouble i2) => i1.Value >= i2.Value;
    public override bool Equals(object obj) => obj is ImaginaryDouble @doubleObj && Value == @doubleObj;
    //Hash code
    public override int GetHashCode() => (int)Value;
    //Static mathematical operations
    //String representation
    public override string ToString() => Value == 0 ? "0" : (Math.Abs(Value) == 1 ? $"{(Value < 0 ? "-" : "")}i" : $"{(Value < 0 ? "-" : "")}{Math.Abs(Value)}i");
}
public class ComplexFloat {
    public float A { get; set; }
    public ImaginaryFloat B { get; set; }
    public ComplexFloat(float real_, float imag_) {
        A = real_;
        B = imag_;
    }
    public ComplexFloat(float real_, ImaginaryFloat imag_) {
        A = real_;
        B = imag_;
    }
    //If the object is initiated to a double or imaginary double, convert to a complex double with the other number at 0
    public static implicit operator ComplexFloat(int real_) => new ComplexFloat(real_, 0);
    public static implicit operator ComplexFloat(ImaginaryInt imag_) => new ComplexFloat(0, imag_);
    public static implicit operator ComplexFloat(float real_) => new ComplexFloat(real_, 0);
    public static implicit operator ComplexFloat(ImaginaryFloat imag_) => new ComplexFloat(0, imag_);
    public static implicit operator ComplexFloat(ComplexInt z) => new ComplexFloat(z.A, z.B);
    //Cast to types to get the norm part of the complex number
    public static explicit operator int(ComplexFloat z) => (int)Math.Sqrt(z.SquaredNorm());
    public static explicit operator float(ComplexFloat z) => (float)Math.Sqrt(z.SquaredNorm());
    public static explicit operator double(ComplexFloat z) => Math.Sqrt(z.SquaredNorm());
    public static explicit operator ComplexInt(ComplexFloat z) => new ComplexInt((int)z.A, (int)z.B);
    //Addition operators
    public static ComplexFloat operator +(ComplexFloat z1, ComplexFloat z2) => new ComplexFloat(z1.A + z2.A, z1.B + z2.B);
    public static ComplexDouble operator +(ComplexFloat z1, ComplexDouble z2) => new ComplexDouble(z1.A + z2.A, z1.B + z2.B);
    public static ComplexDouble operator +(ComplexDouble z1, ComplexFloat z2) => new ComplexDouble(z1.A + z2.A, z1.B + z2.B);
    public static ComplexFloat operator ++(ComplexFloat z) {
        if (z == 0) {
            return 1;
        } else {
            return z + new ComplexFloat(Math.Abs(z.A) / ((float)z), (float)(ComplexMath.Abs(z.B) / ((float)z)));
        }
    }
    //Unary +
    public static ComplexFloat operator +(ComplexFloat z) => z;
    //Subtraction operators
    public static ComplexFloat operator -(ComplexFloat z1, ComplexFloat z2) => new ComplexFloat(z1.A - z2.A, z1.B - z2.B);
    public static ComplexDouble operator -(ComplexFloat z1, ComplexDouble z2) => new ComplexDouble(z1.A - z2.A, z1.B - z2.B);
    public static ComplexDouble operator -(ComplexDouble z1, ComplexFloat z2) => new ComplexDouble(z1.A - z2.A, z1.B - z2.B);
    public static ComplexFloat operator --(ComplexFloat z) {
        if (z == 0) {
            return -1;
        } else {
            return z - new ComplexFloat(Math.Abs(z.A) / ((float)z), (float)(ComplexMath.Abs(z.B) / ((float)z)));
        }
    }
    //Negation operator
    public static ComplexFloat operator -(ComplexFloat z) => new ComplexFloat(-z.A, -z.B);
    //Multiplication operators (a+bi)(c+di)=(ac-bd)+i(bc+ad)
    public static ComplexFloat operator *(ComplexFloat z1, ComplexFloat z2) => new ComplexFloat(z1.A * z2.A + z1.B * z2.B, z1.B * z2.A + z1.A * z2.B);
    public static ComplexDouble operator *(ComplexFloat z1, ComplexDouble z2) => new ComplexDouble(z1.A * z2.A + z1.B * z2.B, z1.B * z2.A + z1.A * z2.B);
    public static ComplexDouble operator *(ComplexDouble z1, ComplexFloat z2) => new ComplexDouble(z1.A * z2.A + z1.B * z2.B, z1.B * z2.A + z1.A * z2.B);
    //Division operators
    public static ComplexFloat operator /(ComplexFloat z1, ComplexFloat z2) => new ComplexFloat((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    public static ComplexDouble operator /(ComplexFloat z1, ComplexDouble z2) => new ComplexDouble((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    public static ComplexDouble operator /(ComplexDouble z1, ComplexFloat z2) => new ComplexDouble((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    //Remainder operators
    public static ComplexFloat operator %(ComplexFloat z1, ComplexFloat z2) => z1 - ((ComplexInt)(z1 / z2)) * z2;
    //Non-static mathematical functions
    public ComplexDouble Conjugate() => new ComplexDouble(A, -B);
    public float SquaredNorm() => A * A - B * B;
    public float SquaredNormSigns() => Math.Abs(A) * A + Math.Abs(B.Value) * B.Value;
    //Complex number comparisons, for greater than / less than, which point is further from the origin
    public static bool operator ==(ComplexFloat z1, ComplexFloat z2) => z1.A == z2.A && z1.B == z2.B;
    public static bool operator !=(ComplexFloat z1, ComplexFloat z2) => !(z1 == z2);
    public static bool operator >=(ComplexFloat z1, ComplexFloat z2) => z1.SquaredNorm() >= z2.SquaredNorm();
    public static bool operator <=(ComplexFloat z1, ComplexFloat z2) => z1.SquaredNorm() <= z2.SquaredNorm();
    public static bool operator >(ComplexFloat z1, ComplexFloat z2) => z1.SquaredNorm() > z2.SquaredNorm();
    public static bool operator <(ComplexFloat z1, ComplexFloat z2) => z1.SquaredNorm() < z2.SquaredNorm();
    public override bool Equals(object obj) {
        if (obj is ComplexDouble z) {
            return new ComplexDouble(A, B) == z;
        } else {
            return false;
        }
    }
    //Out methods
    public void GetRealAndImag(out float a, out float b) {
        a = A;
        b = (int)B;
    }
    //Hash code
    public override int GetHashCode() => (int)A & (int)B;
    //Deconstruction
    public void Deconstruct(out float real_, out ImaginaryFloat imag_) {
        real_ = A;
        imag_ = B;
    }
    //String representation
    public override string ToString() {
        string sign = B < 0 ? "-" : (B > 0 ? "+" : "-");
        if (A == 0) {
            return B == 0 ? "0" : $"{B}";
        } else {
            return B == 0 ? $"{A}" : Math.Abs(B.Value) == 1 ? $"{A} {sign} i" : $"{A} {sign} {Math.Abs(B.Value)}i";
        }
    }
}
public class ImaginaryFloat {
    public float Value { get; set; }
    private ImaginaryFloat(float imag_) {
        Value = imag_;
    }
    //If imaginary is initiated with a float, convert to imaginary number
    public static implicit operator ImaginaryFloat(float num) => new ImaginaryFloat(num);
    public static implicit operator ImaginaryFloat(ImaginaryInt num) => new ImaginaryFloat(num.Value);
    //Cast imaginary number to other number types
    public static explicit operator int(ImaginaryFloat num) => (int)num.Value;
    public static explicit operator float(ImaginaryFloat num) => num.Value;
    public static explicit operator double(ImaginaryFloat num) => num.Value;
    public static explicit operator decimal(ImaginaryFloat num) => (decimal)num.Value;
    //Addition operators
    public static ImaginaryFloat operator +(ImaginaryFloat i1, ImaginaryFloat i2) => new ImaginaryFloat(i1.Value + i2.Value);
    public static ComplexFloat operator +(ImaginaryFloat i, float r) => new ComplexFloat(r, i);
    public static ComplexFloat operator +(float r, ImaginaryFloat i) => new ComplexFloat(r, i);
    public static ComplexDouble operator +(ImaginaryFloat i, double r) => new ComplexDouble(r, i);
    public static ComplexDouble operator +(double r, ImaginaryFloat i) => new ComplexDouble(r, i);
    //Increment operator
    public static ImaginaryFloat operator ++(ImaginaryFloat z1) => new ImaginaryFloat(z1.Value + 1);
    //Unary +
    public static ImaginaryFloat operator +(ImaginaryFloat i) => i;
    //Subtraction operators
    public static ImaginaryFloat operator -(ImaginaryFloat i1, ImaginaryFloat i2) => new ImaginaryFloat(i1.Value - i2.Value);
    public static ComplexFloat operator -(ImaginaryFloat i, float r) => new ComplexFloat(-r, i);
    public static ComplexFloat operator -(float r, ImaginaryFloat i) => new ComplexFloat(r, -i);
    public static ComplexDouble operator -(ImaginaryFloat i, double r) => new ComplexDouble(-r, i);
    public static ComplexDouble operator -(double r, ImaginaryFloat i) => new ComplexDouble(r, -i);
    //Decrement operator
    public static ImaginaryFloat operator --(ImaginaryFloat z1) => new ImaginaryFloat(z1.Value - 1);
    //Negation operator
    public static ImaginaryFloat operator -(ImaginaryFloat i) => new ImaginaryFloat(-i.Value);
    //Multiplication operators
    public static float operator *(ImaginaryFloat i1, ImaginaryFloat i2) => -i1.Value * i2.Value;
    public static ImaginaryFloat operator *(ImaginaryFloat i, float other) => new ImaginaryFloat(i.Value * other);
    public static ImaginaryFloat operator *(float other, ImaginaryFloat i) => new ImaginaryFloat(i.Value * other);
    public static ImaginaryDouble operator *(ImaginaryFloat i, double other) => i.Value * other;
    public static ImaginaryDouble operator *(double other, ImaginaryFloat i) => i.Value * other;
    //Division operators
    public static float operator /(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value / i2.Value;
    public static ImaginaryFloat operator /(ImaginaryFloat i, float other) => new ImaginaryFloat(i.Value / other);
    public static ImaginaryFloat operator /(float other, ImaginaryFloat i) => new ImaginaryFloat(-other / i.Value);
    public static ImaginaryDouble operator /(ImaginaryFloat i, double other) => i.Value / other;
    public static ImaginaryDouble operator /(double other, ImaginaryFloat i) => -other / i.Value;
    //Comparison operators
    public static bool operator <(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value < i2.Value;
    public static bool operator >(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value > i2.Value;
    public static bool operator ==(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value == i2.Value;
    public static bool operator !=(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value != i2.Value;
    public static bool operator <=(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value <= i2.Value;
    public static bool operator >=(ImaginaryFloat i1, ImaginaryFloat i2) => i1.Value >= i2.Value;
    public override bool Equals(object obj) => obj is ImaginaryDouble @doubleObj && Value == @doubleObj;
    //Hash code
    public override int GetHashCode() => (int)Value;
    //Static mathematical operations
    //String representation
    public override string ToString() => Value == 0 ? "0" : (Math.Abs(Value) == 1 ? $"{(Value < 0 ? "-" : "")}i" : $"{(Value < 0 ? "-" : "")}{Math.Abs(Value)}i");
}
public class ComplexInt {
    public int A { get; set; }
    public ImaginaryInt B { get; set; }
    public ComplexInt(int a_, int b_) {
        A = a_;
        B = b_;
    }
    public ComplexInt(int a_, ImaginaryInt b_) {
        A = a_;
        B = b_;
    }
    //Implicit operators
    public static implicit operator ComplexInt(int d) => new ComplexInt(d, 0);
    public static implicit operator ComplexInt(ImaginaryInt d) => new ComplexInt(0, d);
    //Explicit operators
    public static explicit operator int(ComplexInt d) => (int)Math.Sqrt(d.A * ((double)d.A) + ((double)d.B) * ((double)d.B));
    public static explicit operator float(ComplexInt d) => (float)Math.Sqrt(d.A * ((double)d.A) + ((double)d.B) * ((double)d.B));
    public static explicit operator double(ComplexInt d) => Math.Sqrt(d.A * ((double)d.A) + ((double)d.B) * ((double)d.B));
    //Addition operators
    public static ComplexInt operator +(ComplexInt z1, ComplexInt z2) => new ComplexInt(z1.A + z2.A, z1.B + z2.B);
    public static ComplexFloat operator +(ComplexInt z1, ComplexFloat z2) => new ComplexFloat(z1.A + z2.A, z1.B + z2.B);
    public static ComplexFloat operator +(ComplexFloat z1, ComplexInt z2) => new ComplexFloat(z1.A + z2.A, z1.B + z2.B);
    public static ComplexDouble operator +(ComplexInt z1, ComplexDouble z2) => new ComplexDouble(z1.A + z2.A, z1.B + z2.B);
    public static ComplexDouble operator +(ComplexDouble z1, ComplexInt z2) => new ComplexDouble(z1.A + z2.A, z1.B + z2.B);
    public static ComplexInt operator ++(ComplexInt z1) {
        if (z1 == 0) {
            return 1;
        } else {
            return z1 + (ComplexInt)(new ComplexDouble((int)(Math.Abs(z1.A) * 1.99999999), (int)(z1.B * 1.99999999)) / ((double)z1));
        }
    }
    //Unary +
    public static ComplexInt operator +(ComplexInt i) => i;
    //Subtraction operators
    public static ComplexInt operator --(ComplexInt z1) => z1 - new ComplexInt((int)(Math.Abs(z1.A) * 1.99999999), (int)(z1.B * 1.99999999)) / ((int)z1);
    public static ComplexInt operator -(ComplexInt z1, ComplexInt z2) => new ComplexInt(z1.A - z2.A, z1.B - z2.B);
    public static ComplexFloat operator -(ComplexInt z1, ComplexFloat z2) => new ComplexFloat(z1.A - z2.A, z1.B - z2.B);
    public static ComplexFloat operator -(ComplexFloat z1, ComplexInt z2) => new ComplexFloat(z1.A - z2.A, z1.B - z2.B);
    public static ComplexDouble operator -(ComplexInt z1, ComplexDouble z2) => new ComplexDouble(z1.A - z2.A, z1.B - z2.B);
    public static ComplexDouble operator -(ComplexDouble z1, ComplexInt z2) => new ComplexDouble(z1.A - z2.A, z1.B - z2.B);
    //Negation Operator
    public static ComplexInt operator -(ComplexInt z1) => new ComplexInt(-z1.A, -z1.B);
    //Multiplication operators
    public static ComplexInt operator *(ComplexInt z1, ComplexInt z2) => new ComplexInt(z1.B * z2.B + z1.A * z2.A, z1.A * z2.B + z1.B * z2.A);
    public static ComplexFloat operator *(ComplexInt z1, ComplexFloat z2) => new ComplexFloat(z1.B * z2.B + z1.A * z2.A, z1.A * z2.B + z1.B * z2.A);
    public static ComplexFloat operator *(ComplexFloat z1, ComplexInt z2) => new ComplexFloat(z1.B * z2.B + z1.A * z2.A, z1.A * z2.B + z1.B * z2.A);
    public static ComplexDouble operator *(ComplexInt z1, ComplexDouble z2) => new ComplexDouble(z1.B * z2.B + z1.A * z2.A, z1.A * z2.B + z1.B * z2.A);
    public static ComplexDouble operator *(ComplexDouble z1, ComplexInt z2) => new ComplexDouble(z1.B * z2.B + z1.A * z2.A, z1.A * z2.B + z1.B * z2.A);
    //Division operators
    public static ComplexInt operator /(ComplexInt z1, ComplexInt z2) => new ComplexInt((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    public static ComplexFloat operator /(ComplexInt z1, ComplexFloat z2) => new ComplexFloat((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    public static ComplexFloat operator /(ComplexFloat z1, ComplexInt z2) => new ComplexFloat((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    public static ComplexDouble operator /(ComplexInt z1, ComplexDouble z2) => new ComplexDouble((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    public static ComplexDouble operator /(ComplexDouble z1, ComplexInt z2) => new ComplexDouble((z1.A * z2.A - z1.B * z2.B) / z2.SquaredNorm(), (z1.B * z2.A - z1.A * z2.B) / z2.SquaredNorm());
    //Remainder operators
    public static ComplexInt operator %(ComplexInt z1, ComplexInt z2) => z1 - (z1 / z2) * z2;
    //Bitwise operators
    public static ComplexInt operator <<(ComplexInt z, int d) => new ComplexInt(z.A << d, z.B << d);
    public static ComplexInt operator >>(ComplexInt z, int d) => new ComplexInt(z.A >> d, z.B >> d);
    //Non-static mathematical functions
    public ComplexInt Conjugate() => new ComplexInt(A, -B);
    public int SquaredNorm() => A * A - B * B;
    public int SquaredNormSigns() => Math.Abs(A) * A + Math.Abs(B.Value) * B.Value;
    //Complex number comparisons, for greater than / less than, which point is further from the origin
    public static bool operator ==(ComplexInt z1, ComplexInt z2) => z1.A == z2.A && z1.B == z2.B;
    public static bool operator !=(ComplexInt z1, ComplexInt z2) => !(z1 == z2);
    public static bool operator >=(ComplexInt z1, ComplexInt z2) => z1.SquaredNorm() >= z2.SquaredNorm();
    public static bool operator <=(ComplexInt z1, ComplexInt z2) => z1.SquaredNorm() <= z2.SquaredNorm();
    public static bool operator >(ComplexInt z1, ComplexInt z2) => z1.SquaredNorm() > z2.SquaredNorm();
    public static bool operator <(ComplexInt z1, ComplexInt z2) => z1.SquaredNorm() < z2.SquaredNorm();
    public override bool Equals(object obj) {
        if (obj is ComplexInt z) {
            return new ComplexInt(A, B) == z;
        } else {
            return false;
        }
    }
    //Out methods
    public void GetRealAndImag(out int a, out int b) {
        a = A;
        b = (int)B;
    }
    //Hash code
    public override int GetHashCode() => A & (int)B;
    //Deconstruction
    public void Deconstruct(out int real_, out ImaginaryInt imag_) {
        real_ = A;
        imag_ = B;
    }
    //String
    public override string ToString() {
        string sign = B < 0 ? "-" : (B > 0 ? "+" : "-");
        if (A == 0) {
            return B == 0 ? "0" : $"{B}";
        } else {
            return B == 0 ? $"{A}" : Math.Abs(B.Value) == 1 ? $"{A} {sign} i" : $"{A} {sign} {Math.Abs(B.Value)}i";
        }
    }
}
public class ImaginaryInt {
    public int Value { get; set; }
    private ImaginaryInt(int b_) {
        Value = b_;
    }
    //Implicit conversions
    public static implicit operator ImaginaryInt(int d) => new ImaginaryInt(d);
    //Explicit conversions
    public static explicit operator ImaginaryInt(float a) => new ImaginaryInt((int)a);
    public static explicit operator ImaginaryInt(double a) => new ImaginaryInt((int)a);
    public static explicit operator int(ImaginaryInt a) => a.Value;
    public static explicit operator float(ImaginaryInt a) => a.Value;
    public static explicit operator double(ImaginaryInt a) => a.Value;
    //Addition operators
    public static ImaginaryInt operator +(ImaginaryInt a1, ImaginaryInt a2) => a1.Value + a2.Value;
    public static ComplexInt operator +(ImaginaryInt a, int r) => new ComplexInt(r, a.Value);
    public static ComplexInt operator +(int r, ImaginaryInt a) => new ComplexInt(r, a.Value);
    public static ComplexFloat operator +(ImaginaryInt a, float r) => new ComplexFloat(r, a.Value);
    public static ComplexFloat operator +(float r, ImaginaryInt a) => new ComplexFloat(r, a.Value);
    public static ComplexDouble operator +(ImaginaryInt a, double r) => new ComplexDouble(r, a.Value);
    public static ComplexDouble operator +(double r, ImaginaryInt a) => new ComplexDouble(r, a.Value);
    //Unary +
    public static ImaginaryInt operator +(ImaginaryInt i) => i;
    //Increment operator
    public static ImaginaryInt operator ++(ImaginaryInt z1) => z1.Value + 1;
    //Subtraction operators
    public static ImaginaryInt operator -(ImaginaryInt a1, ImaginaryInt a2) => a1.Value - a2.Value;
    public static ComplexInt operator -(ImaginaryInt a, int r) => new ComplexInt(-r, a.Value);
    public static ComplexInt operator -(int r, ImaginaryInt a) => new ComplexInt(r, -a.Value);
    public static ComplexFloat operator -(ImaginaryInt a, float r) => new ComplexFloat(-r, a.Value);
    public static ComplexFloat operator -(float r, ImaginaryInt a) => new ComplexFloat(r, -a.Value);
    public static ComplexDouble operator -(ImaginaryInt a, double r) => new ComplexDouble(-r, a.Value);
    public static ComplexDouble operator -(double r, ImaginaryInt a) => new ComplexDouble(r, -a.Value);
    //Decrement operator
    public static ImaginaryInt operator --(ImaginaryInt z1) => z1.Value - 1;
    //Negation operator
    public static ImaginaryInt operator -(ImaginaryInt a) => -a.Value;
    //Multiplication operators
    public static int operator *(ImaginaryInt a1, ImaginaryInt a2) => -a1.Value * a2.Value;
    public static ImaginaryInt operator *(int d, ImaginaryInt a) => a.Value * d;
    public static ImaginaryInt operator *(ImaginaryInt a, int d) => a.Value * d;
    public static ImaginaryFloat operator *(float d, ImaginaryInt a) => a.Value * d;
    public static ImaginaryFloat operator *(ImaginaryInt a, float d) => a.Value * d;
    public static ImaginaryDouble operator *(double d, ImaginaryInt a) => a.Value * d;
    public static ImaginaryDouble operator *(ImaginaryInt a, double d) => a.Value * d;
    //Division operators
    public static int operator /(ImaginaryInt a1, ImaginaryInt a2) => a1.Value / a2.Value;
    public static ImaginaryInt operator /(ImaginaryInt a, int d) => a.Value / d;
    public static ImaginaryInt operator /(int d, ImaginaryInt a) => -d / a.Value;
    public static ImaginaryFloat operator /(ImaginaryInt a, float d) => a.Value / d;
    public static ImaginaryFloat operator /(float d, ImaginaryInt a) => -d / a.Value;
    public static ImaginaryDouble operator /(ImaginaryInt a, double d) => a.Value / d;
    public static ImaginaryDouble operator /(double d, ImaginaryInt a) => -d / a.Value;
    //Bitwise operators
    public static ImaginaryInt operator <<(ImaginaryInt a, int d) => a.Value << d;
    public static ImaginaryInt operator >>(ImaginaryInt a, int d) => a.Value >> d;
    //Comparison operators
    public static bool operator ==(ImaginaryInt a1, ImaginaryInt a2) => a1.Value == a2.Value;
    public static bool operator !=(ImaginaryInt a1, ImaginaryInt a2) => a1.Value != a2.Value;
    public static bool operator >(ImaginaryInt a1, ImaginaryInt a2) => a1.Value > a2.Value;
    public static bool operator <(ImaginaryInt a1, ImaginaryInt a2) => a1.Value < a2.Value;
    public static bool operator >=(ImaginaryInt a1, ImaginaryInt a2) => a1.Value >= a2.Value;
    public static bool operator <=(ImaginaryInt a1, ImaginaryInt a2) => a1.Value <= a2.Value;
    public override bool Equals(object obj) => obj is ImaginaryInt intObj && Value == intObj;
    //Hash code
    public override int GetHashCode() => Value;
    //String
    public override string ToString() => Value == 0 ? "0" : (Math.Abs(Value) == 1 ? $"{(Value < 0 ? "-" : "")}i" : $"{(Value < 0 ? "-" : "")}{Math.Abs(Value)}i");
}
public class ComplexFraction{
    public readonly ComplexInt num;
    public readonly int den;
    private readonly ComplexInt originalNum;
    private readonly ComplexInt originalDen;
    public ComplexFraction(ComplexInt num, ComplexInt den){
        long largeDen = 1;
        originalNum = num;
        originalDen = den;
        if(den.B == 0){
            this.num = num;
            this.den = den.A;
        }else{
            this.num = (num * den.Conjugate());
            largeDen = den.SquaredNorm();
        }
        while(largeDen > Int32.MaxValue){
            this.num /= 2;
            largeDen /= 2;
        }
        this.den = (int)(largeDen);
        int commonFactor = GCD(GCD(this.num.A, this.den), this.num.B.Value);
        this.num /= commonFactor;
        this.den /= commonFactor;
        originalNum /= commonFactor;
        originalDen /= commonFactor;
        if(this.den < 0){
            this.num *= -1;
            this.den *= -1;
        }
    }
    //Implicit operators
    public static implicit operator ComplexFraction(int n) => new ComplexFraction(n, 1);
    public static implicit operator ComplexFraction(ImaginaryInt n) => new ComplexFraction(n, 1);
    public static implicit operator ComplexFraction(ComplexInt n) => new ComplexFraction(n, 1);
    //Explicit operators
    public static explicit operator ComplexDouble(ComplexFraction n) => n.num / (n.den * 1.0);
    public static explicit operator ComplexFloat(ComplexFraction n) => n.num / (n.den * 1f);
    //Addition operator
    public static ComplexFraction operator +(ComplexFraction a, ComplexFraction b) => new ComplexFraction(a.num * b.den + a.den * b.num, a.den * b.den);
    public static ComplexFraction operator ++(ComplexFraction a) => a + 1;
    public static ComplexFraction operator +(ComplexFraction a) => a;
    //Subtraction operator
    public static ComplexFraction operator -(ComplexFraction a, ComplexFraction b) => new ComplexFraction(a.num * b.den - a.den * b.num, a.den * b.den);
    public static ComplexFraction operator --(ComplexFraction a) => a - 1;
    public static ComplexFraction operator -(ComplexFraction a) => new ComplexFraction(-a.num, -a.den);
    //Multiplication operator
    public static ComplexFraction operator *(ComplexFraction a, ComplexFraction b) => new ComplexFraction(a.num * b.num, a.den * b.den);
    //Division operator
    public static ComplexFraction operator /(ComplexFraction a, ComplexFraction b) => new ComplexFraction(a.num * b.den, a.den * b.num);
    //Other
    public ComplexFraction reciprocal() => new ComplexFraction(originalDen, originalNum);
    public static int GCD(int a, int b) => b == 0 ? a : GCD(b, a % b);
    public override string ToString() => $"({num}){(den == 1 ? "" : $" / {den}")}";
}
//Other mathematical functions
public class ComplexMath {
    public readonly ImaginaryInt I = 1;
    //Return the absolute value of an imaginary and complex number
    public static int Abs(ImaginaryInt i) => Math.Abs(i.Value);
    public static double Abs(ImaginaryDouble i) => Math.Abs(i.Value);
    public static double Abs(ComplexDouble z) => (float)z;
    /// <summary>
    /// Returns the natural logarithm (base e) of a complex number.
    /// </summary>
    /// <returns>
    /// ln(<c>z</c>)
    /// </returns>
    public static ComplexDouble Log(ComplexDouble z) => Math.Log(z.SquaredNorm()) / 2 + (ImaginaryDouble)Math.Atan2(z.B.Value, z.A);
    /// <summary>
    /// Returns the log of a complex valued base of a complex number.
    /// </summary>
    /// <returns>
    /// ln(<c>z</c>) / ln(<c>log_base</c>)
    /// </returns>
    public static ComplexDouble Log(ComplexDouble z, ComplexDouble log_base) => Log(z) / Log(log_base);
    public static ComplexDouble Exp(ComplexDouble z) => Math.Pow(Math.E, z.A) * new ComplexDouble(Math.Cos(z.B.Value), Math.Sin(z.B.Value));
    /// <summary>
    /// Returns a specified complex number to the power of a specified complex number.
    /// </summary>
    /// <returns>
    /// A complex number <c>z1</c> to the power of <c>z2</c>
    /// </returns>
    public static ComplexDouble Pow(ComplexDouble z1, ComplexDouble z2) => Exp(Log(z1) * z2);
​
    /// <summary>
    /// Returns a specified imaginary number to the power of a specified integer.
    /// </summary>
    /// <returns>
    /// A complex double <c>z</c> to the power of <c>n</c>
    /// </returns>
    public static ComplexDouble Pow(ImaginaryDouble z, int n) {
        if (n % 2 == 0) {
            return Math.Pow(z.Value, n) * (n % 4 == 0 ? 1 : -1);
        } else {
            return (ImaginaryDouble)(Math.Pow(z.Value, n) * (n % 4 == 1 ? 1 : -1));
        }
    }
    /// <summary>
    /// Returns the square root of a complex number.
    /// </summary>
    /// <returns>
    /// The positive integer solution of the square root
    /// </returns>
    public static ComplexDouble Sqrt(ComplexDouble z) {
        if (z.B.Value == 0) {
            if (z.A >= 0) {
                return Math.Sqrt(z.A);
            } else {
                return (ImaginaryDouble)Math.Sqrt(-z.A);
            }
        } else {
            return Pow(z, 0.5);
        }
    }
    public static ComplexDouble Root(ComplexDouble z, int n) => Pow(z, 1.0 / n);
    public static ComplexDouble Root(ComplexDouble z, int n, int rootID) => Pow(z, 1.0 / n) * Exp(((ImaginaryDouble) rootID * Math.PI * 2) / n);
    /// <summary>
    /// Returns the sine of a complex number.
    /// </summary>
    /// <returns>
    /// The sine of <c>z</c>
    /// </returns>
    public static ComplexDouble Sin(ComplexDouble z) => new ComplexDouble(Math.Sin(z.A) * Math.Cosh(z.B.Value), Math.Cos(z.A) * Math.Sinh(z.B.Value));
    /// <summary>
    /// Returns the hyperbolic sine of a complex number.
    /// </summary>
    /// <returns>
    /// The hyperbolic sine of <c>z</c>
    /// </returns>
    public static ComplexDouble Sinh(ComplexDouble z) => new ComplexDouble(Math.Sinh(z.A) * Math.Cos(z.B.Value), Math.Cosh(z.A) * Math.Sin(z.B.Value));
    public static ComplexDouble Cos(ComplexDouble z) => new ComplexDouble(Math.Cos(z.A) * Math.Cosh(z.B.Value), -Math.Sin(z.A) * Math.Sinh(z.B.Value));
    public static ComplexDouble Cosh(ComplexDouble z) => new ComplexDouble(Math.Cosh(z.A) * Math.Cos(z.B.Value), Math.Sinh(z.A) * Math.Sin(z.B.Value));
    public static ComplexDouble Tan(ComplexDouble z) => Sin(z) / Cos(z);
    public static ComplexDouble Tanh(ComplexDouble z) => Sinh(z) / Cosh(z);
    public static ComplexInt Round(ComplexDouble z) => new ComplexInt((int)Math.Round(z.A), (int)Math.Round(z.B.Value));
    public static ComplexInt Floor(ComplexDouble z) => new ComplexInt((int)z.A, (int)z.B.Value);
    public static ComplexInt Ceiling(ComplexDouble z) => new ComplexInt((int)Math.Ceiling(z.A), (int)Math.Ceiling(z.B.Value));
    public static ComplexInt IntSqrt(ComplexInt z) {
        if (z.B.Value == 0) {
            return (ComplexInt)(z.A >= 0 ? Math.Sqrt(z.A) : Math.Sqrt(-z.A));
        } else {
            return (ComplexInt)(Pow(z, 0.5) + (0.00000000001 + (ImaginaryDouble)0.00000000001));
        }
    }
}

Cached Result
Last Run:	2:06:34 pm
Compile:	8.595s
Execute:	0s
Memory:	0b
CPU:	0s

View IL Code