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


public class PolyVector {
    Vector[] V=new Vector[100];
    int count;
    int wrap;

    public PolyVector() {
	for(int i=0;i<99;++i) 
	    V[i]=new Vector();
	wrap=0;
    }



    public PolyVector rotate(double d) {
	PolyVector X=new PolyVector();
	X.count=this.count;
	for(int i=0;i<count;++i) {
	    X.V[i]=this.V[i].rotate(d);
	}
	return(X);
    }



/* inscribed to circumscribed */

   public PolyVector toCirc(Complex z) {

     PolyVector Q=this.normalize();
     for(int i=0;i<Q.count;++i) {
        Q.V[i]=new Vector(-V[i].x[0],-V[i].x[1],1);
     }
    Q=Q.dualize(); 
    Q=Q.normalize();
    return(Q);
  }



    public PolyVector(PolyVector Q) {
	this.count=Q.count;
	for(int i=0;i<Q.count;++i) this.V[i]=Q.V[i];
	this.wrap=Q.wrap;
    }

    public PolyVector normalize() {
	PolyVector P=new PolyVector();
	P.count=count;
	for(int i=0;i<count;++i) {
	    P.V[i]=V[i].normalize();
	}
	P.wrap=wrap;
	return(P);
    }


    public GeneralPath toGeneralPath() {
	PolyVector P=this.normalize();
	GeneralPath gp=new GeneralPath();
	gp.moveTo((float)(P.V[0].x[0]),(float)(P.V[0].x[1]));
	for(int i=0;i<count;++i) {
	   gp.lineTo((float)(P.V[i].x[0]),(float)(P.V[i].x[1]));
	}
	gp.closePath();
	return(gp);
    }

    public GeneralPath toPentaPath(int k) {
	PolyVector P=this.normalize();
	GeneralPath gp=new GeneralPath();
	int i1,i2;
	for(int i=0;i<count;++i) {
	    i1=i;
	    i2=(i+k)%count;
	   gp.moveTo((float)(P.V[i1].x[0]),(float)(P.V[i1].x[1]));
	   gp.lineTo((float)(P.V[i2].x[0]),(float)(P.V[i2].x[1]));
	}
	return(gp);
    }


    public static PolyVector regular(int n,int c) {

	PolyVector X=new PolyVector();
	X.count=n;
	for(int i=0;i<n;++i) {
	    double t=c*2.0*Math.PI*i/n;
	    X.V[i]=new Vector(Math.cos(t),Math.sin(t));
	}
	return(X);
    }


    public PolyVector unitize() {
	PolyVector X=new PolyVector();
	X.count=this.count;
	for(int i=0;i<count;++i) {
	    X.V[i]=this.V[i].unitize();
	}
	return(X);
    }


    public int nearestVertex(Complex z) {
	int index=-1;
	Vector W=new Vector(z);
	double min=1000000.0;
	for(int i=0;i<count;++i) {
	    double test=W.dist(W,this.V[i]);
	    if(test<min) {
		min=test;;
		index =i;
	    }
	}
	return(index);
    }

    public PolyVector pentagram() {

	PolyVector X=new PolyVector();
	X.count=count;
	int i1,i2,i3,i4;
	for(int i=0;i<count;++i) {
	    i1=(i-1+count)%count;
	    i2=(i-0+count)%count;
	    i3=(i+1+count)%count;
	    i4=(i+2+count)%count;
	    //ordering is deliberate
	    X.V[i]=V[i].findCross(V[i1],V[i3],V[i2],V[i4]);
	}
	X=X.normalize();
	return(X);
    }


    public PolyVector pentagram(int k1,int k2) {

	PolyVector X=new PolyVector();
	X.count=count;
	int i1,i2,i3,i4;
	int k3=k1+k2;
	for(int i=0;i<count;++i) {
	    i1=(i+0+ count)%count;
	    i2=(i+k2+count)%count;
	    i3=(i+k1+count)%count;
	    i4=(i+k3+count)%count;
	    //ordering is deliberate
	    X.V[i]=V[i].findCross(V[i1],V[i3],V[i2],V[i4]);
	}
	int h=(k1+k2)/2;
	X=X.cycleVertices(-h);
	X=X.normalize();
	return(X);
    }


    public PolyVector dualize() {

	PolyVector X=new PolyVector();
	X.count=this.count;
	for(int i=0;i<count;++i) {
	    int i0=(i+0)%count;
	    int i1=(i+1)%count;
	    X.V[i]=Vector.cross(V[i0],V[i1]);
	}
	X=X.normalize();
	return(X);
    }



    public PolyVector cycleVertices(int h) {
	PolyVector X=new PolyVector();
	X.count=this.count;
	for(int i=0;i<count;++i) {
	    int j=(i+h+100*count)%count;
	    X.V[i]=V[j];
	}
	return(X);
    }




    public void print() {
	for(int i=0;i<count;++i) V[i].print();
    }


    public double[] toConic() {
	return(Conic.toConic(V[0],V[1],V[2],V[3],V[4]));
    }




}