FORM 4.0 (Jun 30 2012) 64-bits                   Run: Mon Feb  4 11:47:30 2013
    *   Title:  POINT CHARGE:  tests
    *           derivatives of retarded and advanced quantities
    *    File:  derivs-test.frm
    *  Author:  David N. Williams
    * License:  Creative Commons Attribution-Share Alike
    * Started:  July 15, 2012
    * Revised:  July 15,16, 2012
    *           August 27,31, 2012
    *           September 1-3,8 2012
    *
    * All parts of this program not in the public domain are:
    *
    *   Copyright (C) 1987-1990, 2012 David N. Williams
    *
    * This work is licensed under the Creative Commons Attribution-
    * Share Alike 2.5 License.  To view a copy of this license, visit
    * http://creativecommons.org/licenses/by-sa/2.5/ or send a letter
    * to Creative Commons, 543 Howard Street, 5th Floor, San
    * Francisco, California, 94105, USA.
    *
    *   Input:  derivs.sav
    *  Output:  log file
    
    #if 0
    See derivs.frm for notation for quantities tested here.
    
    Many of the results used for testing are from our handwritten
    CLASSICAL ELECTRODYNAMICS noteboak, indicated by CED, dating
    back to the early 1970's or before.  Others are from hand
    calculations, since discarded.  Still others are based on
    previously tested results in this file.
    
    Generally speaking there are more tests than absolutely
    necessary. Many were inherited from an earlier version of the
    calculation, which did not have a general differentiation
    procedure.  Now it's mainly the procedure itself that needs
    testing, but we used the old tests to develop the procedure, and
    kept them as a guard against typos in the inputs.
    #endif
    
    *** DEBUGGING
    
    #procedure try
    print;
    .end
    #endprocedure
    
    *** DECLARATIONS
    
    #include derivs-ra.h
    #-
    
    off statistics;
    I mu,nu,la,ro;
    Load derivs.sav;
 dr loaded
 du loaded
 da loaded
 dj loaded
 [d(r.u)] loaded
 [d(r.a)] loaded
 [d.r] loaded
 [d.u] loaded
 [d.a] loaded
 [d.j] loaded
 [r.dr] loaded
 [r.du] loaded
 [r.da] loaded
 [r.dj] loaded
 [u.dr] loaded
 [u.du] loaded
 [u.da] loaded
 [a.dr] loaded
 [a.du] loaded
 [a.da] loaded
 df loaded
 df1 loaded
 [r.d(r.u)] loaded
 [r.d(r.a)] loaded
 [u.d(r.u)] loaded
 [u.d(r.a)] loaded
 [a.d(r.u)] loaded
 [a.d(r.a)] loaded
 [r.df] loaded
 [u.df] loaded
 dfr loaded
 dfu loaded
 dfa loaded
 dfj loaded
 df1r loaded
 df1u loaded
 df1a loaded
 df1j loaded
 drr loaded
 dru loaded
 dra loaded
 drj loaded
 duu loaded
 dua loaded
 duj loaded
 daa loaded
 daj loaded
 dfrr loaded
 dfru loaded
 dfra loaded
 dfrj loaded
 dfuu loaded
 dfua loaded
 dfuj loaded
 dfaa loaded
 dfaj loaded
 [d.fr] loaded
 [d.fu] loaded
 [d.fa] loaded
 [d.fj] loaded
 [d.frr] loaded
 [d.fru] loaded
 [d.fra] loaded
 [d.fur] loaded
 [d.fuu] loaded
 [d.fua] loaded
 [d.far] loaded
 [d.fau] loaded
 [d.faa] loaded
 ddf loaded
 ddr loaded
 ddu loaded
 dda loaded
 ddfr loaded
 ddfu loaded
 ddfa loaded
 ddrr loaded
 ddru loaded
 ddra loaded
 dduu loaded
 ddua loaded
 ddaa loaded
 ddfrr loaded
 ddfru loaded
 ddfra loaded
 ddfuu loaded
 ddfua loaded
 ddfaa loaded
 dddfr loaded
    .global
    
    *** MODULES
    
    * CED, p.11.
    G diff1 = -dr(mu,nu) + g(mu,nu) - r(mu)*u(nu)/r.u;
    G diff2 = -du(mu,nu) + r(mu)*a(nu)/r.u;
    G diff3 = -da(mu,nu) + r(mu)*j(nu)/r.u;
    G diff4 = -dj(mu,nu) + r(mu)*jdot(nu)/r.u;
    
    * CED, p.11.
    G diff5 = -[d(r.u)](mu) + u(mu) + r(mu)*(r.a-c^2)/r.u;
    G diff6 = -[d(r.a)](mu) + a(mu) + r(mu)*r.j/r.u;
    
    G diff7 = -[d.r] + 3;
    G diff8 = -[d.u] + r.a/r.u;
    G diff9 = -[d.a] + r.j/r.u;
    
    G diff10 = -[u.dr](mu) + 0;
    G diff11 = -[u.du](mu) + a(mu);
    G diff12 = -[u.da](mu) + j(mu);
    
    G diff13  = -[r.dr](mu) + r(mu);
    G diff14 = -[r.du](mu) + 0;
    G diff15 = -[r.da](mu) + 0;
    G diff16 = -[r.dj](mu) + 0;
    
    G diff17 = -df(mu)  + f1*( u(mu) + r(mu)*(r.a-c^2)/r.u );
    G diff18 = -df1(mu) + f2*( u(mu) + r(mu)*(r.a-c^2)/r.u );
    
    * Hand calculation.
    G diff19 = -[a.dr](mu) + a(mu) - u(mu)*r.a/r.u;
    G diff20 = -[a.du](mu) + a(mu)*r.a/r.u;
    G diff21 = -[a.da](mu) + j(mu)*r.a/r.u;
    
    * CED, p.11.
    G diff22 = -[u.d(r.u)] + r.a;
    G diff23 = -[u.d(r.a)] + r.j;
    G diff24 = -[r.d(r.u)] + r.u;
    G diff25 = -[r.d(r.a)] + r.a;
    G diff26 = -[a.d(r.u)] + r.a*(r.a-c^2)/r.u;
    G diff27 = -[a.d(r.a)] + a.a + r.a*r.j/r.u;
    
    * CED, p.15.
    G diff28 = -[r.df] + f1*r.u;
    G diff29 = -[u.df] + f1*r.a;
    
    G diff30 = -dfr(mu,nu) + g(mu,nu)*f + r(mu)*r(nu)*f1*(r.a-c^2)/r.u
              - r(mu)*u(nu)*f/r.u + u(mu)*r(nu)*f1;
    G diff31 = -dfu(mu,nu) + u(mu)*u(nu)*f1
              + r(mu)*u(nu)*f1*(r.a-c^2)/r.u + r(mu)*a(nu)*f/r.u;
    G diff32 = -dfa(mu,nu) + f*r(mu)*j(nu)/r.u + f1*u(mu)*a(nu)
              + f1*r(mu)*a(nu)*(r.a-c^2)/r.u;
    G diff33 = -dfj(mu,nu) + f*r(mu)*jdot(nu)/r.u + f1*u(mu)*j(nu)
              + f1*r(mu)*j(nu)*(r.a-c^2)/r.u;
    G diff34 = -df1r(mu,nu) + g(mu,nu)*f1 + r(mu)*r(nu)*f2*(r.a-c^2)/r.u
              - r(mu)*u(nu)*f1/r.u + u(mu)*r(nu)*f2;
    G diff35 = -df1u(mu,nu) + u(mu)*u(nu)*f2
              + r(mu)*u(nu)*f2*(r.a-c^2)/r.u + r(mu)*a(nu)*f1/r.u;
    G diff36 = -df1a(mu,nu) + f1*r(mu)*j(nu)/r.u + f2*u(mu)*a(nu)
              + f2*r(mu)*a(nu)*(r.a-c^2)/r.u;
    G diff37 = -df1j(mu,nu) + f1*r(mu)*jdot(nu)/r.u + f2*u(mu)*j(nu)
              + f2*r(mu)*j(nu)*(r.a-c^2)/r.u;
    print;
    .store

   diff1 = 0;

   diff2 = 0;

   diff3 = 0;

   diff4 = 0;

   diff5 = 0;

   diff6 = 0;

   diff7 = 0;

   diff8 = 0;

   diff9 = 0;

   diff10 = 0;

   diff11 = 0;

   diff12 = 0;

   diff13 = 0;

   diff14 = 0;

   diff15 = 0;

   diff16 = 0;

   diff17 = 0;

   diff18 = 0;

   diff19 = 0;

   diff20 = 0;

   diff21 = 0;

   diff22 = 0;

   diff23 = 0;

   diff24 = 0;

   diff25 = 0;

   diff26 = 0;

   diff27 = 0;

   diff28 = 0;

   diff29 = 0;

   diff30 = 0;

   diff31 = 0;

   diff32 = 0;

   diff33 = 0;

   diff34 = 0;

   diff35 = 0;

   diff36 = 0;

   diff37 = 0;

    
    * Lorentz gauge:  ∂⋅A = 0
    G divA = dfu(mu,mu);
    #call idmetric
    #call idf
    .sort
    
    G diff38 = -drr(la,mu,nu) + dr(la,mu)*r(nu) + r(mu)*dr(la,nu); 
    G diff39 = -dru(la,mu,nu) + dr(la,mu)*u(nu) + r(mu)*du(la,nu);
    G diff40 = -dra(la,mu,nu) + dr(la,mu)*a(nu) + r(mu)*da(la,nu); 
    G diff41 = -drj(la,mu,nu) + dr(la,mu)*j(nu) + r(mu)*dj(la,nu);
    G diff42 = -duu(la,mu,nu) + du(la,mu)*u(nu) + u(mu)*du(la,nu); 
    G diff43 = -dua(la,mu,nu) + du(la,mu)*a(nu) + u(mu)*da(la,nu); 
    G diff44 = -duj(la,mu,nu) + du(la,mu)*j(nu) + u(mu)*dj(la,nu);
    G diff45 = -daa(la,mu,nu) + da(la,mu)*a(nu) + a(mu)*da(la,nu); 
    G diff46 = -daj(la,mu,nu) + da(la,mu)*j(nu) + a(mu)*dj(la,nu);
    
    G diff47 = -dfrr(la,mu,nu)
             + df(la)*r(mu)*r(nu) + f*dr(la,mu)*r(nu) + f*r(mu)*dr(la,nu); 
    G diff48 = -dfru(la,mu,nu)
             + df(la)*r(mu)*u(nu) + f*dr(la,mu)*u(nu) + f*r(mu)*du(la,nu);
    G diff49 = -dfra(la,mu,nu)
             + df(la)*r(mu)*a(nu) + f*dr(la,mu)*a(nu) + f*r(mu)*da(la,nu); 
    G diff50 = -dfrj(la,mu,nu)
             + df(la)*r(mu)*j(nu) + f*dr(la,mu)*j(nu) + f*r(mu)*dj(la,nu); 
    G diff51 = -dfuu(la,mu,nu)
             + df(la)*u(mu)*u(nu) + f*du(la,mu)*u(nu) + f*u(mu)*du(la,nu); 
    G diff52 = -dfua(la,mu,nu)
             + df(la)*u(mu)*a(nu) + f*du(la,mu)*a(nu) + f*u(mu)*da(la,nu); 
    G diff53 = -dfuj(la,mu,nu)
             + df(la)*u(mu)*j(nu) + f*du(la,mu)*j(nu) + f*u(mu)*dj(la,nu); 
    G diff54 = -dfaa(la,mu,nu)
             + df(la)*a(mu)*a(nu) + f*da(la,mu)*a(nu) + f*a(mu)*da(la,nu); 
    G diff55 = -dfaj(la,mu,nu)
             + df(la)*a(mu)*j(nu) + f*da(la,mu)*j(nu) + f*a(mu)*dj(la,nu); 
    print;
    .store

   divA = 0;

   diff38 = 0;

   diff39 = 0;

   diff40 = 0;

   diff41 = 0;

   diff42 = 0;

   diff43 = 0;

   diff44 = 0;

   diff45 = 0;

   diff46 = 0;

   diff47 = 0;

   diff48 = 0;

   diff49 = 0;

   diff50 = 0;

   diff51 = 0;

   diff52 = 0;

   diff53 = 0;

   diff54 = 0;

   diff55 = 0;

    
    * Lorentz gauge Maxwell equations away from charge: ∂⋅∂A = 0
    G dalemA = ddfu(mu,mu,la);
    #call idmetric
    #call idf
    print;
    .store

   dalemA = 0;

    
    * CED, p.14.
    G diff56 = -[d.fr] + 3*f + f1*r.u;
    G diff57 = -[d.fu] + (f/r.u + f1)*r.a;
    * Hand calculation.
    G diff58 = -[d.fa] + f*r.j/r.u + f1*r.a*(r.a-c^2)/r.u;
    G diff59 = -[d.fj] + f*r.jdot/r.u + f1*( u.j +  r.j*(r.a-c^2)/r.u );
    #call idmetric
    .sort
    
    * CED, p.14, plus hand calculation.
    G diff60 = -[d.frr](mu) + r(mu)*( 4*f + f1*r.u );
    G diff61 = -[d.fru](mu) + u(mu)*( 3*f + f1*r.u );
    G diff62 = -[d.fra](mu) + a(mu)*( 3*f + f1*r.u );
    G diff63 = -[d.fur](mu) + r(mu)*( f/r.u + f1 )*r.a;
    G diff64 = -[d.fuu](mu) + ( u(mu)*r.a/r.u + a(mu) )*f + u(mu)*r.a*f1;
    G diff65 = -[d.fua](mu) + a(mu)*( f/r.u + f1 )*r.a + j(mu)*f;
    G diff66 = -[d.far](mu) + r(mu)*( f*r.j + f1*r.a*(r.a-c^2) )/r.u
                               - u(mu)*f*r.a/r.u + a(mu)*f;
    G diff67 = -[d.fau](mu) + u(mu)*( f*r.j + f1*r.a*(r.a-c^2) )/r.u
                               + a(mu)*f*r.a/r.u;
    G diff68 = -[d.faa](mu) + a(mu)*( f*r.j + f1*r.a*(r.a-c^2) )/r.u
                               + j(mu)*f*r.a/r.u;
    
    * CED, p.25.
    G diff69 = -ddf(mu,nu) + g(mu,nu)*f1*(r.a-c^2)/r.u + u(mu)*u(nu)*f2
      + r(mu)*r(nu)*(
          f2*(r.a-c^2)^2/r.u^2 - f1*(r.a-c^2)^2/r.u^3 + f1*r.j/r.u^2
        )
      + ( r(mu)*u(nu) + r(nu)*u(mu) )*(
          f2*(r.a-c^2)/r.u - f1*(r.a-c^2)/r.u^2
        )
      + ( r(mu)*a(nu) + r(nu)*a(mu) )*f1/r.u;
    print;
    .store

   diff56 = 0;

   diff57 = 0;

   diff58 = 0;

   diff59 = 0;

   diff60 = 0;

   diff61 = 0;

   diff62 = 0;

   diff63 = 0;

   diff64 = 0;

   diff65 = 0;

   diff66 = 0;

   diff67 = 0;

   diff68 = 0;

   diff69 = 0;

    
    * ∂(∂R) = -∂(Ru/R.u) =    -∂(fRu)
    G diff70 = -ddr(la,mu,nu) - dfru(la,mu,nu);
    * ∂(∂u) =  ∂(Ra/R.u) =     ∂(fRa)
    G diff71 = -ddu(la,mu,nu) + dfra(la,mu,nu);
    * ∂(∂a) =  ∂(Rj/R.u) =     ∂(fRj)
    G diff72 = -dda(la,mu,nu) + dfrj(la,mu,nu);
    * ∂(∂j) =  ∂(Rjdot/R.u) =  ∂(fRjdot) not implemented
    #call idf
    .sort
    
    G diff73 = -ddfr(mu,nu,la)
      + ddf(mu,nu)*r(la) + df(nu)*dr(mu,la) + df(mu)*dr(nu,la)
      + f*ddr(mu,nu,la);
    G diff74 = -ddfu(mu,nu,la)
      + ddf(mu,nu)*u(la) + df(nu)*du(mu,la) + df(mu)*du(nu,la)
      + f*ddu(mu,nu,la);
    G diff75 = -ddfa(mu,nu,la)
      + ddf(mu,nu)*a(la) + df(nu)*da(mu,la) + df(mu)*da(nu,la)
      + f*dda(mu,nu,la);
    print;
    .store

   diff70 = 0;

   diff71 = 0;

   diff72 = 0;

   diff73 = 0;

   diff74 = 0;

   diff75 = 0;

    
    G diff76 = -ddrr(mu,nu,la,ro)
      + ddr(mu,nu,la)*r(ro) + dr(nu,la)*dr(mu,ro) + dr(mu,la)*dr(nu,ro)
      + r(la)*ddr(mu,nu,ro);
    G diff77 = -ddru(mu,nu,la,ro)
      + ddr(mu,nu,la)*u(ro) + dr(nu,la)*du(mu,ro) + dr(mu,la)*du(nu,ro)
      + r(la)*ddu(mu,nu,ro);
    G diff78 = -ddra(mu,nu,la,ro)
      + ddr(mu,nu,la)*a(ro) + dr(nu,la)*da(mu,ro) + dr(mu,la)*da(nu,ro)
      + r(la)*dda(mu,nu,ro);
    G diff79 = -dduu(mu,nu,la,ro)
      + ddu(mu,nu,la)*u(ro) + du(nu,la)*du(mu,ro) + du(mu,la)*du(nu,ro)
      + u(la)*ddu(mu,nu,ro);
    G diff80 = -ddua(mu,nu,la,ro)
      + ddu(mu,nu,la)*a(ro) + du(nu,la)*da(mu,ro) + du(mu,la)*da(nu,ro)
      + u(la)*dda(mu,nu,ro);
    G diff81 = -ddaa(mu,nu,la,ro)
      + dda(mu,nu,la)*a(ro) + da(nu,la)*da(mu,ro) + da(mu,la)*da(nu,ro)
      + a(la)*dda(mu,nu,ro);
    
    G diff82 = -ddfrr(mu,nu,la,ro) + ddf(mu,nu)*r(la)*r(ro)
      + df(nu)*drr(mu,la,ro) + df(mu)*drr(nu,la,ro)
      + f*ddrr(mu,nu,la,ro);
    G diff83 = -ddfru(mu,nu,la,ro) + ddf(mu,nu)*r(la)*u(ro)
      + df(nu)*dru(mu,la,ro) + df(mu)*dru(nu,la,ro)
      + f*ddru(mu,nu,la,ro);
    G diff84 = -ddfra(mu,nu,la,ro) + ddf(mu,nu)*r(la)*a(ro)
      + df(nu)*dra(mu,la,ro) + df(mu)*dra(nu,la,ro)
      + f*ddra(mu,nu,la,ro);
    G diff85 = -ddfuu(mu,nu,la,ro) + ddf(mu,nu)*u(la)*u(ro)
      + df(nu)*duu(mu,la,ro) + df(mu)*duu(nu,la,ro)
      + f*dduu(mu,nu,la,ro);
    G diff86 = -ddfua(mu,nu,la,ro) + ddf(mu,nu)*u(la)*a(ro)
      + df(nu)*dua(mu,la,ro) + df(mu)*dua(nu,la,ro)
      + f*ddua(mu,nu,la,ro);
    G diff87 = -ddfaa(mu,nu,la,ro) + ddf(mu,nu)*a(la)*a(ro)
      + df(nu)*daa(mu,la,ro) + df(mu)*daa(nu,la,ro)
      + f*ddaa(mu,nu,la,ro);
    
    print +s;
    .end

   diff76 =
       - 2*g(r,u)*r.u^-1
       + g(mu,la)*r(nu)*u(ro)*r.u^-1
       - g(mu,la)*g(nu,ro)
       + g(mu,ro)^2
       - g(mu,ro)*g(nu,la)
       + g(nu,la)*r(mu)*u(ro)*r.u^-1
       + g(nu,ro)^2
      ;

   diff77 = 0;

   diff78 = 0;

   diff79 = 0;

   diff80 = 0;

   diff81 = 0;

   diff82 = 0;

   diff83 = 0;

   diff84 = 0;

   diff85 = 0;

   diff86 = 0;

   diff87 = 0;

  0.03 sec out of 0.03 sec