ADMB Documentation  -a65f1c97
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
df1b2prd.cpp
Go to the documentation of this file.
1 /*
2  * $Id$
3  *
4  * Author: David Fournier
5  * Copyright (c) 2008-2012 Regents of the University of California
6  */
11 #include <df1b2fun.h>
12 #ifndef OPT_LIB
13  #include <cassert>
14  #include <climits>
15 #endif
16 
21  df1b2variable operator * (const df1b2variable& _x,const df1b2variable& _y)
22  {
23  ADUNCONST(df1b2variable,x)
24  ADUNCONST(df1b2variable,y)
25  df1b2variable z;
26  double * xd=x.get_u_dot();
27  double * yd=y.get_u_dot();
28  double * zd=z.get_u_dot();
29  double xu=*x.get_u();
30  double yu=*y.get_u();
31 
32  *z.get_u()=xu*yu;
33 
34  for (unsigned int i=0;i<df1b2variable::nvar;i++)
35  {
36  *zd++ = yu * *xd++ + xu * *yd++;
37  }
38 
39  // WRITE WHATEVER ON TAPE
40  if (!df1b2_gradlist::no_derivatives)
41  f1b2gradlist->write_pass1_prod(&x,&y,&z);
42  return z;
43  }
44 
45 void ad_read_pass2_prod(void);
46 
51  int df1b2_gradlist::write_pass1_prod(const df1b2variable * _px,
52  const df1b2variable * _py,df1b2variable * pz)
53  {
54  ADUNCONST(df1b2variable*,px)
55  ADUNCONST(df1b2variable*,py)
56  ncount++;
57 #if defined(CHECK_COUNT)
58  if (ncount >= ncount_check)
59  cout << ncount << endl;
60 #endif
61  size_t nvar=df1b2variable::nvar;
62 
63  //int total_bytes=3*sizeof(df1b2_header)+sizeof(char*)
64  // +2*(nvar+1)*sizeof(double);
65  size_t total_bytes=3*sizeof(df1b2_header)
66  +2*(nvar+1)*sizeof(double);
67 // string identifier debug stuff
68 #if defined(SAFE_ALL)
69  char ids[]="DL";
70  size_t slen=strlen(ids);
71  total_bytes+=slen;
72 #endif
73 
74  list.check_buffer_size(total_bytes);
75  void * tmpptr=list.bptr;
76 #if defined(SAFE_ALL)
77  memcpy(list,ids,slen);
78 #endif
79 // end of string identifier debug stuff
80 
81  memcpy(list,(df1b2_header*)(px),sizeof(df1b2_header));
82  memcpy(list,(df1b2_header*)(py),sizeof(df1b2_header));
83  memcpy(list,(df1b2_header*)(pz),sizeof(df1b2_header));
84  //memcpy(list,&pf,sizeof(char *));
85  //*(char**)(list.bptr)=(char*)pf;
86  size_t sizeofdouble = sizeof(double);
87  memcpy(list,px->get_u(),sizeofdouble);
88  memcpy(list,py->get_u(),sizeofdouble);
89  memcpy(list,px->get_u_dot(),nvar*sizeofdouble);
90  memcpy(list,py->get_u_dot(),nvar*sizeofdouble);
91  // ***** write record size
92  nlist.bptr->numbytes=adptr_diff(list.bptr,tmpptr);
93  nlist.bptr->pf=(ADrfptr)(&ad_read_pass2_prod);
94  ++nlist;
95  return 0;
96  }
97 
98 
99 void read_pass2_1_prod(void);
100 void read_pass2_2_prod(void);
101 void read_pass2_3_prod(void);
102 
107 void ad_read_pass2_prod(void)
108 {
109  switch(df1b2variable::passnumber)
110  {
111  case 1:
112  read_pass2_1_prod();
113  break;
114  case 2:
115  read_pass2_2_prod();
116  break;
117  case 3:
118  read_pass2_3_prod();
119  break;
120  default:
121  cerr << "illegal value for df1b2variable::pass = "
122  << df1b2variable::passnumber << endl;
123  ad_exit(1);
124  }
125 }
126 
131 void read_pass2_1_prod(void)
132 {
133  // We are going backword for bptr and nbptr
134  // and forward for bptr2 and nbptr2
135  // the current entry+2 in bptr is the size of the record i.e
136  // points to the next record
137  //char * bptr=f1b2gradlist->bptr;
138  //char * bptr2=f1b2gradlist2->bptr;
139  size_t nvar=df1b2variable::nvar;
140  test_smartlist& list=f1b2gradlist->list;
141  //f1b2gradlist->nlist-=sizeof(int);
142  int num_bytes=f1b2gradlist->nlist.bptr->numbytes;
143  list-=num_bytes;
144  list.saveposition(); // save pointer to beginning of record;
145  double xu,yu;
146  //ad_dstar xdot,ydot;
147  //df1b2function2 * pf;
148 
149  // get info from tape1
150 #if defined(SAFE_ALL)
151  checkidentiferstring("DL",f1b2gradlist->list);
152 #endif
153  char * bptr=f1b2gradlist->list.bptr;
154  df1b2_header * px=(df1b2_header *) bptr;
155  bptr+=sizeof(df1b2_header);
156  df1b2_header * py=(df1b2_header *) bptr;
157  bptr+=sizeof(df1b2_header);
158  df1b2_header * pz=(df1b2_header *) bptr;
159  bptr+=sizeof(df1b2_header);
160  //pf=*(df1b2function2 **) bptr;
161  //bptr+=sizeof(char*);
162  constexpr size_t sizeofdouble = sizeof(double);
163  size_t total_bytes=2*nvar*sizeofdouble;
164  memcpy(&xu,bptr,sizeofdouble);
165  bptr+=sizeofdouble;
166  memcpy(&yu,bptr,sizeofdouble);
167  bptr+=sizeofdouble;
168  double * xdot=(double*)bptr;
169  bptr+=nvar*sizeofdouble;
170  double * ydot=(double*)bptr;
171 
172  list.restoreposition(); // save pointer to beginning of record;
173 
174  // ****************************************************************
175  // turn this off if no third derivatives are calculated
176  // if (!no_third_derivatives)
177  // {
178  // save for second reverse pass
179  // save identifier 1
180  test_smartlist & list2 = f1b2gradlist->list2;
181 
182 // string identifier debug stuff
183 #if defined(SAFE_ALL)
184  char ids[]="QK";
185  size_t slen=strlen(ids);
186  total_bytes+=slen;
187 #endif
188 
189  list2.check_buffer_size(total_bytes);
190 
191  void * tmpptr=list2.bptr;
192 #if defined(SAFE_ALL)
193  memcpy(list2,ids,slen);
194 #endif
195 
196  fixed_smartlist2 & nlist2 = f1b2gradlist->nlist2;
197  memcpy(list2,pz->get_u_bar(),nvar*sizeofdouble);
198  memcpy(list2,pz->get_u_dot_bar(),nvar*sizeofdouble);
199  *nlist2.bptr=adptr_diff(list2.bptr,tmpptr);
200  ++nlist2;
201 
202  // Do first reverse pass calculations
203  double* px_u_bari = px->u_bar;
204  double* pz_u_bari = pz->u_bar;
205  for (size_t i=0;i<nvar;i++)
206  {
207  //px->u_bar[i]+=(pf->df1)(xu,yu)*pz->u_bar[i];
208  *px_u_bari += yu * *pz_u_bari;
209  ++px_u_bari;
210  ++pz_u_bari;
211  }
212  double* py_u_bari = py->u_bar;
213  pz_u_bari = pz->u_bar;
214  for (size_t i=0;i<nvar;i++)
215  {
216  //py->u_bar[i]+=(pf->df2)(xu,yu)*pz->u_bar[i];
217  *py_u_bari += xu * *pz_u_bari;
218  ++py_u_bari;
219  ++pz_u_bari;
220  }
221 
222  px_u_bari = px->u_bar;
223  double* pz_u_dot_bari = pz->u_dot_bar;
224  double* ydoti = ydot;
225  for (size_t i=0;i<nvar;i++)
226  {
227  //px->u_bar[i]+=(pf->d2f11)(xu,yu)*xdot[i]*pz->u_dot_bar[i];
228  //px->u_bar[i]+=(pf->d2f12)(xu,yu)*ydot[i]*pz->u_dot_bar[i];
229  *px_u_bari += *ydoti * *pz_u_dot_bari;
230  ++px_u_bari;
231  ++pz_u_dot_bari;
232  ++ydoti;
233  }
234 
235  py_u_bari = py->u_bar;
236  double* xdoti = xdot;
237  pz_u_dot_bari = pz->u_dot_bar;
238  for (size_t i=0;i<nvar;i++)
239  {
240  //py->u_bar[i]+=(pf->d2f22)(xu,yu)*ydot[i]*pz->u_dot_bar[i];
241  //py->u_bar[i]+=(pf->d2f12)(xu,yu)*xdot[i]*pz->u_dot_bar[i];
242  *py_u_bari += *xdoti * *pz_u_dot_bari;
243 
244  ++py_u_bari;
245  ++xdoti;
246  ++pz_u_dot_bari;
247  }
248  double* px_u_dot_bari = px->u_dot_bar;
249  pz_u_dot_bari = pz->u_dot_bar;
250  for (size_t i=0;i<nvar;i++)
251  {
252  //px->u_dot_bar[i]+=(pf->df1)(xu,yu)*pz->u_dot_bar[i];
253  *px_u_dot_bari += yu * *pz_u_dot_bari;
254 
255  ++px_u_dot_bari;
256  ++pz_u_dot_bari;
257  }
258  double* py_u_dot_bari = py->u_dot_bar;
259  pz_u_dot_bari = pz->u_dot_bar;
260  for (size_t i=0;i<nvar;i++)
261  {
262  //py->u_dot_bar[i]+=(pf->df2)(xu,yu)*pz->u_dot_bar[i];
263  *py_u_dot_bari += xu * *pz_u_dot_bari;
264  ++py_u_dot_bari;
265  ++pz_u_dot_bari;
266  }
267 
268  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
269  memset(pz->u_bar, 0, nvar * sizeofdouble);
270  memset(pz->u_dot_bar, 0, nvar * sizeofdouble);
271 }
272 
277 void read_pass2_2_prod(void)
278 {
279  //const int nlist_record_size=sizeof(int)+sizeof(char*);
280  // We are going forward for bptr and backword for bptr2
281  //
282  // list 1
283  //
284  unsigned int nvar=df1b2variable::nvar;
285  test_smartlist & list=f1b2gradlist->list;
286 
287  constexpr size_t sizeofdouble = sizeof(double);
288  //int total_bytes=3*sizeof(df1b2_header)+sizeof(char*)
289  // +2*(nvar+1)*sizeof(double);
290  size_t total_bytes=3*sizeof(df1b2_header)
291  +2*(nvar+1)*sizeofdouble;
292 // string identifier debug stuff
293 #if defined(SAFE_ALL)
294  char ids[]="DL";
295  size_t slen=strlen(ids);
296  total_bytes+=slen;
297 #endif
298 
299  list.check_buffer_size(total_bytes);
300 // end of string identifier debug stuff
301 
302  list.saveposition(); // save pointer to beginning of record;
303  fixed_smartlist & nlist=f1b2gradlist->nlist;
304  // nlist-=sizeof(int);
305  // get record size
306  int num_bytes=nlist.bptr->numbytes;
307  //
308  // list 2
309  //
310  test_smartlist & list2=f1b2gradlist->list2;
311  fixed_smartlist2 & nlist2=f1b2gradlist->nlist2;
312  // get record size
313  int num_bytes2=*nlist2.bptr;
314  --nlist2;
315  // backup the size of the record
316  list2-=num_bytes2;
317  list2.saveposition(); // save pointer to beginning of record;
318  // save the pointer to the beginning of the record
319  // bptr and bptr2 now both point to the beginning of their records
320 
321  double xu,yu;
322  double * xdot;
323  double * ydot;
324  //df1b2_header x,z;
325  //df1b2function2 * pf;
326 
327  // get info from tape1
328  // get info from tape1
329 #if defined(SAFE_ALL)
330  checkidentiferstring("DL",list);
331  checkidentiferstring("QK",list2);
332 #endif
333  df1b2_header * px=(df1b2_header *) list.bptr;
334  list.bptr+=sizeof(df1b2_header);
335  df1b2_header * py=(df1b2_header *) list.bptr;
336  list.bptr+=sizeof(df1b2_header);
337  df1b2_header * pz=(df1b2_header *) list.bptr;
338  list.bptr+=sizeof(df1b2_header);
339  //pf=*(df1b2function2 **) list.bptr;
340  //list.bptr+=sizeof(char*);
341  memcpy(&xu,list.bptr,sizeofdouble);
342  list.bptr+=sizeof(double);
343  memcpy(&yu,list.bptr,sizeofdouble);
344  list.bptr+=sizeof(double);
345  xdot=(double*)list.bptr;
346  list.bptr+=nvar*sizeofdouble;
347  ydot=(double*)list.bptr;
348  list.restoreposition(num_bytes); // save pointer to beginning of record;
349 
350  double * zbar;
351  double * zdotbar;
352 
353  zbar=(double*)list2.bptr;
354  zdotbar=(double*)(list2.bptr+nvar*sizeof(double));
355  list2.restoreposition(); // save pointer to beginning of record;
356 
357  double * x_tilde=px->get_u_tilde();
358  double * x_dot_tilde=px->get_u_dot_tilde();
359  double * x_bar_tilde=px->get_u_bar_tilde();
360  double * x_dot_bar_tilde=px->get_u_dot_bar_tilde();
361  double * y_tilde=py->get_u_tilde();
362  double * y_dot_tilde=py->get_u_dot_tilde();
363  double * y_bar_tilde=py->get_u_bar_tilde();
364  double * y_dot_bar_tilde=py->get_u_dot_bar_tilde();
365  double * z_bar_tilde=pz->get_u_bar_tilde();
366  double * z_dot_bar_tilde=pz->get_u_dot_bar_tilde();
367  // Do second "reverse-reverse" pass calculations
368 
369  memset(z_bar_tilde, 0, nvar * sizeofdouble);
370  memset(z_dot_bar_tilde, 0, nvar * sizeofdouble);
371 
372  // start with x and add y
373  double* x_bar_tildei = x_bar_tilde;
374  double* zbari = zbar;
375  double* z_bar_tildei = z_bar_tilde;
376  for (size_t i=0;i<nvar;i++)
377  {
378  //*x_tilde+=(pf->d2f11)(xu,yu)*zbar[i]*x_bar_tilde[i];
379  //z_bar_tilde[i]+=(pf->df1)(xu,yu)*x_bar_tilde[i];
380  //*y_tilde+=(pf->d2f12)(xu,yu)*zbar[i]*x_bar_tilde[i];
381  *z_bar_tildei += yu * *x_bar_tildei;
382  *y_tilde += *zbari * *x_bar_tildei;
383 
384  ++x_bar_tildei;
385  ++zbari;
386  ++z_bar_tildei;
387  }
388  double* x_dot_bar_tildei = x_dot_bar_tilde;
389  double* zdotbari = zdotbar;
390  double* z_dot_bar_tildei = z_dot_bar_tilde;
391  for (size_t i=0;i<nvar;i++)
392  {
393  //*x_tilde+=(pf->d2f11)(xu,yu)*zdotbar[i]*x_dot_bar_tilde[i];
394  //*y_tilde+=(pf->d2f12)(xu,yu)*zdotbar[i]*x_dot_bar_tilde[i];
395  //z_dot_bar_tilde[i]+=(pf->df1)(xu,yu)*x_dot_bar_tilde[i];
396  *y_tilde += *zdotbari * *x_dot_bar_tildei;
397  *z_dot_bar_tildei += yu * *x_dot_bar_tildei;
398 
399  ++x_dot_bar_tildei;
400  ++zdotbari;
401  ++z_dot_bar_tildei;
402  }
403 
404  /*
405  for (i=0;i<nvar;i++)
406  {
407  x_dot_tilde[i]+=(pf->d2f11)(xu,yu)*zdotbar[i]*x_bar_tilde[i];
408  z_dot_bar_tilde[i]+=(pf->d2f11)(xu,yu)*xdot[i]*x_bar_tilde[i];
409  *x_tilde+=(pf->d3f111)(xu,yu)*xdot[i]*zdotbar[i]*x_bar_tilde[i];
410  *y_tilde+=(pf->d3f112)(xu,yu)*xdot[i]*zdotbar[i]*x_bar_tilde[i];
411  }
412  */
413  // start with y and add x
414  double* y_bar_tildei = y_bar_tilde;
415  zbari = zbar;
416  z_bar_tildei = z_bar_tilde;
417  for (size_t i=0;i<nvar;i++)
418  {
419  //*y_tilde+=(pf->d2f22)(xu,yu)*zbar[i]*y_bar_tilde[i];
420  //*x_tilde+=(pf->d2f12)(xu,yu)*zbar[i]*y_bar_tilde[i];
421  //z_bar_tilde[i]+=(pf->df2)(xu,yu)*y_bar_tilde[i];
422  *x_tilde += *zbari * *y_bar_tildei;
423  *z_bar_tildei += xu * *y_bar_tildei;
424 
425  ++y_bar_tildei;
426  ++zbari;
427  ++z_bar_tildei;
428  }
429  double* y_dot_bar_tildei = y_dot_bar_tilde;
430  zdotbari = zdotbar;
431  z_dot_bar_tildei = z_dot_bar_tilde;
432  for (size_t i=0;i<nvar;i++)
433  {
434  //*y_tilde+=(pf->d2f22)(xu,yu)*zdotbar[i]*y_dot_bar_tilde[i];
435  //*x_tilde+=(pf->d2f12)(xu,yu)*zdotbar[i]*y_dot_bar_tilde[i];
436  //z_dot_bar_tilde[i]+=(pf->df2)(xu,yu)*y_dot_bar_tilde[i];
437  *x_tilde += *zdotbari * *y_dot_bar_tildei;
438  *z_dot_bar_tildei += xu * *y_dot_bar_tildei;
439 
440  ++y_dot_bar_tildei;
441  ++zdotbari;
442  ++z_dot_bar_tildei;
443  }
444  /*
445  for (i=0;i<nvar;i++)
446  {
447  y_dot_tilde[i]+=(pf->d2f22)(xu,yu)*zdotbar[i]*y_bar_tilde[i];
448  z_dot_bar_tilde[i]+=(pf->d2f22)(xu,yu)*ydot[i]*y_bar_tilde[i];
449  *y_tilde+=(pf->d3f222)(xu,yu)*ydot[i]*zdotbar[i]*y_bar_tilde[i];
450  *x_tilde+=(pf->d3f122)(xu,yu)*ydot[i]*zdotbar[i]*y_bar_tilde[i];
451  }
452  */
453  x_bar_tildei = x_bar_tilde;
454  zdotbari = zdotbar;
455  double* ydoti = ydot;
456  double* y_dot_tildei = y_dot_tilde;
457  z_dot_bar_tildei = z_dot_bar_tilde;
458  for (size_t i=0;i<nvar;i++)
459  {
460  //*x_tilde+=(pf->d3f112)(xu,yu)*ydot[i]*zdotbar[i]*x_bar_tilde[i];
461  //*y_tilde+=(pf->d3f122)(xu,yu)*ydot[i]*zdotbar[i]*x_bar_tilde[i];
462  //y_dot_tilde[i]+=(pf->d2f12)(xu,yu)*zdotbar[i]*x_bar_tilde[i];
463  //z_dot_bar_tilde[i]+=(pf->d2f12)(xu,yu)*ydot[i]*x_bar_tilde[i];
464  *y_dot_tildei += *zdotbari * *x_bar_tildei;
465  *z_dot_bar_tildei += *ydoti * *x_bar_tildei;
466 
467  ++x_bar_tildei;
468  ++zdotbari;
469  ++ydoti;
470  ++y_dot_tildei;
471  ++z_dot_bar_tildei;
472  }
473  y_bar_tildei = y_bar_tilde;
474  double* xdoti = xdot;
475  zdotbari = zdotbar;
476  double* x_dot_tildei = x_dot_tilde;
477  z_dot_bar_tildei = z_dot_bar_tilde;
478  for (size_t i=0;i<nvar;i++)
479  {
480  //*x_tilde+=(pf->d3f112)(xu,yu)*xdot[i]*zdotbar[i]*y_bar_tilde[i];
481  //*y_tilde+=(pf->d3f122)(xu,yu)*xdot[i]*zdotbar[i]*y_bar_tilde[i];
482  //x_dot_tilde[i]+=(pf->d2f12)(xu,yu)*zdotbar[i]*y_bar_tilde[i];
483  //z_dot_bar_tilde[i]+=(pf->d2f12)(xu,yu)*xdot[i]*y_bar_tilde[i];
484  *x_dot_tildei += *zdotbari * *y_bar_tildei;
485  *z_dot_bar_tildei += *xdoti * *y_bar_tildei;
486 
487  ++y_bar_tildei;
488  ++xdoti;
489  ++zdotbari;
490  ++x_dot_tildei;
491  ++z_dot_bar_tildei;
492  }
493 }
494 
499 void read_pass2_3_prod(void)
500 {
501  // We are going backword for bptr and forward for bptr2
502  // the current entry+2 in bptr is the size of the record i.e
503  // points to the next record
504  unsigned int nvar=df1b2variable::nvar;
505  fixed_smartlist & nlist=f1b2gradlist->nlist;
506  test_smartlist& list=f1b2gradlist->list;
507  // nlist-=sizeof(int);
508  // get record size
509  int num_bytes=nlist.bptr->numbytes;
510  // backup the size of the record
511  list-=num_bytes;
512  list.saveposition(); // save pointer to beginning of record;
513  // save the pointer to the beginning of the record
514  double xu;
515  double yu;
516  double * xdot;
517  double * ydot;
518  //df1b2_header x,z;
519  //df1b2function2 * pf;
520 
521  // get info from tape1
522  // get info from tape1
523 #if defined(SAFE_ALL)
524  checkidentiferstring("DL",list);
525 #endif
526  df1b2_header * px=(df1b2_header *) list.bptr;
527  list.bptr+=sizeof(df1b2_header);
528  df1b2_header * py=(df1b2_header *) list.bptr;
529  list.bptr+=sizeof(df1b2_header);
530  df1b2_header * pz=(df1b2_header *) list.bptr;
531  list.bptr+=sizeof(df1b2_header);
532  //pf=*(df1b2function2 **) list.bptr;
533  //list.bptr+=sizeof(char*);
534  constexpr size_t sizeofdouble = sizeof(double);
535  memcpy(&xu,list.bptr,sizeofdouble);
536  list.bptr+=sizeofdouble;
537  memcpy(&yu,list.bptr,sizeofdouble);
538  list.bptr+=sizeofdouble;
539  xdot=(double*)list.bptr;
540  list.bptr+=nvar*sizeofdouble;
541  ydot=(double*)list.bptr;
542  list.restoreposition(); // save pointer to beginning of record;
543 
544  //*(px->u_tilde)+=(pf->df1)(xu,yu)* *(pz->u_tilde);
545  //*(py->u_tilde)+=(pf->df2)(xu,yu)* *(pz->u_tilde);
546  *(px->u_tilde)+=yu* *(pz->u_tilde);
547  *(py->u_tilde)+=xu* *(pz->u_tilde);
548 
549  double* pz_u_dot_tildei = pz->u_dot_tilde;
550  double* xdoti = xdot;
551  double* ydoti = ydot;
552  for (size_t i=0;i<nvar;i++)
553  {
554  //*(px->u_tilde)+=(pf->d2f11)(xu,yu)*xdot[i]*pz->u_dot_tilde[i];
555  //*(py->u_tilde)+=(pf->d2f12)(xu,yu)*xdot[i]*pz->u_dot_tilde[i];
556  *(py->u_tilde) += *xdoti * *pz_u_dot_tildei;
557  //*(py->u_tilde)+=(pf->d2f22)(xu,yu)*ydot[i]*pz->u_dot_tilde[i];
558  //*(px->u_tilde)+=(pf->d2f12)(xu,yu)*ydot[i]*pz->u_dot_tilde[i];
559  *(px->u_tilde) += *ydoti * *pz_u_dot_tildei;
560 
561  ++pz_u_dot_tildei;
562  ++xdoti;
563  ++ydoti;
564  }
565  double* px_u_dot_tildei = px->u_dot_tilde;
566  double* py_u_dot_tildei = py->u_dot_tilde;
567  pz_u_dot_tildei = pz->u_dot_tilde;
568  for (size_t i=0;i<nvar;i++)
569  {
570  //px->u_dot_tilde[i]+=(pf->df1)(xu,yu)*pz->u_dot_tilde[i];
571  //py->u_dot_tilde[i]+=(pf->df2)(xu,yu)*pz->u_dot_tilde[i];
572  *px_u_dot_tildei += yu * *pz_u_dot_tildei;
573  *py_u_dot_tildei += xu * *pz_u_dot_tildei;
574 
575  ++px_u_dot_tildei;
576  ++py_u_dot_tildei;
577  ++pz_u_dot_tildei;
578  }
579  *(pz->u_tilde)=0;
580  memset(pz->u_dot_tilde, 0, nvar * sizeofdouble);
581 }
test_smartlist::bptr
char * bptr
Definition: df1b2fun.h:543
df1b2_header::get_u_bar_tilde
double * get_u_bar_tilde() const
Definition: df1b2fun.h:234
test_smartlist::check_buffer_size
void check_buffer_size(const size_t)
Description not yet available.
Definition: df1b2f10.cpp:185
f1b2gradlist
df1b2_gradlist * f1b2gradlist
Definition: df1b2glo.cpp:49
df1b2_gradlist::ncount
int ncount
Definition: df1b2fun.h:752
memcpy
void memcpy(test_smartlist &dest, void *source, const size_t nsize)
memcpy for test_smartlist
Definition: df1b2f10.cpp:367
read_pass2_3_prod
void read_pass2_3_prod(void)
Description not yet available.
Definition: df1b2prd.cpp:499
df1b2_header::u_bar
double * u_bar
Definition: df1b2fun.h:197
df1b2_header::get_u
double * get_u() const
Definition: df1b2fun.h:228
x
#define x
ADUNCONST
#define ADUNCONST(type, obj)
Creates a shallow copy of obj that is not CONST.
Definition: fvar.hpp:140
df1b2variable::passnumber
static int passnumber
Definition: df1b2fun.h:289
df1b2_header::get_u_dot_tilde
double * get_u_dot_tilde() const
Definition: df1b2fun.h:233
adptr_diff
int adptr_diff(void *x, void *y)
Definition: df1b2fn2.cpp:110
ad_exit
exitptr ad_exit
Definition: gradstrc.cpp:53
df1b2_header::u_tilde
double * u_tilde
Definition: df1b2fun.h:199
test_smartlist::restoreposition
void restoreposition(void)
Definition: df1b2fun.h:560
df1b2variable
Description not yet available.
Definition: df1b2fun.h:266
fixed_smartlist2
Description not yet available.
Definition: df1b2fun.h:669
operator*
dmatrix operator*(const d3_array &t, const dvector &v)
Description not yet available.
Definition: d3arr12.cpp:17
df1b2_gradlist::nlist
fixed_smartlist nlist
Definition: df1b2fun.h:754
df1b2_header::get_u_dot
double * get_u_dot() const
Definition: df1b2fun.h:229
df1b2_gradlist::write_pass1_prod
int write_pass1_prod(double x, const df1b2variable *py, df1b2variable *pz)
Description not yet available.
Definition: df1b2prc.cpp:65
fixed_smartlist
Description not yet available.
Definition: df1b2fun.h:602
endl
prnstream & endl(prnstream &)
df1b2_header::u_dot_bar
double * u_dot_bar
Definition: df1b2fun.h:198
df1b2_gradlist::list
test_smartlist list
Definition: df1b2fun.h:753
read_pass2_2_prod
void read_pass2_2_prod(void)
Description not yet available.
Definition: df1b2prd.cpp:277
fixed_smartlist2::bptr
int * bptr
Definition: df1b2fun.h:693
fixed_list_entry::pf
ADrfptr pf
Definition: df1b2fun.h:595
df1b2_gradlist::no_derivatives
static int no_derivatives
Definition: df1b2fun.h:759
df1b2_gradlist::nlist2
fixed_smartlist2 nlist2
Definition: df1b2fun.h:756
read_pass2_1_prod
void read_pass2_1_prod(void)
Description not yet available.
Definition: df1b2prd.cpp:131
test_smartlist
Description not yet available.
Definition: df1b2fun.h:527
df1b2_header::get_u_dot_bar
double * get_u_dot_bar() const
Definition: df1b2fun.h:231
df1b2_header::get_u_tilde
double * get_u_tilde() const
Definition: df1b2fun.h:232
df1b2_header::get_u_dot_bar_tilde
double * get_u_dot_bar_tilde() const
Definition: df1b2fun.h:235
ad_read_pass2_prod
void ad_read_pass2_prod(void)
Description not yet available.
Definition: df1b2prd.cpp:107
df1b2variable::nvar
static unsigned int nvar
Definition: df1b2fun.h:290
ADrfptr
void(* ADrfptr)(void)
Definition: df1b2fun.cpp:139
df1b2_header::u_dot_tilde
double * u_dot_tilde
Definition: df1b2fun.h:200
df1b2_header
Base class for df1b2variable.
Definition: df1b2fun.h:191
df1b2fun.h
Description not yet available.
fixed_smartlist::bptr
fixed_list_entry * bptr
Definition: df1b2fun.h:626
checkidentiferstring
void checkidentiferstring(const char *ids, test_smartlist &list)
Description not yet available.
Definition: df1b2fn5.cpp:256
df1b2_header::get_u_bar
double * get_u_bar() const
Definition: df1b2fun.h:230
fixed_list_entry::numbytes
int numbytes
Definition: df1b2fun.h:594
test_smartlist::saveposition
void saveposition(void)
Definition: df1b2fun.h:552
df1b2_gradlist::list2
test_smartlist list2
Definition: df1b2fun.h:755
ADMB Generated on Wed Sep 7 2022 00:01:27 for ADMB Documentation by doxygen 1.8.5