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


public class GroupAction {

    public GroupAction() {}

    public static double mapx(int choice,double y) {
	double A=phi(-3);
	double B=phi(-2)-phi(-5);
	if(choice==0) return(A*y-A*A-3*A);  
	if(choice==1) return(y+B);
	if(choice==2) return(A*y);
	if(choice==3) return(y-B);
	if(choice==4) return(A*y+A*A+3*A);
	return(0);
    }


    public static double map(double y1) {
	if(y1==1) return(1);
	if(y1<=1) return(map0(y1));
	return(2-map0(2-y1));
    }

    public static double map0(double y1) {      
        double A=Math.sqrt(5)-2;	
	int i=Characteristics.getInterval1(y1);
	double y2=0;
 	if(i==0) y2=y1/A;
 	if(i==1) y2=2*phi(-1)+y1;
 	if(i==2) y2=(y1+A-1)/A;
	y2=y2-2*Math.floor(y2/2);
        return(y2);
    }


    public static double switchRoots(double x) {
	double y=map(x);
	return(preferredInverse(y));
    }

    public static double preferredInverse(double y) {
	double[] x=inverseMap(y);
	for(int i=0;i<3;++i) {
	    int i0=i;
	    int i1=(i+1)%3;
	    int i2=(i+2)%3;
   	    if((x[i0]<=1)&&(x[i1])<=1) return(x[i2]);
   	    if((x[i0]>=1)&&(x[i1])>=1) return(x[i2]);
	}
	return(-1);
    }


    public static double[] inverseMap(double y) {
	double[] x={inverseMap0(y),inverseMap1(y),inverseMap2(y)};
	return(x);
    }

    public static double inverseMap0(double y) {
	if(y<=phi(1)) return(y*phi(-3));
	return(y-phi(1)+phi(-2));
    }

    public static double inverseMap1(double y) {
	return(y*phi(-3)+1-phi(-3));
    }

    public static double inverseMap2(double y) {
	if(y<=phi(-2)) return(y+1+phi(-3));
	return((y-2)*phi(-3)+2);
    }


    public static int getBranch(double x,double y) {
	double[] X=inverseMap(y);
	for(int i=0;i<3;++i) {
	    if(Math.abs(x-X[i])<.001) return(i);
	}
	return(-1);
    }




    public static BigDecimal mapQ(BigDecimal y1) {
	BigDecimal ONE=new BigDecimal("1");
	BigDecimal TWO=new BigDecimal("2");
	BigDecimal y2=map0Q(y1);
	if(y1.compareTo(ONE)<=0) return(y2);
	y2=map0Q(TWO.subtract(y1));
	y2=TWO.subtract(y2);
	return(y2);
    }

    public static int indexQ(BigDecimal x) {
	BigDecimal A=phiQ(3);
	BigDecimal ONE=new BigDecimal("1");
	BigDecimal[] CUT=new BigDecimal[4];
	CUT[0]=new BigDecimal("0");
	CUT[1]=phiQ(2);
	CUT[2]=ONE.subtract(A);
	CUT[3]=new BigDecimal("1");
	for(int i=0;i<3;++i) {
	    if((x.compareTo(CUT[i])>=0)&&(x.compareTo(CUT[i+1])<=0)) return(i);
	}
	return(-1);
    }

	public static BigDecimal map0Q(BigDecimal y1) {
	     BigDecimal A=phiQ(3);
	     BigDecimal ONE=new BigDecimal("1");
	     BigDecimal TWO=new BigDecimal("2");
  	     int i=indexQ(y1);
	     if(i==0) {
		 BigDecimal y2=y1.divide(A,BigDecimal.ROUND_HALF_DOWN);
	                   return(y2);
	     }

	     if(i==1) {
	            BigDecimal P=new BigDecimal(".618033988749894848204586834365638117720309179805762862135448622705");
	            BigDecimal y2=y1.add(TWO.multiply(P));
	            return(y2);
	     }
	     BigDecimal y2=y1.add(A.subtract(ONE));
	     y2=y2.divide(A,BigDecimal.ROUND_HALF_DOWN);
	     return(y2);
	}



