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

public class SanityChecks implements Runnable {
    int halt;
    Manager M;

    public SanityChecks() {
    }

    public SanityChecks(Manager MM) {
	this.M=MM;	
                  sendMessage(0,0);
	halt=0;	
    }


    public void run() {		
         double E=M.C.ENERGY.getParameter();   //power law exponent
	 halt=1;
	 int mode=M.C.SCC.ACTION.mode;
	 System.out.println("mode "+mode);
	 if(mode==0) testDelta();
	 if(mode==1) testSeparationUpperBound0();
	 if(mode==2) testSeparationLowerBound0();
	 if(mode==3) testXtraVector0();
	 if(mode==4) testEnergyTheorem0(E);
	 if(mode==5) testInterval();
	 if(mode==6) testIntervalComplex();
	 if(mode==7) testIntervalVector();
	 if(mode==8) testStereo();
	 if(mode==9) testBoxRoutines();
	 if(mode==10) testSeparation();
	 if(mode==11) testEnergy();
	 if(mode==12) testBinary();
	 halt=0;

    }


    public void sendMessage(int i, double min) {
	M.C.SCC.d[0]=i;
	M.C.SCC.d[1]=min;
	M.C.repaint();
    }


    /**Checks that the function delta from the paper really does give a bound to the radius
       of a spherical patch.    the output (min) should exceed 1.*/

    public void testDelta() {
	double min=100000000;
	Box b1=new Box(new Complex(0,0),-2,0,1);
	int t=M.C.SCC.SI[2].val; 
	Box[] LIST=SanityCheckSupport.getBoxList(b1,t);
	for(int i=0;i<LIST.length;++i) {
	    double radius1=LIST[i].delta()*LIST[i].tau()/2;
	    double radius2=XtraBox.crudeRadius(LIST[i]);
	    double test=radius1/radius2;  //should exceed 1
	    if(min>test) min=test;
	    sendMessage(i,min);
	}
	halt=0;
    }


    /**Checks that the separation upper bound works.  Min should exceed 1*/

    public void testSeparationUpperBound0() {
	double min=10000000;
	Box b1=new Box(new Complex(0,0),-2,0,1);
	int t=M.C.SCC.SI[2].val; 
	Box[] LIST1=SanityCheckSupport.getBoxList(b1,t);
	Box[] LIST2=SanityCheckSupport.getBoxList(b1,t);

	int i=0;
	while((halt==1)&&(i<LIST1.length)) {
	    for(int j=0;j<LIST2.length;++j) {
		double crude=testSeparationUpperBound1(LIST1[i],LIST2[j]);
		double estimate=Separation.psiMax(LIST1[i],LIST2[j]);
		double test=estimate/crude;
		if(test<1) {
		    System.out.println("");
		    LIST1[i].print();
		    LIST2[j].print();
		}

		if(min>test) min=test;
	    }
	    sendMessage(i,min);
	    ++i;
	}
	halt=0;
    }



    public double testSeparationUpperBound1(Box B1,Box B2) {

	int N=M.C.SCC.SI[4].val;   //number of sample points in box
	N=(int)(Math.pow(2,N));

	double max=0;

	for(int i1=0;i1<N;++i1) {
	    for(int i2=0;i2<N;++i2) {
		for(int j1=0;j1<N;++j1) {
		    for(int j2=0;j2<N;++j2) {
			double s1=1.0*i1/N;
			double t1=1.0*i2/N;
			double s2=1.0*j1/N;
			double t2=1.0*j2/N;
			double d=XtraBox.testDistance(B1,B2,s1,t1,s2,t2);
			if(max<d) max=d;
		    }
		}
	    }
	}
	return(max);
    }



