package Current.popups.Polynomial;

import Current.*;
import Current.basic.*;

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


/*This class does some basic manipulations with
BigPolynomials with BigComplex coefficients.  I set the
maximum degree at 100*/


public class BigPolynomial {
    public BigComplex[] z=new BigComplex[100];   //the coefficients
    public int D;  //the degree


    /**basic constructors*/
    public BigPolynomial() {
	D=0;
	for(int i=0;i<100;++i) z[i]=new BigComplex();
    }

    public BigPolynomial(BigComplex[] w,int d) {
	D=d;
	for(int i=0;i<100;++i) z[i]=new BigComplex();
	for(int i=0;i<=d;++i) z[i]=new BigComplex(w[i].x,w[i].y);
    }

    /**vector space operations*/

    public BigPolynomial scale(BigComplex w) {
	BigPolynomial P=new BigPolynomial();
	P.D=D;
	for(int i=0;i<=D;++i) {
	    P.z[i]=BigComplex.times(w,z[i]);
	}
	return(P);
    }

    public BigPolynomial plus(BigPolynomial P) {
	int d;
	d=this.D;
	if(d<P.D) d=P.D;
	BigPolynomial Q=new BigPolynomial();
	Q.D=d;
	for(int i=0;i<99;++i)
	    Q.z[i]=BigComplex.plus(z[i],P.z[i]);
	return(Q);
    }


    public BigPolynomial minus(BigPolynomial P) {
	int d;
	d=this.D;
	if(d<P.D) d=P.D;
	BigPolynomial Q=new BigPolynomial();
	Q.D=d;
	for(int i=0;i<99;++i)
	    Q.z[i]=BigComplex.minus(z[i],P.z[i]);
	return(Q);
    }



    /**the derivative of a polynomial*/
    public BigPolynomial derivative() {
	BigPolynomial P=new BigPolynomial();
	P.D=D-1;
	for(int i=1;i<=D;++i) {
	    P.z[i-1]=BigComplex.times(z[i],new BigComplex(new Complex(i,0)));
	}
	return(P);
    }


    /**In this routine we encode a finite sequence as
       the coefficients of a polynomial.  Then we take the
       difference sequence.*/

    public BigPolynomial difference() {
	BigPolynomial P=new BigPolynomial();
	P.D=D-1;
	for(int i=0;i<D;++i) {
	    P.z[i]=BigComplex.minus(z[i+1],z[i]);
	}
	return(P);
    }

    /**this routine recognizes when some of the coefficients of a
       polynomial are nearly integers*/

    public BigPolynomial recognizeInteger(int tolerance) {
	BigPolynomial P=new BigPolynomial();
	P.D=D;
	for(int i=0;i<=D;++i) {
	    P.z[i]=BigComplex.recognizeInteger(z[i],tolerance);
	}
	return(P);
    }




    /**recognizes the zero polynomial.  0 means yes*/

    public int recognizeZero() {
	for(int i=0;i<=D;++i) {
	    Complex w=z[i].toComplex();
	    if(w.norm()>.0001) return(1);
	}
	return(0);
    }





    /**This routine is applied to a sequence (encoded as a
       polynomial) f(0),f(1),f(2),f(3),...  Assuming that these
       numbers are the output of a polynomial f, this routine
       takes successive differences and tried to find the
       degree.   If the degree is higher than the number of
       terms, meaning that taking successive differences does
       not reveal a pattern, then -1 is returned*/

    public int effectiveDegree() {
	int test=0;
	BigPolynomial P=new BigPolynomial(this.z,this.D);
	for(int i=0;i<D;++i) {
	    P=P.difference();
	    test=P.recognizeZero();
	    if(test==0) return(i);
	}
	return(-1);
    }



    /**This routine assumes that the effective degree of a
       sequence f(0),f(1),...,f(d) is d.  Then it computes
       the highest term (coeff of x^d) of the degree d
       polynomial which generates the sequence.  We only use
       the routine after computing the effective degree of
       the sequence*/

    public BigPolynomial termFromGrowth(int d) {
	int test=0;
	BigPolynomial P=new BigPolynomial(this.z,this.D);
	for(int i=0;i<d;++i) {
	    P=P.difference();
	}
	BigComplex Z=P.z[0];
	for(int i=1;i<=d;++i) {
	    BigDecimal I=new BigDecimal(i);
	    Z.x=Z.x.divide(I,100,BigDecimal.ROUND_FLOOR);
	    Z.y=Z.y.divide(I,100,BigDecimal.ROUND_FLOOR);
	}
	BigPolynomial Q=new BigPolynomial();
	for(int i=0;i<=d;++i) {
	    Q.z[i]=new BigComplex();
	}
	Q.z[d]=Z;
	Q.D=d;

	return(Q);
    }



    /*Given a mononial of the form f(x)=Cx^D, this
      routine computes f(0),...,f(d), and returns these
      values encoded as a polynomial.*/

    public BigPolynomial createValues(int d) {
	BigPolynomial P=new BigPolynomial();
	if(d==0) {
	    P.D=0;
	    return(P);
	}
	P.D=d;
	BigComplex Z=z[D];
	for(int i=0;i<=d;++i) {
	    BigComplex X=new BigComplex();
	    X.x=PrecisionFunction.power(new BigDecimal(i),D);
	    X.y=new BigDecimal(0);
	    P.z[i]=BigComplex.times(Z,X);
	}
	return(P);
    }

    /*Here is the main routine.  In this routine we have a
      sequence f(0),f(1),f(2),... and we compute the 
      polynomial which generates the sequence.  If the
      effective degree computation gives a -1 we return
      the 0 polynomial (with degree -1) to indicate that
      there are not enough numbers in the sequence to
      determine the polynomial*/


    public BigPolynomial fitPolynomial() {
	BigPolynomial A1=new BigPolynomial(this.z,this.D);
	BigPolynomial A2=new BigPolynomial();
	BigPolynomial B1=new BigPolynomial();
	BigPolynomial B2=new BigPolynomial();
	int d=this.effectiveDegree();
	if(d==-1) {A2.D=-1;return(A2);}
	A2.z[0]=new BigComplex(A1.z[0].x,A1.z[0].y);
	for(int i=d;i>0;--i) {
	    B1=A1.termFromGrowth(i);
	    B2=B1.createValues(this.D);
	    A1=A1.minus(B2);
	    A2=A2.plus(B1);
	}
	A2.D=d;	
	return(A2);
    }

    public void print() {
	System.out.println("BigPolynomial");
	for(int i=0;i<=D;++i) z[i].print();
    }

}