Actual source code: ad_grad.c

  1: /*
  2:   THIS PROGRAM DISCLOSES MATERIAL PROTECTABLE UNDER COPYRIGHT
  3:   LAWS OF THE UNITED STATES.  FOR LICENSING INFORMATION CONTACT:

  5:   Christian Bischof or Lucas Roh, Mathematics and Computer Science Division,
  6:   Argonne National Laboratory, 9700 S. Cass Avenue, Argonne IL 60439, 
  7:   {bischof,roh}@mcs.anl.gov.
  8: */

 10: #include "petsc.h"
 11: #include <stdarg.h>

 13: #include "ad_deriv.h"
 14: #include "ad_grad.h"

 16: int ad_grad_size = 0;
 17: int ad_total_grad_size = 0;
 18: int ad_grad_size_shadow = 0;


 21: EXTERN_C_BEGIN

 23: int ad_AD_IncrShadowVar(void)
 24: { return ad_grad_size_shadow++; }

 26: void ad_AD_CommitShadowVar(void)
 27: { ad_grad_size = ad_grad_size_shadow; }

 29: void ad_AD_ResetShadowVar(void)
 30: { ad_grad_size_shadow = 0; }

 32: void ad_grad_axpy_n(int arity, void* ddz, ...)
 33: {
 34:   int                i, j;
 35:   double             *z,alpha,*gradv;
 36:   static double      alphas[100];
 37:   static DERIV_TYPE* grads[100];
 38:   va_list            parg;

 40:   va_start(parg, ddz);
 41:   for (i = 0; i < arity; i++) {
 42:     alphas[i] = va_arg(parg, double);
 43:     grads[i]  = (DERIV_TYPE*)va_arg(parg, DERIV_TYPE*);
 44:   }
 45:   va_end(parg);

 47:   z = DERIV_grad(*((DERIV_TYPE*)ddz));
 48:   {
 49:     gradv = DERIV_grad(*grads[0]);
 50:     alpha = alphas[0];
 51:     for (i = 0; i < ad_GRAD_MAX; i++) {
 52:       z[i] = alpha*gradv[i];
 53:     }
 54:   }
 55:   for (j = 1; j < arity; j++) {
 56:     gradv = DERIV_grad(*grads[j]);
 57:     alpha = alphas[j];
 58:     for (i = 0; i < ad_GRAD_MAX; i++) {
 59:       z[i] += alpha*gradv[i];
 60:     }
 61:   }
 62:   PetscLogFlops(2*ad_GRAD_MAX*(arity-.5));
 63: }

 65: void mfad_grad_axpy_n(int arity, void* ddz, ...)
 66: {
 67:   int                j;
 68:   double             *z,*gradv;
 69:   static double      alphas[100];
 70:   static DERIV_TYPE* grads[100];
 71:   va_list            parg;

 73:   va_start(parg, ddz);
 74:   for (j = 0; j < arity; j++) {
 75:     alphas[j] = va_arg(parg, double);
 76:     grads[j]  = (DERIV_TYPE*)va_arg(parg, DERIV_TYPE*);
 77:   }
 78:   va_end(parg);

 80:   z = DERIV_grad(*((DERIV_TYPE*)ddz));
 81:   {
 82:     gradv = DERIV_grad(*grads[0]);
 83:     z[0] = alphas[0]*gradv[0];
 84:   }

 86:   for (j = 1; j < arity; j++) {
 87:     gradv = DERIV_grad(*grads[j]);
 88:     z[0] += alphas[j]*gradv[0];
 89:   }
 90:   PetscLogFlops(2*(arity-.5));
 91: }

 93: EXTERN_C_END