    public void testSeparationLowerBound0() {
	double min=10000000;
	Box b1=new Box(new Complex(0,0),-2,0,1);
	int t=M.C.SCC.SI[2].val; 
	Box[] LIST1=SanityCheckSupport.getBoxList(b1,t);
	Box[] LIST2=SanityCheckSupport.getBoxList(b1,t);

	int i=0;
	while((halt==1)&&(i<LIST1.length)) {
	    for(int j=0;j<LIST2.length;++j) {
		double crude=testSeparationLowerBound1(LIST1[i],LIST2[j]);
		double estimate=Separation.psiMin(LIST1[i],LIST2[j]);
		if(estimate>0) {
		    double test=crude/estimate;
		    if(min>test) min=test;
		}
	    }
	    sendMessage(i,min);
	    ++i;
	}
	halt=0;
    }





    public double testSeparationLowerBound1(Box B1,Box B2) {

	int N=M.C.SCC.SI[4].val;   //number of sample points in box
	N=(int)(Math.pow(2,N));

	double min=2;

	for(int i1=0;i1<N;++i1) {
	    for(int i2=0;i2<N;++i2) {
		for(int j1=0;j1<N;++j1) {
		    for(int j2=0;j2<N;++j2) {
			double s1=1.0*i1/N;
			double t1=1.0*i2/N;
			double s2=1.0*j1/N;
			double t2=1.0*j2/N;
			double d=XtraBox.testDistance(B1,B2,s1,t1,s2,t2);
			if(min>d) min=d;
		    }
		}
	    }
	}
	return(min);
    }




    /**Checks that some of our routines for spherical geometry are working.**/

    public void testXtraVector0() {
	double min=1;
	Box b1=new Box(new Complex(0,0),-2,0,1);
	int t=M.C.SCC.SI[2].val; 
	Box[] LIST=SanityCheckSupport.getBoxList(b1,t);
	for(int i=0;i<LIST.length;++i) {
	    double test= testXtraVector1(LIST[i]);
	    if(min>test) min=test;
	    sendMessage(i,min);
	}
	halt=0;
    }


    public double testXtraVector1(Box B) {
	Vector[] V=B.toVectors();
	Vector X=XtraVector.center(V[0],V[1]);
	double d1=Vector.dist(X,new Vector(0,0,1));
	double d2=Vector.dist(X,V[0]);
	double d3=Vector.dist(X,V[1]);

	if(Math.abs(d1-d2)>.0000001) return(0);
	if(Math.abs(d1-d3)>.0000001) return(0);
	if(Math.abs(d2-d3)>.0000001) return(0);

	Vector Y=XtraVector.farPoint(V[0],V[1]);
	double d4=Vector.dist(Y,X);
	double d5=Vector.dist(Y,V[0]);
	double d6=Vector.dist(Y,V[1]);
	double d7=XtraVector.norm(Y);

	if(Math.abs(1-d7)>.0000001) return(0);
	if(Math.abs(d1-d4)>.0000001) return(0);
	if(Math.abs(d5-d6)>.0000001) return(0);

	for(int i=0;i<=10;++i) {
	                  Vector H=XtraVector.interpolate(V[0],V[1],1.0*i/10);
		 double d8=XtraVector.norm(H);
	                   if(Math.abs(1-d8)>.0000001) return(0);
		 double d9=Vector.dist(H,X);	
                                     if(Math.abs(d9-d4)>.0000001) return(0);
	}
                  	return(1);
    }



    /**Energy Theorem **/


    public void testEnergyTheorem0(double E) {
	double min=10000000;
	Box b1=new Box(new Complex(0,0),-2,0,1);
	int t1=M.C.SCC.SI[2].val; 
	int t2=M.C.SCC.SI[3].val; 
	Box[] LIST1=SanityCheckSupport.getBoxList(b1,t1);
	Box[] LIST2=SanityCheckSupport.getBoxList(b1,t2);

	int i=0;
	while((halt==1)&&(i<LIST1.length)) {
	    for(int j=0;j<LIST2.length;++j) {
		double test=testEnergyTheorem1(E,LIST1[i],LIST2[j]);
		if(min>test) min=test;
	    }
	    sendMessage(i,min);
	    ++i;
	}
	halt=0;
    }




