// test_Big_nuderiv.java  check using (double) and Big cx 

import java.math.BigDecimal;
import java.io.*;

public class test_Big_nuderiv
{
  public test_Big_nuderiv()
  {
    int n;
    double err1 = 0.0;
    double err2 = 0.0;
    double err3 = 0.0;
    double err4 = 0.0;
    BigDecimal Berr1 = new BigDecimal(0.0);
    BigDecimal Berr2 = new BigDecimal(0.0);
    BigDecimal Berr3 = new BigDecimal(0.0);
    BigDecimal Berr4 = new BigDecimal(0.0);
    double now, start;

    System.out.println("test_Big_nuderiv.java on high order");
    now = System.currentTimeMillis()/1000.0;
    start = now;
    n = 10;
    while(n <= 30)
    {
      System.out.println("initializing big derivative, n="+n);
      double xg[] = new double[n];
      double cx[] = new double[n];
      double cxx[] = new double[n];
      double cxxx[] = new double[n];
      double cxxxx[] = new double[n];
      BigDecimal Bcx[] = new BigDecimal[n];
      BigDecimal Bcxx[] = new BigDecimal[n];
      BigDecimal Bcxxx[] = new BigDecimal[n];
      BigDecimal Bcxxxx[] = new BigDecimal[n];
      double der1 = 0.0;
      double der2 = 0.0;
      double der3 = 0.0;
      double der4 = 0.0;
      BigDecimal Bder1 = new BigDecimal(0.0);
      BigDecimal Bder2 = new BigDecimal(0.0);
      BigDecimal Bder3 = new BigDecimal(0.0);
      BigDecimal Bder4 = new BigDecimal(0.0);

      err1 = 0.0;
      err2 = 0.0;
      err3 = 0.0;
      err4 = 0.0;
      Berr1 = new BigDecimal(0.0);
      Berr2 = new BigDecimal(0.0);
      Berr3 = new BigDecimal(0.0);
      Berr4 = new BigDecimal(0.0);
      for(int i=0; i<n; i++)
      {
        for(int k=0; k<n; k++)
        {
	  xg[k] = (double)k; // should be exact
        }
        new Big_nuderiv(1, n, i, xg, cx);
        new Big_nuderiv(2, n, i, xg, cxx);
        new Big_nuderiv(3, n, i, xg, cxxx);
        new Big_nuderiv(4, n, i, xg, cxxxx);
        new Big_nuderiv(1, n, i, xg, Bcx);
        new Big_nuderiv(2, n, i, xg, Bcxx);
        new Big_nuderiv(3, n, i, xg, Bcxxx);
        new Big_nuderiv(4, n, i, xg, Bcxxxx);
        der1 = 0.0;
        der2 = 0.0;
        der3 = 0.0;
        der4 = 0.0;
        Bder1 = new BigDecimal(0.0);
        Bder2 = new BigDecimal(0.0);
        Bder3 = new BigDecimal(0.0);
        Bder4 = new BigDecimal(0.0);
        for(int k=0; k<n; k++)
        {
	  der1 = der1 + cx[k]*F(xg[k]);
	  der2 = der2 + cxx[k]*F(xg[k]);
	  der3 = der3 + cxxx[k]*F(xg[k]);
	  der4 = der4 + cxxxx[k]*F(xg[k]);
	  Bder1 = Bder1.add(Bcx[k].multiply(BF(xg[k])));
	  Bder2 = Bder2.add(Bcxx[k].multiply(BF(xg[k])));
	  Bder3 = Bder3.add(Bcxxx[k].multiply(BF(xg[k])));
	  Bder4 = Bder4.add(Bcxxxx[k].multiply(BF(xg[k])));
        }
        err1 = Math.max(err1,Math.abs(der1-Fx(xg[i])));
        err2 = Math.max(err2,Math.abs(der2-Fxx(xg[i])));
        err3 = Math.max(err3,Math.abs(der3-Fxxx(xg[i])));
        err4 = Math.max(err4,Math.abs(der4-Fxxxx(xg[i])));
        Berr1 = Berr1.max((Bder1.subtract(BFx(xg[i]))).abs());
        Berr2 = Berr2.max((Bder2.subtract(BFxx(xg[i]))).abs());
        Berr3 = Berr3.max((Bder3.subtract(BFxxx(xg[i]))).abs());
        Berr4 = Berr4.max((Bder4.subtract(BFxxxx(xg[i]))).abs());
      }
      System.out.println("der1="+der1+", max error="+err1);
      System.out.println("der2="+der2+", max error="+err2);
      System.out.println("der3="+der3+", max error="+err3);
      System.out.println("der4="+der4+", max error="+err4);
      System.out.println("max Berror1="+Berr1.toString());
      System.out.println("max Berror2="+Berr2.toString());
      System.out.println("max Berror3="+Berr3.toString());
      System.out.println("max Berror4="+Berr4.toString());
      System.out.println(" ");

      n += 5;
    }
    now = System.currentTimeMillis()/1000.0;
    System.out.println("finished test_nuderiv.java "+(now-start)+" seconds");
  } // end test_Big_nuderiv

