// LegendreFit.java
//
// approximate f(x) ~ a0*g0 + a1*g1*P1(x) + a2*gn*P2(x) + ...
// ai = int -1 to 1 f(x)*Pi(x) dx
// gi = (2i+1)/2

package myjava;

import java.awt.*;
import java.awt.event.*;
import java.text.*;

class LegendreFit extends Frame
{
  LegendreFit()
  {
    setTitle("LegendreFit(x) -1 to 1 of e^x");
    setSize(450,500);
    setBackground(Color.white);
    setForeground(Color.black);
    addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
        System.exit(0);
      }
    });
    setVisible(true);
  }

  double f(double x) // "exact" function e^x 
  {
    return Math.exp(x);
  }

  double P(int i, double x) // Legendre polynomial evaluation
  {
    if(i<=0) return 1.0;
    else if(i==1) return x;
    else return x*((double)(2*i-1)/i)*P(i-1,x)-((double)(i-1)/i)*P(i-2,x);
  }

  double Pchk(int i, double x) // check recursive definition
  {
    switch(i)
    {
      case 0: return 1.0;
      case 1: return x;
      case 2: return -0.5+1.5*x*x;
      case 3: return -1.5*x+2.5*x*x*x;
      case 4: return 0.375-3.75*x*x+4.375*x*x*x*x;
      case 5: return 1.875*x-8.75*x*x*x+7.875*x*x*x*x*x;
      case 6: return -0.3125+6.5625*x*x-19.6875*x*x*x*x+14.4375*x*x*x*x*x*x;
      default : return 0.0;
    }
  }
  
  public void paint(Graphics g)
  {
    // set up function to be approximated
    final int n=100;            // number of samples for plotting
    final double nf=(double)n;
    double fx[] = new double[n]; // f(x)
    double ax[] = new double[n]; // approximation(x)
    final double xmin=-1.0;
    final double xmax=1.0;
    double ymin=0.0;            // for automatic scaling some day
    double ymax=3.0;
    double dx;                  // x step increment
    double xstart;              // initial value
    double x;                   // stepped value xmin to xmax
    
    if(n%2==0) // even, center samples, not end points or center
    {
      dx=(xmax-xmin)/nf;
      xstart=xmin+dx/2.0;
    } 
    else // odd, end points are samples, center point in center
    {
      dx=(xmax-xmin)/(double)(n-1);
      xstart=xmin;
    }
    // do NOT use x=x+dx, very inaccurate!
    for(int i=0; i<n; i++) fx[i]=f(xstart+(double)i*dx); // get "exact" function
    ymin=fx[0];
    ymax=fx[0];
    for(int i=0; i<n; i++)
    {
      ymin=Math.min(ymin,fx[i]);
      ymax=Math.max(ymax,fx[i]);
    }
    // may fudge ymin and ymax for extra room for approximation
    ymin=0.0;
    ymax=3.0;
 
    // set up plot area
    final int hw=400;   // graph area height and width
    final double xsca=hw/(xmax-xmin);  // x data scale -1 to 1
    final double ysca=hw/(ymax-ymin);  // y data scale 0 to 3
    final int f1xOff=25;  // offsets
    final int f1yOff=70;
    final int f1xC=f1xOff+hw/2; // centers
    final int f1yC=f1yOff+hw/2;
    
    g.drawRect(f1xOff, f1yOff, hw, hw);
    g.drawLine(f1xOff, f1yOff+hw/3, f1xOff+hw, f1yOff+hw/3);
    g.drawLine(f1xOff, f1yOff+2*hw/3, f1xOff+hw, f1yOff+2*hw/3);
    g.drawLine(f1xC,   f1yOff, f1xC, f1yOff+hw);
    g.drawString("3",  f1xOff-14,   f1yOff+4);
    g.drawString("e",  f1xOff-14,   f1yOff+400-362+4);
    g.drawString("2",  f1xOff-14,   f1yOff+hw/3+4);
    g.drawString("1",  f1xOff-14,   f1yOff+2*hw/3+4);
    g.drawString("1/e", f1xOff-24,  f1yOff+400-49+4);
    g.drawString("0",  f1xOff-14,   f1yOff+hw+4);
    g.drawString("-1", f1xOff-4,    f1yOff+hw+15);
    g.drawString("0",  f1xC-4,      f1yOff+hw+15);
    g.drawString("1",  f1xOff+hw-4, f1yOff+hw+15);
    g.drawString("y",  f1xOff,      f1yOff-12);
    g.drawString("x",  f1xOff+hw+6, f1yOff+hw+4);

    // plot function
    double x1new, y1new;
    double x1old=xstart;
    double y1old=fx[0];
    g.setColor(Color.black);
    for(int i=1; i<n; i++) // n-1 lines
    {
      x1new=xstart+(double)i*dx;
      y1new=fx[i];
      g.drawLine((int)(f1xC+x1old*xsca), (int)(f1yOff+hw-y1old*ysca),
                 (int)(f1xC+x1new*xsca), (int)(f1yOff+hw-y1new*ysca));
      x1old=x1new;
      y1old=y1new;
    }
    
    // compute approximation
    final int nt=6;
    final int ns=1024; // need bigger or better integration for higher powers
    final double hs=(xmax-xmin)/ns;
    double a[] = new double[nt]; // coefficients
    
    // compute Legendre coefficients a's 
    System.out.println("Legendre coefficients for exp(x)");
    for(int i=0; i<nt; i++)
    {
      // simple trapezoidal integration
      a[i]=0.5*(f(xmin)*P(i,xmin)+f(xmax)*P(i,xmax));
      for(int j=1; j<ns; j++) // ns segments
      {
        x=xmin+j*hs;
        a[i]=a[i]+f(x)*P(i,x);
      }
      a[i]=(xmax-xmin)*a[i]/ns; // scale numerical integration
      System.out.println("a["+i+"]="+a[i]);
    }
 
    Color col[]={Color.yellow, Color.green, Color.red, Color.blue};
    int t=0;                     // power actually used
    double avgerr, maxerr, rmserr, err, y=0.0;
    DecimalFormat f1 = new DecimalFormat("0.000E00");
 
    for(int k=0; k<4; k++)
    {
      // generate the t_th approximation
      t=k+3;
      avgerr=0.0;
      maxerr=0.0;
      rmserr=0.0;
      for(int i=0; i<n; i++) // n samples to plot
      {
        x1new=xstart+(double)i*dx;
        y1new=0.0;
        for(int j=0; j<t; j++)y1new=y1new+((double)(2*j+1)/2)*a[j]*P(j,x1new);
        ax[i]=y1new;
        err=Math.abs(fx[i]-ax[i]);
        avgerr=avgerr+err;
        maxerr=Math.max(maxerr, err);
        rmserr=rmserr+err*err;
        
      }
      avgerr=avgerr/nf;
      rmserr=Math.sqrt(rmserr/nf);
      System.out.println("for "+(t-1)+" power: avgerr="+avgerr);
      System.out.println("            maxerr="+maxerr);
      System.out.println("            rmserr="+rmserr);

      // plot approximation
      g.setColor(col[k]);
      x1old=xstart;
      y1old=ax[0];
      for(int i=1; i<n; i++) // n-1 lines
      {
        x1new=xstart+(double)i*dx;
        y1new=ax[i];
        g.drawLine((int)(f1xC+x1old*xsca), (int)(f1yOff+hw-y1old*ysca),
                   (int)(f1xC+x1new*xsca), (int)(f1yOff+hw-y1new*ysca));
        x1old=x1new;
        y1old=y1new;
      }
      g.drawString((t-1)+" power,  avg error ="+f1.format(avgerr), f1xC+20, f1yOff+hw-10-15*k); 
    }
    g.setColor(Color.black);
    g.drawString(n+" samples", f1xOff+20, f1yOff+hw-20);
    g.setColor(Color.red);
    Font cur18 = new Font("courier", Font.BOLD, 18); 
    g.setFont(cur18);
    g.drawString("LegendreFit(x) -1 to 1 of e^x", 10, 50);
  }
  
  public static void main(String args[])
  {
    System.out.println("LegendreFit.java running");
    new LegendreFit();
  }
}