Actual source code: ad_grad.h

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

  5:   Paul Hovland and Boyana Norris, Mathematics and Computer Science Division,
  6:   Argonne National Laboratory, 9700 S. Cass Avenue, Argonne IL 60439, 
  7:   {hovland,norris}@mcs.anl.gov.
  8: */


 11: #if !defined(AD_GRAD_H)
 12: #define AD_GRAD_H

 14: #include <string.h>
 15: #include "ad_grad_macro_axpys.h"

 17: extern int ad_grad_size;
 18: extern int ad_total_grad_size;   /*only used when generating MPI programs*/
 19: extern int ad_grad_size_shadow;

 21: #   if defined(__cplusplus)
 22:         extern "C" {
 23: #   endif
 24: 
 25: #define ad_AD_GradInitMPI(pargc, pargv) 
 26:     { 
 27:         ad_mpi_init(pargc, pargv, &ad_total_grad_size); 
 28:     }


 31: #define ad_AD_GradFinalMPI() 
 32:     { 
 33:         ad_mpi_final(); 
 34:     }

 36: #define ad_AD_GradFinal() 
 37:     { 
 38:         ad_grad_size = 0; 
 39:     }



 43: #define ad_AD_GradInit(n) 
 44:     { 
 45:         if (n == -1) 
 46:            ad_grad_size = ad_GRAD_MAX; 
 47:         else 
 48:            ad_grad_size = n; 
 49:         ad_grad_size_shadow = 0; 
 50:     }


 53: #define ad_AD_ClearGrad(gz) memset((char*)gz, 0, ad_GRAD_MAX*sizeof(double)); 

 55: #define ad_AD_ClearGrad2(gz)
 56:     {
 57:         int iWiLlNeVeRCoNfLiCt0;
 58:         for (iWiLlNeVeRCoNfLiCt0 = 0 ; iWiLlNeVeRCoNfLiCt0 < ad_GRAD_MAX; 
 59:              iWiLlNeVeRCoNfLiCt0++) {
 60:             gz[iWiLlNeVeRCoNfLiCt0] = 0.0;
 61:         }
 62:     }

 64: #define ad_AD_ClearGradArray(ggz,size)
 65:     {
 66:         int iWiLlNeVeRCoNfLiCt0;
 67:         for (iWiLlNeVeRCoNfLiCt0 = 0 ; iWiLlNeVeRCoNfLiCt0 < size; 
 68:              iWiLlNeVeRCoNfLiCt0++) {
 69:             ad_AD_ClearGrad(DERIV_grad((ggz)[iWiLlNeVeRCoNfLiCt0])); 
 70:         }
 71:     }

 73: #define ad_AD_CopyGrad(gz,gx) 
 74:     {
 75:         int iWiLlNeVeRCoNfLiCt0;
 76:         for (iWiLlNeVeRCoNfLiCt0 = 0 ; iWiLlNeVeRCoNfLiCt0 < ad_GRAD_MAX;
 77:              iWiLlNeVeRCoNfLiCt0++) {
 78:             gz[iWiLlNeVeRCoNfLiCt0] = gx[iWiLlNeVeRCoNfLiCt0];
 79:         }
 80:     }

 82: #   define ad_AD_GetTotalGradSize() ad_grad_size
 83: #   define ad_AD_SetTotalGradSize(x) ad_grad_size = x

 85: #   define ad_AD_IncrementTotalGradSize(x) 
 86:     {  87:          if (x + ad_grad_size_shadow > ad_GRAD_MAX) { 88:                 fprintf (stderr, "ad_AD_IncrementTotalGradSize() Error: the number of independent variables %d exceeds the max (GRAD_MAX)!n", x + ad_grad_size_shadow); 89:                 fflush(stderr);   90:                 abort();   91:         } 92:         ad_grad_size_shadow += x; 93:     }

 95: #   define ad_AD_ExtractGrad(a, var) 
 96:     {  97:         int pOsItIoN;  98:         for (pOsItIoN = 0; pOsItIoN < ad_grad_size; pOsItIoN++) { 99:             (a)[pOsItIoN] = DERIV_grad(var)[pOsItIoN];  100:         }101:     }
102: #   define ad_AD_ExtractVal(a, var) 
103:     { 104:         a = DERIV_val(var); 105:     }
106: #   define ad_AD_SetGrad(a, var) 
107:     { 108:         int pOsItIoN; 109:         for (pOsItIoN = 0; pOsItIoN < ad_grad_size; pOsItIoN++) {110:             DERIV_grad(var)[pOsItIoN] = (a)[pOsItIoN];  111:         }112:     }

114: #   define ad_AD_SetIndepDone() ad_AD_CommitShadowVar()
115: #   define ad_AD_ResetIndep() ad_AD_ResetShadowVar()
116: #   define ad_AD_SetIndep(var) 
117:     { 118:         int pOsItIoN = ad_AD_IncrShadowVar(); 119:         if (pOsItIoN > ad_GRAD_MAX) {120:             fprintf (stderr, "ad_AD_SetIndep() Error: the number of " 121:                      "independent variables %d exceeds the max (GRAD_MAX)!n",122:                      pOsItIoN); 123:             fflush(stderr);  124:             abort();  125:         }126:         ad_AD_ClearGrad(DERIV_grad(var)); 127:         DERIV_grad(var)[pOsItIoN] = 1; 128:     }
129: #   define ad_AD_SetIndepArray(vars, size) 
130:     { 131:         int iWiLlNeVeRCoNfLiCt; 132:         for (iWiLlNeVeRCoNfLiCt = 0; iWiLlNeVeRCoNfLiCt < size; 133:                iWiLlNeVeRCoNfLiCt++) { 134:             ad_AD_ClearGrad(DERIV_grad((vars)[iWiLlNeVeRCoNfLiCt])); 135:             DERIV_grad((vars)[iWiLlNeVeRCoNfLiCt])[ad_AD_IncrShadowVar()] = 1; 136:         } 137:     }

139: #   define ad_AD_SetIndepArrayElement(var, index) 
140:     { 141:        ad_AD_ClearGrad(DERIV_grad((var)[index])); 142:        DERIV_grad((var)[index])[ad_AD_IncrShadowVar()] = 1; 143:     }

145: #   define ad_AD_SetIndepArrayColored(vars, size, colors) 
146:     { 147:         int iWiLlNeVeRCoNfLiCt; 148:         for (iWiLlNeVeRCoNfLiCt = 0; iWiLlNeVeRCoNfLiCt < size; 149:                iWiLlNeVeRCoNfLiCt++) { 150:             ad_AD_ClearGrad2(DERIV_grad((vars)[iWiLlNeVeRCoNfLiCt])); 151:             DERIV_grad((vars)[iWiLlNeVeRCoNfLiCt])[ad_grad_size_shadow+(colors)[iWiLlNeVeRCoNfLiCt]] = 1; 152:         } 153:     }

155: /* values array is the same length as vars */
156: #   define ad_AD_SetIndepVector(vars, size, values) 
157:     { 158:         int iWiLlNeVeRCoNfLiCt; 159:         for (iWiLlNeVeRCoNfLiCt = 0; iWiLlNeVeRCoNfLiCt < size; 160:                iWiLlNeVeRCoNfLiCt++) { 161:             ad_AD_ClearGrad(DERIV_grad((vars)[iWiLlNeVeRCoNfLiCt])); 162:             DERIV_grad((vars)[iWiLlNeVeRCoNfLiCt])[ad_grad_size_shadow] = (values)[iWiLlNeVeRCoNfLiCt]; 163:         } 164:     }

166: #define ad_AD_SetValArray(vars, size, values) 
167:     { 
168:         int iWiLlNeVeRCoNfLiCt; 
169:         for (iWiLlNeVeRCoNfLiCt = 0; iWiLlNeVeRCoNfLiCt < size; 
170:                iWiLlNeVeRCoNfLiCt++) { 
171:             DERIV_val((vars)[iWiLlNeVeRCoNfLiCt]) = (values)[iWiLlNeVeRCoNfLiCt]; 
172:         } 
173:     }

175: extern int ad_AD_IncrShadowVar(void);
176: extern void ad_AD_CommitShadowVar(void);
177: extern void ad_AD_ResetShadowVar(void);


180: #   if defined(__cplusplus)
181:         }
182: #  endif
183: #endif /*AD_GRAD_H*/