  double F(double x)
  {
    return 1.0*x*x*x*x*x + 2.0*x*x*x*x + 3.0*x*x*x + 4.0*x*x + 5.0*x +6.0;
  }

  double Fx(double x)
  {
    return 5.0*x*x*x*x + 8.0*x*x*x + 9.0*x*x + 8.0*x + 5.0;
  }

  double Fxx(double x)
  {
    return 20.0*x*x*x + 24.0*x*x + 18.0*x + 8.0;
  }

  double Fxxx(double x)
  {
    return 60.0*x*x + 48.0*x + 18.0;
  }

  double Fxxxx(double x)
  {
    return 120.0*x + 48.0;
  }

  BigDecimal BF(double x)
  {
    BigDecimal Bx = new BigDecimal(x);
    BigDecimal n1 = new BigDecimal(1.0);
    BigDecimal n2 = new BigDecimal(2.0);
    BigDecimal n3 = new BigDecimal(3.0);
    BigDecimal n4 = new BigDecimal(4.0);
    BigDecimal n5 = new BigDecimal(5.0);
    BigDecimal n6 = new BigDecimal(6.0);
    // 1.0*x*x*x*x*x + 2.0*x*x*x*x + 3.0*x*x*x + 4.0*x*x + 5.0*x +6.0
    return
     (n1.multiply(Bx).multiply(Bx).multiply(Bx).multiply(Bx).multiply(Bx)).add
     (n2.multiply(Bx).multiply(Bx).multiply(Bx).multiply(Bx)).add
     (n3.multiply(Bx).multiply(Bx).multiply(Bx)).add
     (n4.multiply(Bx).multiply(Bx)).add
     (n5.multiply(Bx)).add
     (n6);
  }

  BigDecimal BFx(double x)
  {
    BigDecimal Bx = new BigDecimal(x);
    BigDecimal n5 = new BigDecimal(5.0);
    BigDecimal n8 = new BigDecimal(8.0);
    BigDecimal n9 = new BigDecimal(9.0);
    // 5.0*x*x*x*x + 8.0*x*x*x + 9.0*x*x + 8.0*x + 5.0
    return (n5.multiply(Bx).multiply(Bx).multiply(Bx).multiply(Bx)).add
	   (n8.multiply(Bx).multiply(Bx).multiply(Bx)).add
	   (n9.multiply(Bx).multiply(Bx)).add
	   (n8.multiply(Bx)).add
           (n5);
  }

  BigDecimal BFxx(double x)
  {
    BigDecimal Bx = new BigDecimal(x);
    BigDecimal n20 = new BigDecimal(20.0);
    BigDecimal n24 = new BigDecimal(24.0);
    BigDecimal n18 = new BigDecimal(18.0);
    BigDecimal n8  = new BigDecimal( 8.0);
    // 20.0*x*x*x + 24.0*x*x + 18.0*x + 8.0;
    return (n20.multiply(Bx).multiply(Bx).multiply(Bx)).add
	   (n24.multiply(Bx).multiply(Bx)).add
	   (n18.multiply(Bx)).add
           (n8);
  }

  BigDecimal BFxxx(double x)
  {
    BigDecimal Bx = new BigDecimal(x);
    BigDecimal n60 = new BigDecimal(60.0);
    BigDecimal n48 = new BigDecimal(48.0);
    BigDecimal n18 = new BigDecimal(18.0);
    // 60.0*x*x + 48.0*x + 18.0
    return (n60.multiply(Bx).multiply(Bx)).add
	   (n48.multiply(Bx)).add
           (n18);
  }

  BigDecimal BFxxxx(double x)
  {
    BigDecimal Bx = new BigDecimal(x);
    BigDecimal n120 = new BigDecimal(120.0);
    BigDecimal n48  = new BigDecimal(48.0);
    // 120.0*x + 48.0;
    return (n120.multiply(Bx)).add
           (n48);
  }

  public static void main (String[] args)
  {
    new test_Big_nuderiv();
  } // end main of test_Big_nuderiv.java
} // end class test_Big_nuderiv