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


public class XInvariants {
    double x,y;
    
    public XInvariants() {}

    //vectors should be normalized

    public static double slope(Vector V1,Vector V2) {
        double s;
        s=(V2.x[1]-V1.x[1])/(V2.x[0]-V1.x[0]);
        return(s);
    }


    //inverse of usual cross ratio
    public static double cross0(double a,double b,double c,double d)
      {
      double x;
      x=(a-b)*(c-d)/((a-c)*(b-d));
      return(x);
      }


    public static double fan(Vector x,Vector a,Vector b,Vector c,Vector d) {
        double f=cross0(slope(x,a),slope(x,b),slope(x,c),slope(x,d));
        return(f);
    }



    // the local invariant
    public static double locinv(PolyVector P,int j,int ii) {
        int i;
	int n=P.count;
	PolyVector Q=P.rotate(Math.sqrt(2.0));   //a random rotation to avoid degeneracies
	int j1=(j-1*ii+n)%n;
	int j2=(j-2*ii+n)%n;
	int j3=(j-0*ii+n)%n;
	int j4=(j+1*ii+n)%n;
	int j5=(j+2*ii+n)%n;
	double ll=fan(Q.V[j1],Q.V[j2],Q.V[j3],Q.V[j4],Q.V[j5]);
        return(ll);
    }


    // the global invariants

    public static double[] invariant(PolyVector P) {
	double[] x=new double[P.count*2];

        for(int i=0;i<P.count;++i) {
             x[2*i-0]=locinv(P,i,-1);
             x[2*i+1]=locinv(P,i,1);
	}
	return(x);
    }

    public static double[] productInvariant(PolyVector P) {
	double[] x=invariant(P);
	int n=2*P.count;
	double[] y=new double[n/2];
	int i1,i2,i3;
	for(int i=0;i<n;i=i+2) {
	    i2=(i+1+n)%n;
	    i3=(i-0+n)%n;
	    y[i/2]=x[i2]*x[i3];
	}
	return(y);
    }



    public static double[] conicInvariant1(PolyVector P) {
	double[] x=invariant(P);
	int n=2*P.count;
	double[] y=new double[n/2];
	int i1,i2,i3;
	for(int i=0;i<n;i=i+2) {
	    i1=(i+2+n)%n;
	    i2=(i+1+n)%n;
	    i3=(i-0+n)%n;
	    y[i/2]=(1-x[i1])*(1-x[i2]*x[i3]);
	}
	return(y);
    }






    public static double[] conicInvariant2(PolyVector P) {
	double[] x=invariant(P);
	int n=2*P.count;
	double[] y=new double[n/2];
	int i1,i2,i3;
	for(int i=0;i<n;i=i+2) {
	    i1=(i+1+n)%n;
	    i2=(i+2+n)%n;
	    i3=(i+3+n)%n;
	    y[i/2]=(1-x[i1])*(1-x[i2]*x[i3]);
	}
	return(y);
    }

    public static double[] conicInvariant(PolyVector P) {
	double[] x1=conicInvariant1(P);
	double[] x2=conicInvariant2(P);
	double[] x=new double[P.count];
	for(int i=0;i<P.count;++i) {
	    x[i]=x2[i]-x1[i];
	}
    return(x);
    }


    public static double howInscribed(PolyVector P) {
	double[] x=conicInvariant(P);
	double test=0;
	for(int i=0;i<P.count;++i) {
	    test=test+x[i]*x[i];
	}
	test=Math.sqrt(test);
	return(test);
    }



    public static double conicPoly1(PolyVector P) {
	double[] x=conicInvariant(P);
	double total=0;
	for(int i=0;i<P.count;++i) total=total+x[i];
	return(total);
    }

    public static double conicPoly2(PolyVector P,int d) {
	double[] x=conicInvariant(P);
	double total=0;
	int i1,i2;

	for(int i=0;i<P.count;++i) {
	    i1=i;
	    i2=(i+d)%P.count;
	    total=total+x[i1]*x[i2];
	}
	return(total);
    }


    public static PolyVector penta(double p1,double q2,double p3) {
	PolyVector X=new PolyVector();
	X.count=5;
	X.V[0]=new Vector(0,1,0);
	X.V[1]=new Vector(0,1,1);
	X.V[2]=new Vector(1,1,1);
	X.V[3]=new Vector(1,1,1-p1);
	X.V[4]=new Vector(1-p3,1-p3+p1*q2*p3,1-p1-p3+p1*q2*p3);
	X=Matrix.normalize(X,0);
	return(X);
    }


    public static PolyVector develop(double[] x,int n) {
	int spot=1;
	int i1,i2,i3;
	int N=x.length;
	PolyVector X=penta(x[1],x[2],x[3]);
	PolyVector Y=new PolyVector();
	for(int i=0;i<n+N+3;++i) {
	    i1=(2*spot+1)%N;
	    i2=(2*spot+2)%N;
	    i3=(2*spot+3)%N;
	    Y=penta(x[i1],x[i2],x[i3]);
	    X.V[spot+4]=Matrix.nextVector(X.V[spot],X.V[spot+1],X.V[spot+2],X.V[spot+3],Y.V[4]);
	    ++spot;
	}
	X.count=spot+5;
	X=X.normalize();

	PolyVector XX=new PolyVector();
	for(int i=0;i<n;++i) {
	    XX.V[i]=X.V[i+N+1];
	}
	XX.count=n;
	return(XX);
    }


    public static PolyVector funnyRescale(PolyVector X,double t,int N) {
	double[] d=XInvariants.invariant(X);
	for(int i=0;i<X.count;++i) {
	    d[2*i+0]=d[2*i+0]*t;
	    d[2*i+1]=d[2*i+1]/t;
	}
	PolyVector Y=XInvariants.develop(d,2*X.count*N);
	Y.wrap=X.count;
	return(Y);
    }

}