    public double testEnergyTheorem1(double E,Box B1,Box B2) {
	int N=M.C.SCC.SI[4].val;   //number of sample points in box
	N=(int)(Math.pow(2,N));
	double num=0;

	for(int i=0;i<=N;++i) {
	    for(int j=0;j<=N;++j) {
		double a=1.0*i/N;
		double b=1.0*j/N;	
		double test=XtraEnergy.discrepancy0(E,B1,B2,a,b);
		if(num<test) num=test;
	    }
	}
	double d=B1.delta();
	double epsilon=EnergyEstimator.epsilon(E,B1,B2);
	double estimate=epsilon*d*d;
	if(estimate<10000) {
	    double ratio=estimate/num;
	    return(ratio);
	}

	return(10000);
    }
    


    /**Interval arithmetic**/




    public void testInterval() {


	System.out.println("representation of doubles");
	double x=316.875;
                      long xx = Double.doubleToLongBits(x);
	    System.out.println(Long.toBinaryString(xx));
    	     x=317;
                       xx = Double.doubleToLongBits(x);
	    System.out.println(Long.toBinaryString(xx));

	System.out.println("");



	System.out.println("interval operations");

	Interval K=new Interval();
	Interval I=new Interval(3,4);
	Interval J=new Interval(5,6);
	Interval I2=new Interval(1/256.0);
	I.print();
	J.print();

	System.out.println("max");
	K=Interval.max(I,J);
	K.print();

	System.out.println("min");
	K=Interval.min(I,J);
	K.print();

	System.out.println("plus");
	K=Interval.plus(I,J);
	K.print();

	System.out.println("minus");
	K=Interval.minus(I,J);
	K.print();

	System.out.println("times");
	K=Interval.times(I,J);
	K.print();

	System.out.println("divide");
	K=Interval.divide(I,J);
	K.print();

	System.out.println("sqrt");
	for(int i=1;i<3;++i) {
	    I2=new Interval(Math.pow(.5,i));
	    K=Interval.sqrt(I2);
	      I2.print();
	      K.print();
	      System.out.println("");
	}



	System.out.println("abs");
	I=new Interval(2,3);
	K=Interval.abs(I);
	I.print();
	K.print();
	System.out.println("");

	I=new Interval(-3,-2);
	K=Interval.abs(I);
	I.print();
	K.print();
	System.out.println("");

	I=new Interval(-2,3);
	K=Interval.abs(I);
	I.print();
	K.print();

    }



    public void testIntervalComplex() {
	System.out.println("complex interval operations");

	IntervalComplex z1=new IntervalComplex(new Interval(2,2.1),new Interval(3,3.1));
	IntervalComplex z2=new IntervalComplex(new Interval(-3,-2.8),new Interval(5,5.1));
	z1.print();
	z2.print();

	IntervalComplex z3=new IntervalComplex();

	System.out.println("plus");
	z3=IntervalComplex.plus(z1,z2);
	z3.print();

	System.out.println("average");
	z3=IntervalComplex.average(z1,z2);
	z3.print();

	System.out.println("minus");
	z3=IntervalComplex.minus(z1,z2);
	z3.print();

	System.out.println("max norm");
	Interval I=IntervalComplex.distMaxNorm(z1,z2);
	I.print();
    }


    public void testIntervalVector() {
	System.out.println("complex interval operations");

	IntervalVector V1=new IntervalVector(new Interval(1,1.1),new Interval(2.2,2.4),new Interval(4.4,5.1));
	IntervalVector V2=new IntervalVector(new Interval(-1,-.7),new Interval(-5,-4),new Interval(6.5,7.1));
	V1.print();
	V2.print();

	IntervalVector V3=new IntervalVector();

	System.out.println("plus");
	V3=IntervalVector.plus(V1,V2);
	V3.print();

	System.out.println("minus");
	V3=IntervalVector.minus(V1,V2);
	V3.print();

	System.out.println("dot");
	Interval I=IntervalVector.dot(V1,V2);
	I.print();

	System.out.println("dist");
	System.out.println("dot");
	I=IntervalVector.dist(V1,V2);
	I.print();

    }

