using System;

///<summary>Complex. This type implements complex numbers with the
///usual arithmetic operations.</summary>
struct Complex {
	double re;
	double im;
	
	///<summary>Creates a new complex number.</summary>
	///<param name="re">The real part of this number.</param>
	///<param name="im">The imaginary part of this number.</param>
	public Complex(double re, double im) {this.re = re; this.im = im;}

	///<summary>Creates a new complex number with an imaginary part of 0.</summary>
	///<param name="re">The real part of this number.</param>
	public Complex(double re) : this(re, 0) {}
	
	///<summary>Returns the real part of this number.</summary>
	public double Re {
		get { return re; }
		set { re = value; }
	}
	
	///<summary>Returns the imaginary part of this number.</summary>
	public double Im {
		get { return im; }
		set { im = value; }
	}
	
	///<summary>Returns a string representation of this number in the form x + yi.
	///This method is inherited from System.Object.</summary>
	public override string ToString() {
		return String.Format("{0:f2}+{1:f2}i", re, im);
	}
	
	///<summary>Checks the equality of two complex numbers.
	///This method is inherited from System.Object.</summary>
	///<param name="obj">The object to compare this number with.</param>
	public override bool Equals(object obj) {
		return this == (Complex)obj;
	}
	
	///<summary>Returns a hash code for this number.
	///This method is inherited from System.Object</summary>
	public override int GetHashCode() {
		return ((int)re) ^ ((int)im);
	}
	
	///<summary>Adds two complex numbers and returns a new complex number
	///with the result</summary>
	public static Complex operator + (Complex x, Complex y) {
		return new Complex(x.re + y.re, x.im + y.im);
	}
	
	///<summary>Subtracts two complex numbers and returns a new complex number
	///with the result</summary>
	public static Complex operator - (Complex x, Complex y) {
		return new Complex(x.re - y.re, x.im - y.im);
	}
	
	///<summary>Multiplies two complex numbers and returns a new complex number
	///with the result</summary>
	public static Complex operator * (Complex x, Complex y) {
		return new Complex(x.re * y.re - x.im * y.im, x.re * y.im + y.re * x.im);
	}
	
	///<summary>Divides two complex numbers and returns a new complex number
	///with the result</summary>
	public static Complex operator / (Complex x, Complex y) {
		double n = y.re * y.re + y.im * y.im;
		return new Complex((x.re * y.re + x.im * y.im)/n, (y.re * x.im - x.re * y.im)/n);
	}
	
	///<summary>Compares two complex numbers for equality.</summary>
	public static bool operator == (Complex x, Complex y) {
		return x.re == y.re && x.im == y.im;
	}
	
	///<summary>Compares two complex numbers for inequality.</summary>
	public static bool operator != (Complex x, Complex y) {
		return x.re != y.re || x.im != y.im;
	}
	
	///<summary>Converts a complex number to a double value
	///by returning the real part of it.</summary>
	public static explicit operator double(Complex x) {
		return x.re;
	}
	
	///<summary>Converts a double number to a complex number
	///by setting the imaginary part to 0.</summary>
	public static implicit operator Complex(double x) {
		return new Complex(x, 0);
	}

}

class Test {

	public static void Main() {
		Complex x = 1;
		Complex y = new Complex(2, 1);
		Console.WriteLine(x + y);
		Console.WriteLine(x * y);
		Console.WriteLine(y / y);
		Console.WriteLine((double)y);
	}
}