    public static double phi(int k) {
	double phi=(1+Math.sqrt(5))/2;
	double a=Math.pow(phi,k);
	return(a);
    }


    public static BigDecimal phiQ(int k) {
	BigDecimal P=new BigDecimal(".618033988749894848204586834365638117720309179805762862135448622705");
	BigDecimal X=new BigDecimal("1");
	if(k==0) return(X);
	for(int i=0;i<k;++i) {
	    X=X.multiply(P);
	}
	return(X);
    }



    public static BigDecimal f0(BigDecimal x) {
	BigDecimal ONE=new BigDecimal("1");
	BigDecimal TWO=new BigDecimal("2");
	BigDecimal P1=new BigDecimal(".618033988749894848204586834365638117720309179805762862135448622705");
	BigDecimal P2=new BigDecimal("1.618033988749894848204586834365638117720309179805762862135448622705");
	if(x.compareTo(P1)<=0) return(x);
	if(x.compareTo(ONE)>=0) {
  	       BigDecimal y=TWO.subtract(x);
	       return(y);
	}
	BigDecimal y=P2.subtract(P2.multiply(x));
	return(y);
    }


    public static BigDecimal f1(BigDecimal X) {
	return(f0(f0(X)));
    }

    public static BigDecimal partition(int n) {
	BigDecimal total=new BigDecimal("0");
	int count=1;
	for(int i=0;i<n;++i) {
	    total=total.add(phiQ(3*count));
	    if(i%2==1) ++count;
	}
	return(total);
    }


    public static BigDecimal[] f2(BigDecimal x) {
	for(int i=0;i<100;++i) {
	    BigDecimal y1=partition(i);
	    BigDecimal  y2=partition(i+1);
	    if((y1.compareTo(x)<=0)&&(x.compareTo(y2)<=0)) {
		BigDecimal[] Y={y1,y2,new BigDecimal(new Double(i))};
		return(Y);
	    }
	}

	BigDecimal ZERO=new BigDecimal("0");
	BigDecimal[] Y={ZERO,ZERO,ZERO};
	return(Y);
    }




    public static BigDecimal f3(BigDecimal x,int k) {
	BigDecimal[] y=f2(x);
	BigDecimal ONE=new BigDecimal("1");

	BigDecimal t1=x.subtract(y[0]);
	t1=t1.divide(y[1].subtract(y[0]),BigDecimal.ROUND_HALF_DOWN);
	BigDecimal t2=ONE.subtract(t1);
	t1=f1(t1);
	t2=f1(t2);
	if(k%2==0) return(t1);
	return(t2);
    }




    public static int[] sequence1(BigDecimal x,int lim) {
                   BigDecimal  t=f1(x);
	int[] N=new int[lim];   
	for(int i=0;i<lim;++i) {
	    BigDecimal[] y=f2(t);
	    N[i]=(int)(y[2].doubleValue());
	    t=f3(t,N[i]);
	}
	return(N);
    }



    public static int[] sequence(BigDecimal x,int lim) {
	int[] N=new int[lim];   
	BigDecimal y=x.add(new BigDecimal("0"));

	for(int i=0;i<lim;++i) {
	    N[i]=index2Q(y);
	    y=mapQ(y);
	}
	return(N);
    }

    public static int index2Q(BigDecimal x) {
	BigDecimal A=phiQ(3);
	BigDecimal ONE=new BigDecimal("1");
	BigDecimal TWO=new BigDecimal("2");
	BigDecimal[] CUT=new BigDecimal[6];
	CUT[0]=new BigDecimal("0");
	CUT[1]=phiQ(2);
	CUT[2]=ONE.subtract(A);
	CUT[3]=TWO.subtract(CUT[2]);
	CUT[4]=TWO.subtract(CUT[1]);
	CUT[5]=TWO;
	for(int i=0;i<5;++i) {
	    if((x.compareTo(CUT[i])>=0)&&(x.compareTo(CUT[i+1])<=0)) return(i);
	}
	return(-1);
    }

}