    public void testStereo() {

	double a=3/(5*Math.sqrt(2));
	double b=2*Math.sqrt(2)/5;
	double c=Math.sqrt(2)/2;
	Vector V=new Vector(a,b,c);
	IntervalVector IV=new IntervalVector(new Interval(a,a),new Interval(b,b),new Interval(c,c));

	System.out.println("vectors ");

	V.print();
	IV.print();

	System.out.println("apply stereographic projection");

	Complex z=Stereo.stereo(V);
	IntervalComplex Iz=IntervalStereo.stereo(IV);
	z.print();
	Iz.print();

	System.out.println("apply inverse stereographic projection");

	Vector W=Stereo.inverseStereo(z);
	IntervalVector IW=IntervalStereo.inverseStereo(Iz);
	W.print();
	IW.print();
    }

    public void testBoxRoutines() {

	Complex z=new Complex(1.0/4.0,5.0/8.0);
	IntervalComplex Iz=new IntervalComplex(new Interval(1.2),new Interval(-2.3));
	Box B=new Box(z,3,0,1);
	IntervalBox IB=IntervalBox.create(B);

	System.out.println("print boxes");
	B.print();
	IB.print();
	System.out.println("");

	System.out.println("center");
	Vector V=B.getCenter();
	V.print();
	IntervalVector IV=IB.getCenter();
	IV.print();

	System.out.println("");

	System.out.println("sidelength");
	double s=B.sidelength();
	Interval Is=IB.sidelength();
	System.out.println(s);
	Is.print();

	System.out.println("");

	System.out.println("vertices");
	Complex[] Z=B.toVertices();
	IntervalComplex[] IZ=IB.toVertices();
	for(int i=0;i<4;++i) {
	    Z[i].print();
	    IZ[i].print();
	    System.out.println("");
	}

	System.out.println("");

	System.out.println("stereo vertices");
	Vector[] W=B.toVectors();
	IntervalVector[] IW=IB.toVectors();
	for(int i=0;i<4;++i) {
	    W[i].print();
	    IW[i].print();
	    System.out.println("");
	}

	System.out.println("");
	System.out.println("side bounds");

	double d=0;
	Interval Id=new Interval();

	d=B.xAbsMin();
	Id=IB.xAbsMin();
	System.out.print(d+" ");
	Id.print();

	d=B.yAbsMin();
	Id=IB.yAbsMin();
	System.out.print(d+" ");
	Id.print();

	d=B.xAbsMax();
	Id=IB.xAbsMax();
	System.out.print(d+" ");
	Id.print();

	d=B.yAbsMax();
	Id=IB.yAbsMax();
	System.out.print(d+" ");
	Id.print();
	Id.print();

	System.out.println("");
	System.out.println("delta");

	d=B.delta();
	Id=IB.delta();
	System.out.print(d+" ");
	Id.print();

	System.out.println("");
	System.out.println("tau");

	d=B.tau();
	Id=IB.tau();
	System.out.print(d+" ");
	Id.print();
    }

