import java.applet.Applet;
import java.awt.event.*;
import java.awt.*;

/*This class does the basic arithmetic
  of complex numbers */

public class Complex {
    double x,y;
    
    public Complex() {
        this.x=0.0;
        this.y=0.0;
    } 
    
    public Complex(double x,double y) {
        this.x=x;
        this.y=y;
    }
    
    public Complex(Complex z) {
        this.x=z.x;
        this.y=z.y;
    }

    public Complex set(Complex z) {
        x=z.x;
        y=z.y;
        return this;
    }

    public static double norm(Complex z) {
        return Math.sqrt(z.x*z.x+z.y*z.y);
    }

    public static Complex unit(Complex z) {
        double d=z.norm(z);
        return new Complex(z.x/d,z.y/d);
    }

    public static Complex plus(Complex z1,Complex z2) {
        return new Complex(z1.x+z2.x, z1.y+z2.y);
    }

    public static Complex average(Complex z1,Complex z2) {
        return new Complex(.5*z1.x+.5*z2.x, .5*z1.y+.5*z2.y);
    }
    

    public static Complex minus(Complex z1,Complex z2) {
        return new Complex(z1.x-z2.x, z1.y-z2.y);
    }
    

    public static Complex prolong(Complex z1,Complex z2,double d) {
	return new Complex((d+1)*z1.x-d*z2.x, (d+1)*z1.y-d*z2.y);
    }

    public static Complex times(Complex z1,Complex z2) {
        return new Complex(z1.x*z2.x-z1.y*z2.y,
        z1.x*z2.y+z1.y*z2.x);
    }

    public static Complex inverse(Complex z) {
        double d=z.x*z.x+z.y*z.y;
        return new Complex(z.x/d,-z.y/d);
    }
    

    public static Complex divide(Complex z1,Complex z2) {
        return times(z1,inverse(z2));
    }
    
    public static Complex conjugate(Complex z) {
        return new Complex(z.x,-z.y);
    }
    

    public static double dot(Complex a, Complex b) {
        return a.x*b.x+a.y*b.y;
    }
    
    public static double dist(Complex a,Complex b) {
        Complex z=minus(a,b);
        return(norm(z));
    }
    

  public static double area(Complex z1,Complex z2,Complex z3) {
        double a;
        Complex[] z=new Complex[5];
        z[1]=z1.minus(z2,z1);
        z[2]=z1.minus(z3,z1);
        z[3]=z1.conjugate(z[2]);
        z[4]=z1.times(z[1],z[3]);
        a=-z[4].y;
        return(a);
    }


    public static double nearness(Complex z1,Complex z2,Complex w) {
	double d1=dist(z1,z2);
	double d2=dist(w,z1);
	double d3=dist(w,z2);
	double d=(d2+d3)/d1;
	if(d>1.01) return(1);
	double a1=area(z1,z2,w);
	a1=Math.abs(a1);
	double a2=Complex.dist(z1,z2);
	if(a2<.001) return(1);
	return(a1/a2);
    }


    public static double distanceToLine(Complex z1,Complex z2,Complex z3) {
	double t1=area(z1,z2,z3);
	double t2=dist(z2,z3);
	return(t1/t2);
    }


    
    
    
    public double norm() {
        return Math.sqrt(x*x+y*y);
    }

    public Complex unit() {
        double d=norm();
        return new Complex(x/d,y/d);
    }

    public Complex plus(Complex z) {
        return new Complex(x+z.x, y+z.y);
    }
    

    public Complex minus(Complex z) {
        return new Complex(x-z.x, y-z.y);
    }

    public Complex times(Complex z) {
        return new Complex(x*z.x-y*z.y,
        x*z.y+y*z.x);
    }
    
    

    public Complex inverse() {
        double d=x*x+y*y;
        return new Complex(x/d,-y/d);
    }
    
    public Complex divide(Complex z2) {
        return times(inverse(z2));
    }
    
    
    public Complex conjugate() {
        return new Complex(x,-y);
    }

    public double dot(Complex a) {
        return a.x*x+a.y*y;
    }
    
    public boolean equals(Complex a) {
        return ((a.x==x)&&(a.y==y));
    }
    
    
    public double arg(){
        return Math.atan2(y,x);
    }


    public static int  isPositivelyOriented(Complex z1,Complex z2,Complex z3) {
        Complex[] z=new Complex[5];
        for(int i=1;i<=4;++i) z[i]=new Complex();
        z[1]=Complex.minus(z2,z1);
        z[2]=Complex.minus(z3,z1);
        z[3]=Complex.conjugate(z[2]);
        z[4]=Complex.times(z[1],z[3]);
	if(z[4].y<0) return(1);
	return(0);
    }

    public static int  notNegativelyOriented(Complex z1,Complex z2,Complex z3) {
        Complex[] z=new Complex[5];
        for(int i=1;i<=4;++i) z[i]=new Complex();
        z[1]=Complex.minus(z2,z1);
        z[2]=Complex.minus(z3,z1);
        z[3]=Complex.conjugate(z[2]);
        z[4]=Complex.times(z[1],z[3]);
	if(z[4].y<=0) return(1);
	return(0);
    }

    public static int  zeroOriented(Complex z1,Complex z2,Complex z3) {
        Complex[] z=new Complex[5];
        for(int i=1;i<=4;++i) z[i]=new Complex();
        z[1]=Complex.minus(z2,z1);
        z[2]=Complex.minus(z3,z1);
        z[3]=Complex.conjugate(z[2]);
        z[4]=Complex.times(z[1],z[3]);
	if(Math.abs(z[4].y)<=0.0000001) return(1);
	return(0);
    }



    public static double  coerce(double x,int a) {
	if(a==0) return(x);
	int n1=(int)(x-1);
	int n2=(int)(x+1);
	double min=2;
	double test=0;
	double y=0;
	double yy=0;
	for(int i=n1*a;i<=n2*a;++i) {
	    y=1.0*i/a;
	    test=Math.abs(x-y);
	    if(min>test) {
		min=test;
		yy=y;
	    }
	}
	return(yy);
    }

    Complex reflect(Complex z) {

	Complex w=new Complex();
	w.x=2*this.x-z.x;
	w.y=2*this.y-z.y;
	return(w);
    }

    //forces entries to be nearby rationals, a and b specify denominators

    public Complex coerce(int a,int b) {
	Complex w=new Complex(coerce(this.x,a),coerce(this.y,b));
	return(w);
    }

    
    public Complex scale(Complex z,double r) {
        Complex w=new Complex();
        w.x=r*x+(1.0-r)*z.x;
        w.y=r*y+(1.0-r)*z.y;
        return(w);
    }


    public void print() {
	double xx=x;
	double yy=y;
	if(Math.abs(xx)<.0000000001) xx=0;
	if(Math.abs(yy)<.0000000001) yy=0;
	System.out.println("Complex: "+xx+" "+yy);
    }
}