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

public class TreeFunctions {

    /*This routine takes the average of a list of complex numbers*/

    public static Complex average(Complex[] Z,int COUNT) {
	Complex w=new Complex(0,0);
	for(int i=0;i<COUNT;++i) w=Complex.plus(w,Z[i]);
	w.x=w.x/COUNT;
	w.y=w.y/COUNT;
	return(w);
    }


    /**These two routines rotate the complex number "moved" about the
       complex number "fixed" */

    public static Complex rotate(Complex fixed,Complex moved,double step) {
        Complex w=new Complex(Math.cos(step),Math.sin(step));
	return(rotate(fixed,moved,w));
    }

    public static Complex rotate(Complex fixed,Complex moved,Complex u) {
	Complex z=Complex.minus(moved,fixed);
	z=Complex.times(z,u);
	z=Complex.plus(z,fixed);
	return(z);
    }


    /**These two routines compute the average rotation of a number
       with respect to a list of numbers*/


    public static Complex rotateAverage(Complex[] fixed,int COUNT,Complex moved,double step) {
        Complex w=new Complex(Math.cos(step),Math.sin(step));
	return(rotateAverage(fixed,COUNT,moved,w));
    }


    public static Complex rotateAverage(Complex[] fixed,int COUNT,Complex moved,Complex u) {
	Complex[] Z=new Complex[COUNT];
	for(int i=0;i<COUNT;++i) Z[i]=rotate(fixed[i],moved,u);
	Complex w=average(Z,COUNT);
	return(w);
    }




    /**These two routines rotate the whole list of complex numbers
       about the origin*/

    public static Complex[] rotateEntire(Complex[] Z,int COUNT,Complex u) {
	Complex[] W=new Complex[COUNT];
	double d=maxDist(Z,COUNT);
	Complex z=new Complex(0,0);
	for(int i=0;i<COUNT;++i) {
	    W[i]=rotate(z,Z[i],u);
	}
	return(W);
    }

    public static Complex[] rotateEntire(Complex[] Z,int COUNT,double step) {
       Complex w=new Complex(Math.cos(step),Math.sin(step));
       return(rotateEntire(Z,COUNT,w));
    }



    /*This computes the maximum distance from the origin*/

    public static double maxDist(Complex[] Z,int COUNT) {
	double max=0;
	double dist=0;
	for(int i=0;i<COUNT;++i) {
	    dist=Z[i].norm();
	    if(max<dist) max=dist;
	}
	return(max);
    }

    /*This rescales the picture about the origin*/

    public static Complex[] rescale(Complex[] Z,int COUNT) {
	Complex[] W=new Complex[COUNT];
	double d=maxDist(Z,COUNT);
	double e=0;
	Complex u=new Complex();
	for(int i=0;i<COUNT;++i) {
	    e=Z[i].norm()/d;
	    u=new Complex(Z[i]);
	    if(u.norm()>.00001) {
	      u=u.unit();
	      u.x=e*u.x;
	      u.y=e*u.y;
	    }
	    W[i]=new Complex(u);
	}
	return(W);
    }



    /**This translates the central node to the origin*/

   public static Complex[] translate(Complex[] Z,int COUNT) {	
         Complex[] W=new Complex[COUNT];
	for(int i=0;i<COUNT;++i) {
	    W[i]=Complex.minus(Z[i],Z[0]);
	}
	return(W);
   }



}