// test_nuderiv4d.java   test  nuderiv4d  with 28 points 
//                    order 1  minimum points 5       
//                    order 2  minimum points 15       
//                    order 3  minimum points 35      
//                    order 4  minimum points 70            
//                    going beyond minimum points does not help much 
//                    actually, current limit of nuderiv4d
class test_nuderiv4d
{
  final int n = 70; // need "g" for more points, generated by gen_data4
  double x[] = new double[n];
  double y[] = new double[n]; 
  double z[] = new double[n];
  double t[] = new double[n]; 

  test_nuderiv4d()
  {
    int debug = 0;
    int order = 4;
    double U[] = new double[n];
    double est, actual, dx, dy, dz, dt;
    double cx[] = new double[n];
    double cy[] = new double[n];
    double cz[] = new double[n];
    double ct[] = new double[n];

    double cxx[] = new double[n];
    double cxy[] = new double[n];
    double cxz[] = new double[n];
    double cxt[] = new double[n];
    double cyy[] = new double[n];
    double cyz[] = new double[n];
    double cyt[] = new double[n];
    double czz[] = new double[n];
    double czt[] = new double[n];
    double ctt[] = new double[n];

    double cxxx[] = new double[n];
    double cxxy[] = new double[n];
    double cxxz[] = new double[n];
    double cxxt[] = new double[n];
    double cxyy[] = new double[n];
    double cxyz[] = new double[n];
    double cxyt[] = new double[n];
    double cxzz[] = new double[n];
    double cxzt[] = new double[n];
    double cxtt[] = new double[n];
    double cyyy[] = new double[n];
    double cyyz[] = new double[n];
    double cyyt[] = new double[n];
    double cyzz[] = new double[n];
    double cyzt[] = new double[n];
    double cytt[] = new double[n];
    double czzz[] = new double[n];
    double czzt[] = new double[n];
    double cztt[] = new double[n];
    double cttt[] = new double[n];

    double cxxxx[] = new double[n];
    double cxxxy[] = new double[n];
    double cxxxz[] = new double[n];
    double cxxxt[] = new double[n];
    double cxxyy[] = new double[n];
    double cxxyz[] = new double[n];
    double cxxyt[] = new double[n];
    double cxxzz[] = new double[n];
    double cxxzt[] = new double[n];
    double cxxtt[] = new double[n];
    double cxyyy[] = new double[n];
    double cxyyz[] = new double[n];
    double cxyyt[] = new double[n];
    double cxyzz[] = new double[n];
    double cxyzt[] = new double[n];
    double cxytt[] = new double[n];
    double cxzzz[] = new double[n];
    double cxzzt[] = new double[n];
    double cxztt[] = new double[n];
    double cxttt[] = new double[n];
    double cyyyy[] = new double[n];
    double cyyyz[] = new double[n];
    double cyyyt[] = new double[n];
    double cyyzz[] = new double[n];
    double cyyzt[] = new double[n];
    double cyytt[] = new double[n];
    double cyzzz[] = new double[n];
    double cyzzt[] = new double[n];
    double cyztt[] = new double[n];
    double cyttt[] = new double[n];
    double czzzz[] = new double[n];
    double czzzt[] = new double[n];
    double czztt[] = new double[n];
    double czttt[] = new double[n];
    double ctttt[] = new double[n];
    double error, maxerror;

    nuderiv4d N = new nuderiv4d(1);

    System.out.println("test_nuderiv4d.java running");
    gen_data4(1);

    for(int i=0; i<n; i++)
    {
      U[i] =  f(x[i],y[i],z[i],t[i]);
      dx   = fx(x[i],y[i],z[i],t[i]);
      dy   = fy(x[i],y[i],z[i],t[i]);
      dz   = fx(x[i],y[i],z[i],t[i]);
      dt   = fy(x[i],y[i],z[i],t[i]);
      System.out.println("point "+i+"  x="+x[i]+", y="+y[i]+", z="+z[i]);
      System.out.println("             t="+t[i]+", U="+U[i]+", dx="+dx);
      System.out.println("             dy="+dy+", dz="+dz+", dt="+dt);
    } 

    maxerror = 0.0;
    for(int point=0; point<n; point++) // Ux 
    {
      N.nu4dx(order, n, point, x, y, z, t, cx);
      est = 0.0;
      for(int i=0; i<n; i++) est += cx[i]*U[i];
      actual = fx(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cx "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Ux 

    for(int point=0; point<n; point++) // Uy 
    {
      N.nu4dy(order, n, point, x, y, z, t, cy);
      est = 0.0;
      for(int i=0; i<n; i++) est += cy[i]*U[i];
      actual = fy(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cy "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uy 

    for(int point=0; point<n; point++) // Uz 
    {
      N.nu4dz(order, n, point, x, y, z, t, cz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cz[i]*U[i];
      actual = fz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uz

    for(int point=0; point<n; point++) // Ut 
    {
      N.nu4dt(order, n, point, x, y, z, t, ct);
      est = 0.0;
      for(int i=0; i<n; i++) est += ct[i]*U[i];
      actual = ft(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("ct "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Ut 

    for(int point=0; point<n; point++) // Uxx 
    {
      N.nu4dxx(order, n, point, x, y, z, t, cxx);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxx[i]*U[i];
      actual = fxx(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxx "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxx 

    for(int point=0; point<n; point++) // Uxy 
    {
      N.nu4dxy(order, n, point, x, y, z, t, cxy);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxy[i]*U[i];
      actual = fxy(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxy "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxy 

    for(int point=0; point<n; point++) // Uxz 
    {
      N.nu4dxz(order, n, point, x, y, z, t, cxz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxz[i]*U[i];
      actual = fxz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxz

    for(int point=0; point<n; point++) // Uxt 
    {
      N.nu4dxt(order, n, point, x, y, z, t, cxt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxt[i]*U[i];
      actual = fxt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxt

    for(int point=0; point<n; point++) // Uyy 
    {
      N.nu4dyy(order, n, point, x, y, z, t, cyy);
      est = 0.0;
        for(int i=0; i<n; i++) est += cyy[i]*U[i];
        actual = fyy(x[point],y[point],z[point],t[point]);
        error = actual-est;
        maxerror = Math.max(maxerror,Math.abs(error));
        System.out.println("cyy "+point+", est="+est+", actual="+actual+
                           ", error="+ error);
      } // end Uyy 

    for(int point=0; point<n; point++) // Uyz 
    {
      N.nu4dyz(order, n, point, x, y, z, t, cyz);
      est = 0.0;
        for(int i=0; i<n; i++) est += cyz[i]*U[i];
        actual = fyz(x[point],y[point],z[point],t[point]);
        error = actual-est;
        maxerror = Math.max(maxerror,Math.abs(error));
        System.out.println("cyz "+point+", est="+est+", actual="+actual+
                           ", error="+ error);
      } // end Uyz

    for(int point=0; point<n; point++) // Uyt 
    {
      N.nu4dyt(order, n, point, x, y, z, t, cyt);
      est = 0.0;
        for(int i=0; i<n; i++) est += cyt[i]*U[i];
        actual = fyt(x[point],y[point],z[point],t[point]);
        error = actual-est;
        maxerror = Math.max(maxerror,Math.abs(error));
        System.out.println("cyt "+point+", est="+est+", actual="+actual+
                           ", error="+ error);
      } // end Uyt

    for(int point=0; point<n; point++) // Uzz 
    {
      N.nu4dzz(order, n, point, x, y, z, t, czz);
      est = 0.0;
        for(int i=0; i<n; i++) est += czz[i]*U[i];
        actual = fzz(x[point],y[point],z[point],t[point]);
        error = actual-est;
        maxerror = Math.max(maxerror,Math.abs(error));
        System.out.println("czz "+point+", est="+est+", actual="+actual+
                           ", error="+ error);
      } // end Uzz

    for(int point=0; point<n; point++) // Uzt 
    {
      N.nu4dzt(order, n, point, x, y, z, t, czt);
      est = 0.0;
        for(int i=0; i<n; i++) est += czt[i]*U[i];
        actual = fzt(x[point],y[point],z[point],t[point]);
        error = actual-est;
        maxerror = Math.max(maxerror,Math.abs(error));
        System.out.println("czt "+point+", est="+est+", actual="+actual+
                           ", error="+ error);
      } // end Uzt

    for(int point=0; point<n; point++) // Utt 
    {
      N.nu4dtt(order, n, point, x, y, z, t, ctt);
      est = 0.0;
        for(int i=0; i<n; i++) est += ctt[i]*U[i];
        actual = ftt(x[point],y[point],z[point],t[point]);
        error = actual-est;
        maxerror = Math.max(maxerror,Math.abs(error));
        System.out.println("ctt "+point+", est="+est+", actual="+actual+
                           ", error="+ error);
      } // end Utt

    for(int point=0; point<n; point++) // Uxxx 
    {
      N.nu4dxxx(order, n, point, x, y, z, t, cxxx);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxxx[i]*U[i];
      actual = fxxx(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxxx "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxxx 

    for(int point=0; point<n; point++) // Uxxy 
    {
      N.nu4dxxy(order, n, point, x, y, z, t, cxxy);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxxy[i]*U[i];
      actual = fxxy(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxxy "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxxy 

    for(int point=0; point<n; point++) // Uxxz 
    {
      N.nu4dxxz(order, n, point, x, y, z, t, cxxz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxxz[i]*U[i];
      actual = fxxz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxxz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxxz

    for(int point=0; point<n; point++) // Uxxt 
    {
      N.nu4dxxt(order, n, point, x, y, z, t, cxxt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxxt[i]*U[i];
      actual = fxxt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxxt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxxt

    for(int point=0; point<n; point++) // Uxyy 
    {
      N.nu4dxyy(order, n, point, x, y, z, t, cxyy);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxyy[i]*U[i];
      actual = fxyy(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxyy "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxyy 

    for(int point=0; point<n; point++) // Uxyz 
    {
      N.nu4dxyz(order, n, point, x, y, z, t, cxyz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxyz[i]*U[i];
      actual = fxyz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxyz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxyz

    for(int point=0; point<n; point++) // Uxyt 
    {
      N.nu4dxyt(order, n, point, x, y, z, t, cxyt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxyt[i]*U[i];
      actual = fxyt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxyt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxyt

    for(int point=0; point<n; point++) // Uxzz 
    {
      N.nu4dxzz(order, n, point, x, y, z, t, cxzz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxzz[i]*U[i];
      actual = fxzz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxzz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxzz

    for(int point=0; point<n; point++) // Uxzt 
    {
      N.nu4dxzt(order, n, point, x, y, z, t, cxzt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxzt[i]*U[i];
      actual = fxzt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxzt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxzt

    for(int point=0; point<n; point++) // Uxtt 
    {
      N.nu4dxtt(order, n, point, x, y, z, t, cxtt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxtt[i]*U[i];
      actual = fxtt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxtt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxtt

    for(int point=0; point<n; point++) // Uyyy 
    {
      N.nu4dyyy(order, n, point, x, y, z, t, cyyy);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyyy[i]*U[i];
      actual = fyyy(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyyy "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyyy 

    for(int point=0; point<n; point++) // Uyyz 
    {
      N.nu4dyyz(order, n, point, x, y, z, t, cyyz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyyz[i]*U[i];
      actual = fyyz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyyz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyyz

    for(int point=0; point<n; point++) // Uyyt 
    {
      N.nu4dyyt(order, n, point, x, y, z, t, cyyt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyyt[i]*U[i];
      actual = fyyt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyyt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyyt

    for(int point=0; point<n; point++) // Uyzz 
    {
      N.nu4dyzz(order, n, point, x, y, z, t, cyzz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyzz[i]*U[i];
      actual = fyzz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyzz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyzz

    for(int point=0; point<n; point++) // Uyzt 
    {
      N.nu4dyzt(order, n, point, x, y, z, t, cyzt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyzt[i]*U[i];
      actual = fyzt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyzt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyzt

    for(int point=0; point<n; point++) // Uytt 
    {
      N.nu4dytt(order, n, point, x, y, z, t, cytt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cytt[i]*U[i];
      actual = fytt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cytt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uytt

    for(int point=0; point<n; point++) // Uzzz 
    {
      N.nu4dzzz(order, n, point, x, y, z, t, czzz);
      est = 0.0;
      for(int i=0; i<n; i++) est += czzz[i]*U[i];
      actual = fzzz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("czzz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uzzz

    for(int point=0; point<n; point++) // Uzzt 
    {
      N.nu4dzzt(order, n, point, x, y, z, t, czzt);
      est = 0.0;
      for(int i=0; i<n; i++) est += czzt[i]*U[i];
      actual = fzzt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("czzt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uzzt

    for(int point=0; point<n; point++) // Uztt 
    {
      N.nu4dztt(order, n, point, x, y, z, t, cztt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cztt[i]*U[i];
      actual = fztt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cztt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uztt

    for(int point=0; point<n; point++) // Uttt 
    {
      N.nu4dttt(order, n, point, x, y, z, t, cttt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cttt[i]*U[i];
      actual = fttt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cttt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uttt

    for(int point=0; point<n; point++) // Uxxxx 
    {
      N.nu4dxxxx(order, n, point, x, y, z, t, cxxxx);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxxxx[i]*U[i];
      actual = fxxxx(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxxxx "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxxxx 

    for(int point=0; point<n; point++) // Uxxxy 
    {
      N.nu4dxxxy(order, n, point, x, y, z, t, cxxxy);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxxxy[i]*U[i];
      actual = fxxxy(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxxxy %4d, "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxxxy 

    for(int point=0; point<n; point++) // Uxxxz 
    {
      N.nu4dxxxz(order, n, point, x, y, z, t, cxxxz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxxxz[i]*U[i];
      actual = fxxxz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxxxz %4d, "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxxxz

    for(int point=0; point<n; point++) // Uxxxt 
    {
      N.nu4dxxxt(order, n, point, x, y, z, t, cxxxt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxxxt[i]*U[i];
      actual = fxxxt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxxxt %4d, "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxxxt

    for(int point=0; point<n; point++) // Uxxyy 
    {
      N.nu4dxxyy(order, n, point, x, y, z, t, cxxyy);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxxyy[i]*U[i];
      actual = fxxyy(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxxyy "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxxyy 

    for(int point=0; point<n; point++) // Uxxyz 
    {
      N.nu4dxxyz(order, n, point, x, y, z, t, cxxyz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxxyz[i]*U[i];
      actual = fxxyz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxxyz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxxyz

    for(int point=0; point<n; point++) // Uxxyt 
    {
      N.nu4dxxyt(order, n, point, x, y, z, t, cxxyt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxxyt[i]*U[i];
      actual = fxxyt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxxyt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxxyt

    for(int point=0; point<n; point++) // Uxyyy 
    {
      N.nu4dxyyy(order, n, point, x, y, z, t, cxyyy);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxyyy[i]*U[i];
      actual = fxyyy(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxyyy "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxyyy 

    for(int point=0; point<n; point++) // Uxyyz 
    {
      N.nu4dxyyz(order, n, point, x, y, z, t, cxyyz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxyyz[i]*U[i];
      actual = fxyyz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxyyz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxyyz

    for(int point=0; point<n; point++) // Uxyyt 
    {
      N.nu4dxyyt(order, n, point, x, y, z, t, cxyyt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxyyt[i]*U[i];
      actual = fxyyt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxyyt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxyyt

    for(int point=0; point<n; point++) // Uxyzz 
    {
      N.nu4dxyzz(order, n, point, x, y, z, t, cxyzz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxyzz[i]*U[i];
      actual = fxyzz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxyzz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxyzz

    for(int point=0; point<n; point++) // Uxyzt 
    {
      N.nu4dxyzt(order, n, point, x, y, z, t, cxyzt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxyzt[i]*U[i];
      actual = fxyzt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxyzt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxyzt

    for(int point=0; point<n; point++) // Uxytt 
    {
      N.nu4dxytt(order, n, point, x, y, z, t, cxytt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxytt[i]*U[i];
      actual = fxytt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxytt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxytt

    for(int point=0; point<n; point++) // Uxzzz 
    {
      N.nu4dxzzz(order, n, point, x, y, z, t, cxzzz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxzzz[i]*U[i];
      actual = fxzzz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxzzz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxzzz

    for(int point=0; point<n; point++) // Uxzzt 
    {
      N.nu4dxzzt(order, n, point, x, y, z, t, cxzzt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxzzt[i]*U[i];
      actual = fxzzt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxzzt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxzzt

    for(int point=0; point<n; point++) // Uxttt 
    {
      N.nu4dxttt(order, n, point, x, y, z, t, cxttt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cxttt[i]*U[i];
      actual = fxttt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cxttt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uxttt

    for(int point=0; point<n; point++) // Uyyyy 
    {
      N.nu4dyyyy(order, n, point, x, y, z, t, cyyyy);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyyyy[i]*U[i];
      actual = fyyyy(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyyyy "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyyyy 

    for(int point=0; point<n; point++) // Uyyyz 
    {
      N.nu4dyyyz(order, n, point, x, y, z, t, cyyyz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyyyz[i]*U[i];
      actual = fyyyz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyyyz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyyyz

    for(int point=0; point<n; point++) // Uyyyt 
    {
      N.nu4dyyyt(order, n, point, x, y, z, t, cyyyt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyyyt[i]*U[i];
      actual = fyyyt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyyyt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyyyt

    for(int point=0; point<n; point++) // Uyyzz 
    {
      N.nu4dyyzz(order, n, point, x, y, z, t, cyyzz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyyzz[i]*U[i];
      actual = fyyzz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyyzz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyyzz

    for(int point=0; point<n; point++) // Uyyzt
    {
      N.nu4dyyzt(order, n, point, x, y, z, t, cyyzt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyyzt[i]*U[i];
      actual = fyyzt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyyzt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyyzt

    for(int point=0; point<n; point++) // Uyytt
    {
      N.nu4dyytt(order, n, point, x, y, z, t, cyytt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyytt[i]*U[i];
      actual = fyytt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyytt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyytt

    for(int point=0; point<n; point++) // Uyzzz 
    {
      N.nu4dyzzz(order, n, point, x, y, z, t, cyzzz);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyzzz[i]*U[i];
      actual = fyzzz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyzzz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyzzz

    for(int point=0; point<n; point++) // Uyzzt 
    {
      N.nu4dyzzt(order, n, point, x, y, z, t, cyzzt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyzzt[i]*U[i];
      actual = fyzzt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyzzt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyzzt

    for(int point=0; point<n; point++) // Uyztt 
    {
      N.nu4dyztt(order, n, point, x, y, z, t, cyztt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyztt[i]*U[i];
      actual = fyztt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyztt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyztt

    for(int point=0; point<n; point++) // Uyttt 
    {
      N.nu4dyttt(order, n, point, x, y, z, t, cyttt);
      est = 0.0;
      for(int i=0; i<n; i++) est += cyttt[i]*U[i];
      actual = fyttt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("cyttt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uyttt

    for(int point=0; point<n; point++) // Uzzzz 
    {
      N.nu4dzzzz(order, n, point, x, y, z, t, czzzz);
      est = 0.0;
      for(int i=0; i<n; i++) est += czzzz[i]*U[i];
      actual = fzzzz(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("czzzz "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uzzzz

    for(int point=0; point<n; point++) // Uzzzt 
    {
      N.nu4dzzzt(order, n, point, x, y, z, t, czzzt);
      est = 0.0;
      for(int i=0; i<n; i++) est += czzzt[i]*U[i];
      actual = fzzzt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("czzzt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uzzzt

    for(int point=0; point<n; point++) // Uzztt 
    {
      N.nu4dzztt(order, n, point, x, y, z, t, czztt);
      est = 0.0;
      for(int i=0; i<n; i++) est += czztt[i]*U[i];
      actual = fzztt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("czztt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uzztt

    for(int point=0; point<n; point++) // Uzttt 
    {
      N.nu4dzttt(order, n, point, x, y, z, t, czttt);
      est = 0.0;
      for(int i=0; i<n; i++) est += czttt[i]*U[i];
      actual = fzttt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("czttt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Uzttt

    for(int point=0; point<n; point++) // Utttt 
    {
      N.nu4dtttt(order, n, point, x, y, z, t, ctttt);
      est = 0.0;
      for(int i=0; i<n; i++) est += ctttt[i]*U[i];
      actual = ftttt(x[point],y[point],z[point],t[point]);
      error = actual-est;
      maxerror = Math.max(maxerror,Math.abs(error));
      System.out.println("ctttt "+point+", est="+est+", actual="+actual+
                         ", error="+ error);
    } // end Utttt

    System.out.println("maxerror for order="+order+", n="+n+
                       ", is "+maxerror);
    System.out.println("test_nuderiv4d.java finished");
  }

  // test functions
  double f(double x, double y, double z, double t)
  {
    return x*x*x*x +  2.0*x*x*x*y +  3.0*x*x*x*z +  4.0*x*x*x*t +
       5.0*x*x*y*y +  6.0*x*x*y*z +  7.0*x*x*y*t +  8.0*x*x*z*z +
       9.0*x*x*z*t + 10.0*x*x*t*t + 11.0*x*y*y*y + 12.0*x*y*y*z +
      13.0*x*y*y*t + 14.0*x*y*z*z + 15.0*x*y*z*t + 16.0*x*y*t*t +
      17.0*x*z*z*z + 18.0*x*z*z*t + 19.0*x*z*t*t + 20.0*x*t*t*t +
      21.0*y*y*y*y + 22.0*y*y*y*z + 23.0*y*y*y*t + 24.0*y*y*z*z +
      25.0*y*y*z*t + 26.0*y*y*t*t + 27.0*y*z*z*z + 28.0*y*z*z*t +
      29.0*y*z*t*t + 30.0*y*t*t*t + 31.0*z*z*z*z + 32.0*z*z*z*t +
      33.0*z*z*t*t + 34.0*z*t*t*t + 35.0*t*t*t*t + 36.0*x*x*x   +
      37.0*x*x*y   + 38.0*x*x*z   + 39.0*x*x*t   + 40.0*x*y*y   +
      41.0*x*y*z   + 42.0*x*y*t   + 43.0*x*z*z   + 44.0*x*z*t   +
      45.0*x*t*t   + 46.0*y*y*y   + 47.0*y*y*z   + 48.0*y*y*t   +
      49.0*y*z*z   + 50.0*y*z*t   + 51.0*y*t*t   + 52.0*z*z*z   +
      53.0*z*z*t   + 54.0*z*t*t   + 55.0*t*t*t   + 56.0*x*x     +
      57.0*x*y     + 58.0*x*z     + 59.0*x*t     + 60.0*y*y     +
      61.0*y*z     + 62.0*y*t     + 63.0*z*z     + 64.0*z*t     +
      65.0*t*t     + 66.0*x       + 67.0*y       + 68.0*z       +
      69.0*t       + 70.0; 
  }

  double fx(double x, double y, double z, double t)
  {
    return 4.0*x*x*x +  6.0*x*x*y +  9.0*x*x*z + 12.0*x*x*t + 
          10.0*x*y*y + 12.0*x*y*z + 14.0*x*y*t + 16.0*x*z*z +
          18.0*x*z*t + 20.0*x*t*t + 11.0*y*y*y + 12.0*y*y*z +
          13.0*y*y*t + 14.0*y*z*z + 15.0*y*z*t + 16.0*y*t*t +
          17.0*z*z*z + 18.0*z*z*t + 19.0*z*t*t + 20.0*t*t*t +
                                                108.0*x*x   +
          74.0*x*y   + 76.0*x*z   + 78.0*x*t   + 40.0*y*y   +
          41.0*y*z   + 42.0*y*t   + 43.0*z*z   + 44.0*z*t   +
          45.0*t*t   +                          112.0*x     +
	  57.0*y     + 58.0*z     + 59.0*t     +
                       66.0;                        
  }

  double fy(double x, double y, double z, double t)
  {
      //      return            2.0*x*x*x +
      //    20.0*x*x*y +  6.0*x*x*z +  7.0*x*x*t +
      //                              33.0*x*y*y + 24.0*x*y*z +
      //    26.0*x*y*t + 14.0*x*z*z + 15.0*x*z*t + 16.0*x*t*t +
      //    84.0*y*y*y + 66.0*y*y*z + 69.0*y*y*t + 48.0*y*z*z +
      //    50.0*y*z*t + 52.0*y*t*t + 27.0*z*z*z + 28.0*z*z*t +
      //    29.0*z*t*t + 30.0*t*t*t +
      //    37.0*x*x   +                           80.0*x*y   +
      //    41.0*x*z   + 42.0*x*t   +
      //                138.0*y*y   + 94.0*y*z   + 96*y*t     +
      //    49.0*z*z   + 50.0*z*t   + 51.0*t*t   +
      //    57.0*x     +                          120.0*y     +
      //    61.0*z     + 62.0*t     +
      //
      //	                            67.0;
      return 15.0*x*z*t + 57.0*x     + 120.0*y    + 26.0*x*y*t +
             48.0*y*z*z + 50.0*y*z*t + 42.0*x*t   + 14.0*x*z*z +
             24.0*x*y*z + 96.0*y*t   + 28.0*z*z*t + 29.0*z*t*t +
             30.0*t*t*t +  7.0*x*x*t + 69.0*y*y*t + 138.0*y*y  +
             10.0*x*x*y + 37.0*x*x   + 49.0*z*z   + 50.0*z*t   +
             66.0*y*y*z + 80.0*x*y   + 27.0*z*z*z + 41.0*x*z   +
             33.0*x*y*y + 84.0*y*y*y + 52.0*y*t*t + 16.0*x*t*t +
              6.0*x*x*z + 94.0*y*z   + 61.0*z     + 62.0*t     +
	      2.0*x*x*x + 51.0*t*t   + 67.0; 
  }

  double fz(double x, double y, double z, double t)
  {
    return                           3.0*x*x*x +
                        6.0*x*x*y +              16.0*x*x*z +
           9.0*x*x*t +                           12.0*x*y*y +
                       28.0*x*y*z + 15.0*x*y*t +
          51.0*x*z*z + 36.0*x*z*t + 19.0*x*t*t +
                       22.0*y*y*y +              48.0*y*y*z +
          25.0*y*y*t +              81.0*y*z*z + 56.0*y*z*t +
          29.0*y*t*t +             124.0*z*z*z + 96.0*z*z*t +
          66.0*z*t*t + 34.0*t*t*t + 
                       38.0*x*x   + 
          41.0*x*y   +              86.0*x*z   + 44.0*x*t   +
                                    47.0*y*y   + 
          98.0*y*z   + 50.0*y*t   +             156.0*z*z   +
         106.0*z*t   + 54.0*t*t   +
                       58.0*x     +
          61.0*y     +             126.0*z     + 64.0*t     +
	                                         68.0; 
  }

  double ft(double x, double y, double z, double t)
  {
    return                                        4.0*x*x*x +
                                     7.0*x*x*y +
           9.0*x*x*z + 20.0*x*x*t + 
          13.0*x*y*y +              15.0*x*y*z + 32.0*x*y*t +
                       18.0*x*z*z + 38.0*x*z*t + 60.0*x*t*t +
                                    23.0*y*y*y + 
          25.0*y*y*z + 52.0*y*y*t +            + 28.0*y*z*z +
          58.0*y*z*t + 90.0*y*t*t +              32.0*z*z*z +
          66.0*z*z*t +102.0*z*t*t +140.0*t*t*t +
                                    39.0*x*x   +
                       42.0*x*y   +              44.0*x*z   +
          90.0*x*t   +                           48.0*y*y   +
                       50.0*y*z   +102.0*y*t   +
          53.0*z*z   +108.0*z*t   +165.0*t*t   + 
                                    59.0*x     +
                       62.0*y     +              64.0*z     +
         130.0*t     +
	  69.0;
  }

  double fxx(double x, double y, double z, double t)
  {
    return 18.0*z*t+112.0+14.0*y*t+78.0*t+16.0*z*z+12.0*y*z+24.0*x*t+
	   12.0*x*y+216.0*x+74.0*y+76.0*z+10.0*y*y+20.0*t*t+18.0*x*z+12*x*x;
  }

  double fxy(double x, double y, double z, double t)
  {
    return 57.0+14.0*x*t+14.0*z*z+15.0*z*t+12.0*x*z+42.0*t+26.0*y*t+
           80.0*y+6.0*x*x+24.0*y*z+74.0*x+20.0*x*y+33.0*y*y+
           16.0*t*t+41.0*z;
  }

  double fxz(double x, double y, double z, double t)
  {
    return 18.0*x*t+28.0*y*z+15.0*y*t+32.0*x*z+12.0*x*y+36.0*z*t+
           19.0*t*t+86.0*z+44.0*t+12.0*y*y+51.0*z*z+76.0*x+9.0*x*x+
           41.0*y+58.0;
  }

  double fxt(double x, double y, double z, double t)
  {
    return 18.0*x*z+14.0*x*y+15.0*y*z+78.0*x+42.0*y+18.0*z*z+38.0*z*t+
           60.0*t*t+12.0*x*x+13.0*y*y+44.0*z+32.0*y*t+40.0*x*t+
           59.0+90.0*t;
  }

  double fyy(double x, double y, double z, double t)
  {
    return 120.0+26.0*x*t+48.0*z*z+50.0*z*t+24.0*x*z+96.0*t+138.0*y*t+
           276.0*y+10.0*x*x+132.0*y*z+80.0*x+66.0*x*y+252.0*y*y+
            52.0*t*t+94.0*z;
  }

  double fyz(double x, double y, double z, double t)
  {
    return 15.0*x*t+96.0*y*z+50.0*y*t+28.0*x*z+24.0*x*y+56.0*z*t+
           29.0*t*t+98.0*z+50.0*t+66.0*y*y+81.0*z*z+41.0*x+6.0*x*x+
           94.0*y+61.0;
  }

  double fyt(double x, double y, double z, double t)
  {
    return 15.0*x*z+26.0*x*y+50.0*y*z+42.0*x+96.0*y+28.0*z*z+
           58.0*z*t+90.0*t*t+7.0*x*x+69.0*y*y+50.0*z+104.0*y*t+
           32.0*x*t+62.0+102.0*t;
  }

  double fzz(double x, double y, double z, double t)
  {
    return  36.0*x*t+162.0*y*z+56.0*y*t+102.0*x*z+28.0*x*y+192.0*z*t+66.0*t*t+
            312.0*z+106.0*t+48.0*y*y+372.0*z*z+86.0*x+16.0*x*x+98.0*y+126.0;
  }

  double fzt(double x, double y, double z, double t)
  {
    return 36.0*x*z+15.0*x*y+56.0*y*z+44.0*x+50.0*y+96.0*z*z+
           132.0*z*t+102.0*t*t+9.0*x*x+25.0*y*y+106.0*z+58.0*y*t+
           38.0*x*t+64.0+108.0*t;
  }

  double ftt(double x, double y, double z, double t)
  {
    return 38.0*x*z+32.0*x*y+58.0*y*z+90.0*x+102.0*y+66.0*z*z+204.0*z*t+
           420*t*t+20.0*x*x+52.0*y*y+108.0*z+180.0*y*t+120.0*x*t+
           130.0+330.0*t;
  }

  double fxxx(double x, double y, double z, double t)
  {
    return 24.0*t+24.0*x+12.0*y+18.0*z+216.0;
  }

  double fxxy(double x, double y, double z, double t)
  {
    return 14.0*t+12.0*z+20.0*y+12.0*x+74.0;
  }

  double fxxz(double x, double y, double z, double t)
  {
    return 18.0*t+12.0*y+32.0*z+18.0*x+76.0;
  }

  double fxxt(double x, double y, double z, double t)
  {
    return 14.0*y+18.0*z+24.0*x+40.0*t+78.0;
  }

  double fxyy(double x, double y, double z, double t)
  {
    return 26.0*t+24.0*z+20.0*x+80.0+66.0*y ;
  }

  double fxyz(double x, double y, double z, double t)
  {
    return  28.0*z+15.0*t+12.0*x+24.0*y+41.0;
  }

  double fxyt(double x, double y, double z, double t)
  {
    return 14.0*x+15.0*z+42.0+26.0*y+32.0*t;
  }

  double fxzz(double x, double y, double z, double t)
  {
    return 36.0*t+102.0*z+28.0*y+86.0+32.0*x;
  }

  double fxzt(double x, double y, double z, double t)
  {
    return 18.0*x+15.0*y+36.0*z+38.0*t+44.0;
  }

  double fxtt(double x, double y, double z, double t)
  {
    return 38.0*z+32.0*y+90.0+40.0*x+120.0*t;
  }

  double fyyy(double x, double y, double z, double t)
  {
    return 66.0*x+132.0*z+138.0*t+504.0*y+276.0;
  }

  double fyyz(double x, double y, double z, double t)
  {
    return 50.0*t+24.0*x+132.0*y+96.0*z+94.0;
  }

  double fyyt(double x, double y, double z, double t)
  {
    return 26.0*x+50.0*z+138.0*y+104.0*t+96.0;
  }

  double fyzz(double x, double y, double z, double t)
  {
    return 162.0*z+56.0*t+28.0*x+96.0*y+98.0;
  }

  double fyzt(double x, double y, double z, double t)
  {
    return 15.0*x+50.0*y+56.0*z+58.0*t+50.0;
  }

  double fytt(double x, double y, double z, double t)
  {
    return 32.0*x+58.0*z+102.0+104.0*y+180.0*t;
  }

  double fzzz(double x, double y, double z, double t)
  {
    return 102.0*x+162.0*y+192.0*t+744.0*z+312.0;
  }

  double fzzt(double x, double y, double z, double t)
  {
    return 56.0*y+36.0*x+132.0*t+192.0*z+106.0;
  }

  double fztt(double x, double y, double z, double t)
  {
    return  38.0*x+58.0*y+132.0*z+204.0*t+108.0;
  }

  double fttt(double x, double y, double z, double t)
  {
    return 204.0*z+840*t+180.0*y+120.0*x+330.0;
  }

  double fxxxx(double x, double y, double z, double t)
  {
    return 24.0;
  }

  double fxxxy(double x, double y, double z, double t)
  {
    return 12.0;
  }

  double fxxxz(double x, double y, double z, double t)
  {
    return 18.0;
  }

  double fxxxt(double x, double y, double z, double t)
  {
    return 24.0;
  }

  double fxxyy(double x, double y, double z, double t)
  {
    return 20.0;
  }

  double fxxyz(double x, double y, double z, double t)
  {
    return 12.0;
  }

  double fxxyt(double x, double y, double z, double t)
  {
    return 14.0;
  }

  double fxxzz(double x, double y, double z, double t)
  {
    return 32.0;
  }

  double fxxzt(double x, double y, double z, double t)
  {
    return 18.0;
  }

  double fxxtt(double x, double y, double z, double t)
  {
    return 40.0;
  }

  double fxyyy(double x, double y, double z, double t)
  {
    return 66.0;
  }

  double fxyyz(double x, double y, double z, double t)
  {
    return 24.0;
  }

  double fxyyt(double x, double y, double z, double t)
  {
    return 26.0;
  }

  double fxyzz(double x, double y, double z, double t)
  {
    return 28.0;
  }

  double fxyzt(double x, double y, double z, double t)
  {
    return 15.0;
  }

  double fxytt(double x, double y, double z, double t)
  {
    return 32.0;
  }

  double fxzzz(double x, double y, double z, double t)
  {
    return 102.0;
  }

  double fxzzt(double x, double y, double z, double t)
  {
    return 36.0;
  }

  double fxztt(double x, double y, double z, double t)
  {
    return 38.0;
  }

  double fxttt(double x, double y, double z, double t)
  {
    return 120.0;
  }

  double fyyyy(double x, double y, double z, double t)
  {
    return 504.0;
  }

  double fyyyz(double x, double y, double z, double t)
  {
    return 132.0;
  }

  double fyyyt(double x, double y, double z, double t)
  {
    return 138.0;
  }

  double fyyzz(double x, double y, double z, double t)
  {
    return 96.0;
  }

  double fyyzt(double x, double y, double z, double t)
  {
    return 50.0;
  }

  double fyytt(double x, double y, double z, double t)
  {
    return 104.0;
  }

  double fyzzz(double x, double y, double z, double t)
  {
    return 162.0;
  }

  double fyzzt(double x, double y, double z, double t)
  {
    return 56.0;
  }

  double fyztt(double x, double y, double z, double t)
  {
    return 58.0;
  }

  double fyttt(double x, double y, double z, double t)
  {
    return 180.0;
  }

  double fzzzz(double x, double y, double z, double t)
  {
    return 744.0;
  }

  double fzzzt(double x, double y, double z, double t)
  {
    return 192.0;
  }

  double fzztt(double x, double y, double z, double t)
  {
    return 132.0;
  }

  double fzttt(double x, double y, double z, double t)
  {
    return 204.0;
  }

  double ftttt(double x, double y, double z, double t)
  {
    return 840.0;
  }

  void gen_data4(int which)
  {
    double rx = 0.25;
    double ry = 0.28;
    double rz = 0.33;
    double rt = 0.37;
    double drx = 0.0096;
    double dry = 0.0094;
    double drz = 0.0091;
    double drt = 0.0089;
    double thx = 0.2;
    double thy = 1.7;
    double thz = 2.3;
    double tht = 3.32;
    double dthx = 0.61;
    double dthy = 0.72;
    double dthz = 0.49;
    double dtht = 0.53;
    double d5th = 0.628318531;
    double d3rd = 1.047197551;
    double th5th = 1.256637061; 
    double r = 0.2;
    double theta1 = 0.05;
    double phi1 = 0.1;
    double psi1 = 0.15;
    int    nn = 0;
    double theta, phi, psi;

    if(which==0)
    { 
      for(int i=0; i<n; i++)
      {
        x[i] = rx*Math.sin(thx);
        y[i] = ry*Math.cos(thy);
        z[i] = rz*Math.sin(thz);
        t[i] = rt*Math.cos(tht);
        rx = rx + drx;
        ry = ry + dry;
        rz = rz + drz;
        rt = rt + drt;
        thx = thx + dthx;
        thy = thy + dthy;
        thz = thz + dthz;
        tht = tht + dtht;
      }
    }
    else
    {
      nn = 0;
      psi = psi1;
      for(int ipsi=0; ipsi<3; ipsi++)
      {
	phi = phi1;
	for(int iphi=0; iphi<5; iphi++)
	{
	  theta = theta1;
	  for(int itheta=0; itheta<5; itheta++)
	  {
	    x[nn] = r*Math.sin(psi)*Math.sin(phi)*Math.cos(theta); 
            y[nn] = r*Math.sin(psi)*Math.sin(phi)*Math.sin(theta);
            z[nn] = r*Math.sin(psi)*Math.cos(phi);
            t[nn] = r*Math.cos(psi);
            nn++;
            if(nn==n) return;
            r += 0.011;
	    theta += th5th;
          }
          theta1 += 0.008;
          phi += d5th;
        }
        phi1 += 0.009;
        psi += d3rd;
      }
    } // end if 
  } // end gen_data4

  public static void main (String[] args)
  {
    new test_nuderiv4d();
  }
} // end  class test_nuderiv4d