source: trunk/ADOL-C/include/adolc/interfaces.h @ 372

Last change on this file since 372 was 372, checked in by kulshres, 8 years ago

Reintroduce the old method of hessian pattern propagation

This reintroduces the hessian pattern propagation code that was in
previous releases under new interfaces

nonl_ind_old_forward_t() and nonl_ind_old_forward_s()

The standard interfaces nonl_ind_forward_t() and nonl_ind_forward_s()
rely on a newer approach introduced by
Andrea Walther <andrea.wather@…> since May 2012

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

  • Property svn:keywords set to Author Date Id Revision
File size: 22.8 KB
Line 
1/*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File:     interfaces.h
4 Revision: $Id: interfaces.h 372 2012-12-07 12:24:46Z kulshres $
5 Contents: Declaration of the standard interfaces to ADOL-C forward and
6           reverse calls (C++, C and Fortran callable C functions).
7 
8           Functions prototyped here are defined in the files
9                 uni5_for.mc for
10                                 zos_forward.c
11                                 fos_forward.c
12                                 hos_forward.c
13                                 fov_forward.c
14                                 hov_forward.c
15                                 hov_wk_forward.c
16                 fo_rev.mc for
17                                 fos_reverse.c
18                                 fov_reverse.c
19                 ho_rev.mc for
20                                 hos_reverse.c
21                                 hos_ov_reverse.c
22                                 hov_reverse.c
23                                 hos_ti_reverse.c
24                                 hov_ti_reverse.c
25                 interfacesC.C
26                 interfacesf.c
27             
28           ADOL-C Abreviations :
29                 zos : zero-order-scalar mode   
30                 fos : first-order-scalar mode
31                 hos : higher-order-scalar mode
32                 fov : first-order-vector mode
33                 hov : higher-order-vector mode
34                 wk  : with keep
35                 ov  : over vector (forward)
36                 ti  : Taylor input
37 
38 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
39               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel
40 
41 This file is part of ADOL-C. This software is provided as open source.
42 Any use, reproduction, or distribution of the software constitutes
43 recipient's acceptance of the terms of the accompanying license file.
44 
45----------------------------------------------------------------------------*/
46#if !defined(ADOLC_INTERFACES_H)
47#define ADOLC_INTERFACES_H 1
48
49#include <adolc/common.h>
50
51#if defined(SPARSE)
52#include <adolc/sparse/sparsedrivers.h>
53#include <adolc/sparse/sparse_fo_rev.h>
54#endif
55
56/****************************************************************************/
57/****************************************************************************/
58/*                                                       Now the C++ THINGS */
59#if defined(__cplusplus)
60
61/****************************************************************************/
62/*                                           FORWARD MODE, overloaded calls */
63
64/*--------------------------------------------------------------------------*/
65/*    General scalar call. For d=0 or d=1 done by specialized code          */
66/*                                                                          */
67/* forward(tag, m, n, d, keep, X[n][d+1], Y[m][d+1]) : hos || fos || zos    */
68ADOLC_DLL_EXPORT int forward(short, int, int, int, int, double**, double**);
69
70/*--------------------------------------------------------------------------*/
71/*    Y can be one dimensional if m=1. d=0 or d=1 done by specialized code  */
72/*                                                                          */
73/* forward(tag, m, n, d, keep, X[n][d+1], Y[d+1]) : hos || fos || zos       */
74ADOLC_DLL_EXPORT int forward(short, int, int, int, int, double**, double*);
75
76/*--------------------------------------------------------------------------*/
77/*    X and Y can be one dimensional if d = 0; done by specialized code     */
78/*                                                                          */
79/* forward(tag, m, n, d, keep, X[n], Y[m]) : zos                            */
80ADOLC_DLL_EXPORT int forward(short, int, int, int, int, double*, double*);
81
82/*--------------------------------------------------------------------------*/
83/*    X and Y can be one dimensional if d omitted; done by specialized code */
84/*                                                                          */
85/* forward(tag, m, n, keep, X[n], Y[m]) : zos                               */
86ADOLC_DLL_EXPORT int forward(short, int, int, int, double*, double*);
87
88/*--------------------------------------------------------------------------*/
89/*  General vector call                                                     */
90/*                                                                          */
91/* forward(tag, m, n, d, p, x[n], X[n][p][d], y[m], Y[m][p][d]) : hov       */
92ADOLC_DLL_EXPORT int forward(short, int, int, int, int, double*, double***,
93                             double*, double***);
94
95/*--------------------------------------------------------------------------*/
96/*  d = 1 may be omitted. General vector call, done by specialized code     */
97/*                                                                          */
98/* forward(tag, m, n, p, x[n], X[n][p], y[m], Y[m][p]) : fov                */
99ADOLC_DLL_EXPORT int forward(
100    short, int, int, int, double*, double**, double*, double**);
101
102/****************************************************************************/
103/*                                           REVERSE MODE, overloaded calls */
104
105/*--------------------------------------------------------------------------*/
106/*  General call                                                            */
107/*                                                                          */
108/* reverse(tag, m, n, d, u[m], Z[n][d+1]) : hos                             */
109ADOLC_DLL_EXPORT int reverse(short, int, int, int, double*, double**);
110
111/*--------------------------------------------------------------------------*/
112/*    u can be a scalar if m=1                                              */
113/*                                                                          */
114/* reverse(tag, m, n, d, u, Z[n][d+1]) : hos                                */
115ADOLC_DLL_EXPORT int reverse(short, int, int, int, double, double**);
116
117/*--------------------------------------------------------------------------*/
118/*    Z can be vector if d = 0; done by specialized code                    */
119/*                                                                          */
120/* reverse(tag, m, n, d, u[m], Z[n]) : fos                                  */
121ADOLC_DLL_EXPORT int reverse(short, int, int, int, double*, double*);
122
123/*--------------------------------------------------------------------------*/
124/*    u can be a scalar if m=1 and d=0; done by specialized code            */
125/*                                                                          */
126/* reverse(tag, m, n, d, u, Z[n]) : fos                                     */
127ADOLC_DLL_EXPORT int reverse(short, int, int, int, double, double*);
128
129/*--------------------------------------------------------------------------*/
130/*  General vector call                                                     */
131/*                                                                          */
132/* reverse(tag, m, n, d, q, U[q][m], Z[q][n][d+1], nz[q][n]) : hov          */
133ADOLC_DLL_EXPORT int reverse(
134    short, int, int, int, int, double**, double***, short** =0);
135
136/*--------------------------------------------------------------------------*/
137/*    U can be a vector if m=1                                              */
138/*                                                                          */
139/* reverse(tag, m, n, d, q, U[q], Z[q][n][d+1], nz[q][n]) : hov             */
140ADOLC_DLL_EXPORT int reverse(
141    short, int, int, int, int, double*, double***, short** = 0);
142
143/*--------------------------------------------------------------------------*/
144/*                                                                          */
145/*    If d=0 then Z may be a matrix, no nz; done by specialized code        */
146/*                                                                          */
147/* reverse(tag, m, n, d, q, U[q][m], Z[q][n]) : fov                         */
148ADOLC_DLL_EXPORT int reverse(short, int, int, int, int, double**, double**);
149
150/*--------------------------------------------------------------------------*/
151/*                                                                          */
152/*    d=0 may be omitted, Z is a matrix, no nz; done by specialized code    */
153/*                                                                          */
154/* reverse(tag, m, n, q, U[q][m], Z[q][n]) : fov                            */
155ADOLC_DLL_EXPORT int reverse(short, int, int, int, double**, double**);
156
157/*--------------------------------------------------------------------------*/
158/*                                                                          */
159/*    If m=1 and d=0 then U can be vector and Z a matrix but no nz.         */
160/*    Done by specialized code                                              */
161/*                                                                          */
162/* reverse(tag, m, n, d, q, U[q], Z[q][n]) : fov                            */
163ADOLC_DLL_EXPORT int reverse(short, int, int, int, int, double*, double**);
164
165/*--------------------------------------------------------------------------*/
166/*                                                                          */
167/*    If q and U are omitted they default to m and I so that as above       */
168/*                                                                          */
169/* reverse(tag, m, n, d, Z[q][n][d+1], nz[q][n]) : hov                      */
170ADOLC_DLL_EXPORT int reverse(short, int, int, int, double***, short** =0);
171
172#endif
173
174/****************************************************************************/
175/****************************************************************************/
176/*                                                         Now the C THINGS */
177BEGIN_C_DECLS
178
179/****************************************************************************/
180/*                                                             FORWARD MODE */
181
182/*--------------------------------------------------------------------------*/
183/*                                                                      ZOS */
184/* zos_forward(tag, m, n, keep, x[n], y[m])                                 */
185/* (defined in uni5_for.mc)                                                 */
186ADOLC_DLL_EXPORT int zos_forward(short,int,int,int,const double*,double*);
187
188/* zos_forward_nk(tag, m, n, x[n], y[m])                                    */
189/* (no keep, defined in uni5_for.c, but not supported in ADOL-C 1.8)        */
190ADOLC_DLL_EXPORT int zos_forward_nk(short,int,int,double*,double*);
191
192/* zos_forward_partx(tag, m, n, ndim[n], x[n][d], y[m])                     */
193/* (based on zos_forward)                                                   */
194
195ADOLC_DLL_EXPORT int zos_forward_partx(short,int,int,int*,double**,double*);
196
197/*--------------------------------------------------------------------------*/
198/*                                                                      FOS */
199/* fos_forward(tag, m, n, keep, x[n], X[n], y[m], Y[m])                     */
200/* (defined in uni5_for.mc)                                                 */
201ADOLC_DLL_EXPORT int fos_forward(
202    short,int,int,int,const double*,double*,double*,double*);
203
204/* fos_forward_nk(tag,m,n,x[n],X[n],y[m],Y[m])                              */
205/* (no keep, defined in uni5_for.c, but not supported in ADOL-C 1.8)        */
206ADOLC_DLL_EXPORT int fos_forward_nk(
207    short,int,int,double*,double*,double*,double*);
208
209/* fos_forward_partx(tag, m, n, ndim[n], x[n][][2], y[m][2])                */
210/* (based on fos_forward)                                                   */
211ADOLC_DLL_EXPORT int fos_forward_partx(
212    short,int,int,int*,double***,double**);
213
214/*--------------------------------------------------------------------------*/
215/*                                                                      HOS */
216/* hos_forward(tag, m, n, d, keep, x[n], X[n][d], y[m], Y[m][d])            */
217/* (defined in uni5_for.mc)                                                 */
218ADOLC_DLL_EXPORT int hos_forward(
219    short,int,int,int,int,double*,double**,double*,double**);
220
221/* hos_forward_nk(tag, m, n, d, x[n], X[n][d], y[m], Y[m][d])               */
222/* (no keep, defined in uni5_for.c, but not supported in ADOL-C 1.8)        */
223ADOLC_DLL_EXPORT int hos_forward_nk(
224    short,int,int,int,double*,double**,double*,double**);
225
226/* hos_forward_partx(tag, m, n, ndim[n], d, X[n][d+1], Y[m][d+1])           */
227/* (defined in forward_partx.c)                                             */
228ADOLC_DLL_EXPORT int hos_forward_partx(
229    short,int,int,int*,int,double***,double**);
230
231/* now pack the arrays into vectors for Fortran calling                     */
232ADOLC_DLL_EXPORT fint hos_forward_(
233    fint*,fint*,fint*,fint*,fint*,fdouble*,fdouble*,fdouble*,fdouble*);
234
235/*--------------------------------------------------------------------------*/
236/*                                                                      FOV */
237/* fov_forward(tag, m, n, p, x[n], X[n][p], y[m], Y[m][p])                  */
238/* (defined in uni5_for.mc)                                                 */
239ADOLC_DLL_EXPORT int fov_forward(
240    short, int,int,int,const double*,double**,double*,double**);
241ADOLC_DLL_EXPORT int fov_offset_forward(
242    short, int,int,int,int,double*,double**,double*,double**);
243
244/* now pack the arrays into vectors for Fortran calling                     */
245ADOLC_DLL_EXPORT fint fov_forward_(
246    fint*,fint*,fint*,fint*,fdouble*,fdouble*,fdouble*,fdouble*);
247
248/*  fov_forward_partx(tag, m, n, ndim[n], p,                                */
249/*                    x[n][], X[n][][p],y[m], Y[m][p])                      */
250ADOLC_DLL_EXPORT int fov_forward_partx(
251    short, int, int, int*, int, double**, double***, double*, double**);
252
253/*--------------------------------------------------------------------------*/
254/*                                                                      HOV */
255/* hov_forward(tag, m, n, d, p, x[n], X[n][p][d], y[m], Y[m][p][d])         */
256/* (defined in uni5_for.mc)                                                 */
257ADOLC_DLL_EXPORT int hov_forward(
258    short,int,int,int,int,double*,double***,double*,double***);
259
260/* now pack the arrays into vectors for Fortran calling                     */
261ADOLC_DLL_EXPORT fint hov_forward_(
262    fint*,fint*,fint*,fint*,fint*,fdouble*,fdouble*,fdouble*,fdouble*);
263
264/*  hov_forward_partx(tag, m, n, ndim[n], d, p,                             */
265/*                    x[n][], X[n][][p][d], y[m], Y[m][p][d])               */
266ADOLC_DLL_EXPORT int hov_forward_partx(
267    short, int, int, int*, int, int,
268    double**, double****, double*, double***);
269
270/*--------------------------------------------------------------------------*/
271/*                                                                   HOV_WK */
272/* hov_wk_forward(tag, m, n, d, p, x[n], X[n][p][d], y[m], Y[m][p][d])      */
273/* (defined in uni5_for.mc)                                                 */
274ADOLC_DLL_EXPORT int hov_wk_forward(
275    short,int,int,int,int,int,double*,double***,double*,double***);
276
277/* now pack the arrays into vectors for Fortran calling                     */
278ADOLC_DLL_EXPORT fint hov_wk_forward_(
279    fint*,fint*,fint*,fint*,fint*,fint*,fdouble*,fdouble*,fdouble*,fdouble*);
280
281/****************************************************************************/
282/*                                                    BIT PATTERN UTILITIES */
283/*--------------------------------------------------------------------------*/
284/*                                                            INT_FOR, SAFE */
285/* int_forward_safe(tag, m, n, p, X[n][p], Y[m][p])                         */
286
287ADOLC_DLL_EXPORT int int_forward_safe
288(short, int, int, int, unsigned long int**, unsigned long int**);
289
290
291/*--------------------------------------------------------------------------*/
292/*                                                           INT_FOR, TIGHT */
293/* int_forward_tight(tag, m, n, p, x[n], X[n][p], y[m], Y[m][p])            */
294
295ADOLC_DLL_EXPORT int int_forward_tight
296(short, int, int, int, const double*, unsigned long int**, double*, unsigned long int**);
297
298/****************************************************************************/
299/*                                                   INDEX DOMAIN UTILITIES */
300/*--------------------------------------------------------------------------*/
301/*                                                            INDOPRO, SAFE */
302/* indopro_forward_safe(tag, m, n, p, x[n], *Y[m])                          */
303
304ADOLC_DLL_EXPORT int indopro_forward_safe
305(short, int, int, const double*, unsigned int**);
306
307
308/*--------------------------------------------------------------------------*/
309/*                                                           INDOPRO, TIGHT */
310/* indopro_forward_tight(tag, m, n,  x[n], *Y[m])                           */
311
312ADOLC_DLL_EXPORT int indopro_forward_tight
313(short, int, int, const double*, unsigned int**);
314
315/****************************************************************************/
316/*                                         NONLINEAR INDEX DOMAIN UTILITIES */
317/*--------------------------------------------------------------------------*/
318/*                                                            INDOPRO, SAFE */
319/* nonl_ind_forward_safe(tag, m, n, p, x[n], *Y[m])                          */
320
321ADOLC_DLL_EXPORT int nonl_ind_forward_safe
322(short, int, int, const double*, unsigned int**);
323
324
325/*--------------------------------------------------------------------------*/
326/*                                                           INDOPRO, TIGHT */
327/* nonl_ind_forward_tight(tag, m, n,  x[n], *Y[m])                           */
328
329ADOLC_DLL_EXPORT int nonl_ind_forward_tight
330(short, int, int, const double*, unsigned int**);
331/*--------------------------------------------------------------------------*/
332/*                                                            INDOPRO, SAFE */
333/* nonl_ind_old_forward_safe(tag, m, n, p, x[n], *Y[m])                          */
334
335ADOLC_DLL_EXPORT int nonl_ind_old_forward_safe
336(short, int, int, const double*, unsigned int**);
337
338
339/*--------------------------------------------------------------------------*/
340/*                                                           INDOPRO, TIGHT */
341/* nonl_ind_old_forward_tight(tag, m, n,  x[n], *Y[m])                           */
342
343ADOLC_DLL_EXPORT int nonl_ind_old_forward_tight
344(short, int, int, const double*, unsigned int**);
345
346/****************************************************************************/
347/*                                                             REVERSE MODE */
348
349/*--------------------------------------------------------------------------*/
350/*                                                                      FOS */
351/* fos_reverse(tag, m, n, u[m], z[n])                                       */
352/* (defined  in fo_rev.mc)                                                  */
353ADOLC_DLL_EXPORT int fos_reverse(short,int,int,double*,double*);
354
355/* now pack the arrays into vectors for Fortran calling                     */
356ADOLC_DLL_EXPORT fint fos_reverse_(fint*,fint*,fint*,fdouble*,fdouble*);
357
358/*--------------------------------------------------------------------------*/
359/*                                                                      HOS */
360/*  hos_reverse(tag, m, n, d, u[m], Z[n][d+1])                              */
361/* (defined  in ho_rev.mc)                                                  */
362ADOLC_DLL_EXPORT int hos_reverse(short,int,int,int,double*,double**);
363
364/* now pack the arrays into vectors for Fortran calling                     */
365ADOLC_DLL_EXPORT fint hos_reverse_(fint*,fint*,fint*,fint*,fdouble*,fdouble*);
366
367/*--------------------------------------------------------------------------*/
368/*                                                                   HOS_TI */
369/*  hos_ti_reverse(tag, m, n, d, U[m][d+1], Z[n][d+1])                      */
370/* (defined  in ho_rev.mc)                                                  */
371ADOLC_DLL_EXPORT int hos_ti_reverse(short,int,int,int,double**,double**);
372
373/* now pack the arrays into vectors for Fortran calling                     */
374ADOLC_DLL_EXPORT fint hos_ti_reverse_(
375    fint*,fint*,fint*,fint*,fdouble*,fdouble*);
376
377/*--------------------------------------------------------------------------*/
378/*                                                                   HOS_OV */
379/*  hos_ov_reverse(tag, m, n, d, u[m], Z[n][d+1])                           */
380/* (defined  in ho_rev.mc)                                                  */
381ADOLC_DLL_EXPORT int hos_ov_reverse(short,int,int,int,int,double**,double***);
382
383/* now pack the arrays into vectors for Fortran calling                     */
384ADOLC_DLL_EXPORT fint hos_ov_reverse_(
385    fint*,fint*,fint*,fint*,fint*,fdouble*,fdouble***);
386
387/*--------------------------------------------------------------------------*/
388/*                                                                      FOV */
389/* fov_reverse(tag, m, n, p, U[p][m], Z[p][n])                              */
390/* (defined  in fo_rev.mc)                                                  */
391ADOLC_DLL_EXPORT int fov_reverse(short,int,int,int,double**,double**);
392
393/* now pack the arrays into vectors for Fortran calling                     */
394ADOLC_DLL_EXPORT fint fov_reverse_(fint*,fint*,fint*,fint*,fdouble*,fdouble*);
395
396/*--------------------------------------------------------------------------*/
397/*                                                                      HOV */
398/* hov_reverse(tag, m, n, d, p, U[p][m], Z[p][n][d+1], nz[p][n])            */
399/* (defined  in ho_rev.mc)                                                  */
400ADOLC_DLL_EXPORT int hov_reverse(
401    short,int,int,int,int,double**,double***,short**);
402
403/* now pack the arrays into vectors for Fortran calling      */
404ADOLC_DLL_EXPORT fint hov_reverse_(
405    fint*,fint*,fint*,fint*,fint*,fdouble*,fdouble*);
406
407/*--------------------------------------------------------------------------*/
408/*                                                                   HOV_TI */
409/* hov_ti_reverse(tag, m, n, d, p, U[p][m][d+1], Z[p][n][d+1], nz[p][n])    */
410/* (defined  in ho_rev.mc)                                                  */
411ADOLC_DLL_EXPORT int hov_ti_reverse(
412    short,int,int,int,int,double***,double***,short**);
413
414/* now pack the arrays into vectors for Fortran calling      */
415ADOLC_DLL_EXPORT fint hov_ti_reverse_(
416    fint*,fint*,fint*,fint*,fint*,fdouble*,fdouble*);
417
418/****************************************************************************/
419/*                                                    BIT PATTERN UTILITIES */
420/*--------------------------------------------------------------------------*/
421/*                                                           INT_REV, TIGHT */
422/* int_reverse_tight(tag, m, n, q, U[q][m], Z[q][n])                        */
423
424ADOLC_DLL_EXPORT int int_reverse_tight
425(short, int, int, int, unsigned long int**, unsigned long int**);
426
427
428/*--------------------------------------------------------------------------*/
429/*                                                            INT_REV, SAFE */
430/* int_reverse_safe(tag, m, n, q, U[q][m], Z[q][n])                         */
431
432ADOLC_DLL_EXPORT int int_reverse_safe
433(short, int, int, int, unsigned long int**, unsigned long int**);
434
435END_C_DECLS
436
437#endif
Note: See TracBrowser for help on using the repository browser.