    public void testSeparation() {

	Complex z1=new Complex(1.0/8.0,-3.0/4.0);
	Box B1=new Box(z1,3,0,1);
	IntervalBox IB1=IntervalBox.create(B1);

	Complex z2=new Complex(-3.0/2.0,5.0/32.0);
	Box B2=new Box(z2,3,1,1);
	IntervalBox IB2=IntervalBox.create(B2);

	Box B3=new Box(new Complex(),0,2,1);
	IntervalBox IB3=IntervalBox.create(B3);

	System.out.println("separation");

	B1.print();
	IB1.print();

	B2.print();
	IB2.print();

	double d=0;
	Interval Id=new Interval(0);

	System.out.println("upper bound");
	d=Separation.psiMax(B1,B2);
	Id=IntervalSeparation.psiMax(IB1,IB2);
	System.out.print(d+" ");
	Id.print();

	System.out.println("lower bound");
	d=Separation.psiMin(B1,B2);
	Id=IntervalSeparation.psiMin(IB1,IB2);
	System.out.print(d+" ");
	Id.print();

	System.out.println("upper bound identical boxes");
	d=Separation.psiMax(B2,B2);
	Id=IntervalSeparation.psiMax(IB2,IB2);
	System.out.print(d+" ");
	Id.print();

	System.out.println("lower bound identical boxes");
	d=Separation.psiMin(B2,B2);
	Id=IntervalSeparation.psiMin(IB2,IB2);
	System.out.print(d+" ");
	Id.print();

	System.out.println("perfect upper bound");
	d=Separation.psiMax(B1,B3);
	Id=IntervalSeparation.psiMax(IB1,IB3);
	Interval Id2=IntervalSeparation.perfectUpperBound(IB1,IB3);
	System.out.print(d+" ");
	Id.print();
	Id2.print();

	System.out.println("perfect lower bound");
	d=Separation.psiMin(B1,B3);
	Id=IntervalSeparation.psiMin(IB1,IB3);	
                  Id2=IntervalSeparation.perfectLowerBound(IB1,IB3);
	System.out.print(d+" ");
	Id.print();
	Id2.print();

    }


    public void testEnergy() {

	Complex z1=new Complex(1.0/8.0,-3.0/4.0);
	Box B1=new Box(z1,3,0,1);
	IntervalBox IB1=IntervalBox.create(B1);

	Complex z2=new Complex(-3.0/2.0,5.0/32.0);
	Box B2=new Box(z2,3,1,1);
	IntervalBox IB2=IntervalBox.create(B2);


	System.out.println("min interaction");

	double d=Energy.energyLowerBound(1,B1,B2);
	Interval Id=IntervalEnergy.energyLowerBound(1,IB1,IB2);
	System.out.print(d+" ");
	Id.print();


	System.out.println("TBP energy");
	d=Energy.minEnergy(1);
	Id=IntervalEnergy.minEnergy(1);
	System.out.print(d+" ");
	Id.print();

	System.out.println("tetra bound");
	d=Energy.tetrahedralComplement(1);
	Id=IntervalEnergy.tetrahedralComplement(1);
	System.out.print(d+" ");
	Id.print();
	System.out.println("");
	d=Energy.tetrahedralComplement(2);
	Id=IntervalEnergy.tetrahedralComplement(2);
	System.out.print(d+" ");
	Id.print();


	System.out.println("Lambda1");
	double R=Separation.psiMin(B1,B2);
	Interval IR=IntervalSeparation.psiMin(IB1,IB2);	
	d=EnergyEstimator.lambda1(1.0,B1,B2,R);
	Id=IntervalEnergyEstimator.lambda1(1.0,IB1,IB2,IR);
	System.out.print(d+" ");
	Id.print();

	System.out.println("Lambda2");
	R=Separation.psiMin(B1,B2);
	IR=IntervalSeparation.psiMin(IB1,IB2);	
	d=EnergyEstimator.lambda2(1.0,B1,B2,R);
	Id=IntervalEnergyEstimator.lambda2(1.0,IB1,IB2,IR);
	System.out.print(d+" ");
	Id.print();

	System.out.println("epsilon");
	d=EnergyEstimator.epsilon(1.0,B1,B2);
	Id=IntervalEnergyEstimator.epsilon(1.0,IB1,IB2);
	System.out.print(d+" ");
	Id.print();
    }

    public void testBinary() {
	for(int i=0;i<128;++i) {
	    int[] k=BoxConfiguration.binary7(i);
	
	    for(int j=0;j<7;++j) System.out.print(k[j]);    
                      System.out.print("      "+i+"   ");
	    System.out.println("");
	}
    }

}