ADOL-C: Automatic Differentiation in C/C++ 2.7.3
Loading...
Searching...
No Matches
interfaces.h
Go to the documentation of this file.
1/*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File: interfaces.h
4 Revision: $Id$
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.cpp for
10 zos_forward.cpp
11 fos_forward.cpp
12 hos_forward.cpp
13 fov_forward.cpp
14 hov_forward.cpp
15 hov_wk_forward.cpp
16 fo_rev.cpp for
17 fos_reverse.cpp
18 fov_reverse.cpp
19 ho_rev.cpp for
20 hos_reverse.cpp
21 hos_ov_reverse.cpp
22 hov_reverse.cpp
23 hos_ti_reverse.cpp
24 hov_ti_reverse.cpp
25 interfacesc.cpp
26 interfacesf.cpp
27
28 ADOL-C Abbreviations :
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/adolcexport.h>
50#include <adolc/internal/common.h>
51
52/****************************************************************************/
53/****************************************************************************/
54/* Now the C++ THINGS */
55#if defined(__cplusplus)
56
57/****************************************************************************/
58/* FORWARD MODE, overloaded calls */
59
60/*--------------------------------------------------------------------------*/
61/* General scalar call. For d=0 or d=1 done by specialized code */
62/* */
63/* forward(tag, m, n, d, keep, X[n][d+1], Y[m][d+1]) : hos || fos || zos */
64ADOLC_API int forward(short, int, int, int, int, double **, double **);
65
66/*--------------------------------------------------------------------------*/
67/* Y can be one dimensional if m=1. d=0 or d=1 done by specialized code */
68/* */
69/* forward(tag, m, n, d, keep, X[n][d+1], Y[d+1]) : hos || fos || zos */
70ADOLC_API int forward(short, int, int, int, int, double **, double *);
71
72/*--------------------------------------------------------------------------*/
73/* X and Y can be one dimensional if d = 0; done by specialized code */
74/* */
75/* forward(tag, m, n, d, keep, X[n], Y[m]) : zos */
76ADOLC_API int forward(short, int, int, int, int, const double *, double *);
77
78/*--------------------------------------------------------------------------*/
79/* X and Y can be one dimensional if d omitted; done by specialized code */
80/* */
81/* forward(tag, m, n, keep, X[n], Y[m]) : zos */
82ADOLC_API int forward(short, int, int, int, const double *, double *);
83
84/*--------------------------------------------------------------------------*/
85/* General vector call */
86/* */
87/* forward(tag, m, n, d, p, x[n], X[n][p][d], y[m], Y[m][p][d]) : hov */
88ADOLC_API int forward(short, int, int, int, int, const double *,
89 const double *const *const *, double *, double ***);
90
91/*--------------------------------------------------------------------------*/
92/* d = 1 may be omitted. General vector call, done by specialized code */
93/* */
94/* forward(tag, m, n, p, x[n], X[n][p], y[m], Y[m][p]) : fov */
95ADOLC_API int forward(short, int, int, int, const double *,
96 const double *const *, double *, double **);
97
98/****************************************************************************/
99/* REVERSE MODE, overloaded calls */
100
101/*--------------------------------------------------------------------------*/
102/* General call */
103/* */
104/* reverse(tag, m, n, d, u[m], Z[n][d+1]) : hos */
105ADOLC_API int reverse(short, int, int, int, const double *, double **);
106
107/*--------------------------------------------------------------------------*/
108/* u can be a scalar if m=1 */
109/* */
110/* reverse(tag, m, n, d, u, Z[n][d+1]) : hos */
111ADOLC_API int reverse(short, int, int, int, double, double **);
112
113/*--------------------------------------------------------------------------*/
114/* Z can be vector if d = 0; done by specialized code */
115/* */
116/* reverse(tag, m, n, d, u[m], Z[n]) : fos */
117ADOLC_API int reverse(short, int, int, int, const double *, double *);
118
119/*--------------------------------------------------------------------------*/
120/* u can be a scalar if m=1 and d=0; done by specialized code */
121/* */
122/* reverse(tag, m, n, d, u, Z[n]) : fos */
123ADOLC_API int reverse(short, int, int, int, double, double *);
124
125/*--------------------------------------------------------------------------*/
126/* General vector call */
127/* */
128/* reverse(tag, m, n, d, q, U[q][m], Z[q][n][d+1], nz[q][n]) : hov */
129ADOLC_API int reverse(short, int, int, int, int, const double *const *,
130 double ***, short ** = nullptr);
131
132/*--------------------------------------------------------------------------*/
133/* U can be a vector if m=1 */
134/* */
135/* reverse(tag, m, n, d, q, U[q], Z[q][n][d+1], nz[q][n]) : hov */
136ADOLC_API int reverse(short, int, int, int, int, double *, double ***,
137 short ** = nullptr);
138
139/*--------------------------------------------------------------------------*/
140/* */
141/* If d=0 then Z may be a matrix, no nz; done by specialized code */
142/* */
143/* reverse(tag, m, n, d, q, U[q][m], Z[q][n]) : fov */
144ADOLC_API int reverse(short, int, int, int, int, const double *const *,
145 double **);
146
147/*--------------------------------------------------------------------------*/
148/* */
149/* d=0 may be omitted, Z is a matrix, no nz; done by specialized code */
150/* */
151/* reverse(tag, m, n, q, U[q][m], Z[q][n]) : fov */
152ADOLC_API int reverse(short, int, int, int, const double *const *, double **);
153
154/*--------------------------------------------------------------------------*/
155/* */
156/* If m=1 and d=0 then U can be vector and Z a matrix but no nz. */
157/* Done by specialized code */
158/* */
159/* reverse(tag, m, n, d, q, U[q], Z[q][n]) : fov */
160ADOLC_API int reverse(short, int, int, int, int, double *, double **);
161
162/*--------------------------------------------------------------------------*/
163/* */
164/* If q and U are omitted they default to m and I so that as above */
165/* */
166/* reverse(tag, m, n, d, Z[q][n][d+1], nz[q][n]) : hov */
167ADOLC_API int reverse(short, int, int, int, double ***, short ** = 0);
168
169#endif
170
171/****************************************************************************/
172/****************************************************************************/
173/* Now the C THINGS */
174BEGIN_C_DECLS
175
176/****************************************************************************/
177/* FORWARD MODE */
178
179/*--------------------------------------------------------------------------*/
180/* ZOS */
181/* zos_forward(tag, m, n, keep, x[n], y[m]) */
182/* (defined in uni5_for.cpp) */
183ADOLC_API int zos_forward(short, int, int, int, const double *, double *);
184
185/* zos_forward_nk(tag, m, n, x[n], y[m]) */
186/* (no keep, defined in uni5_for.cpp, but not supported in ADOL-C 1.8) */
187ADOLC_API int zos_forward_nk(short, int, int, const double *, double *);
188
189/* zos_forward_partx(tag, m, n, ndim[n], x[n][d], y[m]) */
190/* (based on zos_forward) */
191
192ADOLC_API int zos_forward_partx(short, int, int, const int *,
193 const double *const *, double *);
194
195/*--------------------------------------------------------------------------*/
196/* FOS */
197/* fos_forward(tag, m, n, keep, x[n], X[n], y[m], Y[m]) */
198/* (defined in uni5_for.cpp) */
199ADOLC_API int fos_forward(short, int, int, int, const double *, const double *,
200 double *, double *);
201
202/* fos_forward_nk(tag,m,n,x[n],X[n],y[m],Y[m]) */
203/* (no keep, defined in uni5_for.cpp, but not supported in ADOL-C 1.8) */
204ADOLC_API int fos_forward_nk(short, int, int, const double *, const double *,
205 double *, double *);
206
207/* fos_forward_partx(tag, m, n, ndim[n], x[n][][2], y[m][2]) */
208/* (based on fos_forward) */
209ADOLC_API int fos_forward_partx(short, int, int, const int *,
210 const double *const *const *, double **);
211
212/*--------------------------------------------------------------------------*/
213/* HOS */
214/* hos_forward(tag, m, n, d, keep, x[n], X[n][d], y[m], Y[m][d]) */
215/* (defined in uni5_for.cpp) */
216ADOLC_API int hos_forward(short, int, int, int, int, const double *,
217 const double *const *, double *, double **);
218
219/* hos_forward_nk(tag, m, n, d, x[n], X[n][d], y[m], Y[m][d]) */
220/* (no keep, defined in uni5_for.cpp, but not supported in ADOL-C 1.8) */
221ADOLC_API int hos_forward_nk(short, int, int, int, const double *,
222 const double *const *, double *, double **);
223
224/* hos_forward_partx(tag, m, n, ndim[n], d, X[n][d+1], Y[m][d+1]) */
225/* (defined in forward_partx.cpp) */
226ADOLC_API int hos_forward_partx(short, int, int, const int *, int,
227 const double *const *const *, double **);
228
229/* now pack the arrays into vectors for Fortran calling */
230ADOLC_API fint hos_forward_(const fint *, const fint *, const fint *,
231 const fint *, const fint *, const fdouble *,
232 const fdouble *, fdouble *, fdouble *);
233
234/*--------------------------------------------------------------------------*/
235/* FOV */
236/* fov_forward(tag, m, n, p, x[n], X[n][p], y[m], Y[m][p]) */
237/* (defined in uni5_for.cpp) */
238ADOLC_API int fov_forward(short, int, int, int, const double *,
239 const double *const *, double *, double **);
240ADOLC_API int fov_offset_forward(short, int, int, int, int, const double *,
241 const double *const *, double *, double **);
242
243/* now pack the arrays into vectors for Fortran calling */
244ADOLC_API fint fov_forward_(const fint *, const fint *, const fint *,
245 const fint *, const fdouble *, const fdouble *,
246 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_API int fov_forward_partx(short, int, int, const int *, int,
251 const double *const *,
252 const double *const *const *, double *,
253 double **);
254
255/*--------------------------------------------------------------------------*/
256/* HOV */
257/* hov_forward(tag, m, n, d, p, x[n], X[n][p][d], y[m], Y[m][p][d]) */
258/* (defined in uni5_for.cpp) */
259ADOLC_API int hov_forward(short, int, int, int, int, const double *,
260 const double *const *const *, double *, double ***);
261
262/* now pack the arrays into vectors for Fortran calling */
263ADOLC_API fint hov_forward_(const fint *, const fint *, const fint *,
264 const fint *, const fint *, const fdouble *,
265 const fdouble *, fdouble *, fdouble *);
266
267/* hov_forward_partx(tag, m, n, ndim[n], d, p, */
268/* x[n][], X[n][][p][d], y[m], Y[m][p][d]) */
269ADOLC_API int hov_forward_partx(short, int, int, const int *, int, int,
270 const double *const *,
271 const double *const *const *const *, double *,
272 double ***);
273
274/*--------------------------------------------------------------------------*/
275/* HOV_WK */
276/* hov_wk_forward(tag, m, n, d, keep, p, x[n], X[n][p][d], y[m], Y[m][p][d]) */
277/* (defined in uni5_for.cpp) */
278ADOLC_API int hov_wk_forward(short, int, int, int, int, int, const double *,
279 const double *const *const *, double *,
280 double ***);
281
282/* now pack the arrays into vectors for Fortran calling */
283ADOLC_API fint hov_wk_forward_(const fint *, const fint *, const fint *,
284 const fint *, const fint *, const fint *,
285 fdouble *, fdouble *, fdouble *, fdouble *);
286
287/****************************************************************************/
288/* BIT PATTERN UTILITIES */
289/*--------------------------------------------------------------------------*/
290/* INT_FOR, SAFE */
291/* int_forward_safe(tag, m, n, p, X[n][p], Y[m][p]) */
292
293ADOLC_API int int_forward_safe(short, int, int, int, const bitword_t *const *,
294 bitword_t **);
295
296/*--------------------------------------------------------------------------*/
297/* INT_FOR, TIGHT */
298/* int_forward_tight(tag, m, n, p, x[n], X[n][p], y[m], Y[m][p]) */
299
300ADOLC_API int int_forward_tight(short, int, int, int, const double *,
301 const bitword_t *const *, double *,
302 bitword_t **);
303
304/****************************************************************************/
305/* INDEX DOMAIN UTILITIES */
306/*--------------------------------------------------------------------------*/
307/* INDOPRO, SAFE */
308/* indopro_forward_safe(tag, m, n, p, x[n], *Y[m]) */
309
310ADOLC_API int indopro_forward_safe(short, int, int, const double *, uint **);
311
312/*--------------------------------------------------------------------------*/
313/* INDOPRO, TIGHT */
314/* indopro_forward_tight(tag, m, n, x[n], *Y[m]) */
315
316ADOLC_API int indopro_forward_tight(short, int, int, const double *, uint **);
317
318/****************************************************************************/
319/* NONLINEAR INDEX DOMAIN UTILITIES */
320/*--------------------------------------------------------------------------*/
321/* INDOPRO, SAFE */
322/* nonl_ind_forward_safe(tag, m, n, p, x[n], *Y[m]) */
323
324ADOLC_API int nonl_ind_forward_safe(short, int, int, const double *, uint **);
325
326/*--------------------------------------------------------------------------*/
327/* INDOPRO, TIGHT */
328/* nonl_ind_forward_tight(tag, m, n, x[n], *Y[m]) */
329
330ADOLC_API int nonl_ind_forward_tight(short, int, int, const double *, uint **);
331/*--------------------------------------------------------------------------*/
332/* INDOPRO, SAFE */
333/* nonl_ind_old_forward_safe(tag, m, n, p, x[n], *Y[m]) */
334
335ADOLC_API int nonl_ind_old_forward_safe(short, int, int, const double *,
336 uint **);
337
338/*--------------------------------------------------------------------------*/
339/* INDOPRO, TIGHT */
340/* nonl_ind_old_forward_tight(tag, m, n, x[n], *Y[m]) */
341
342ADOLC_API int nonl_ind_old_forward_tight(short, int, int, const double *,
343 uint **);
344
345/****************************************************************************/
346/* REVERSE MODE */
347
348/*--------------------------------------------------------------------------*/
349/* FOS */
350/* fos_reverse(tag, m, n, u[m], z[n]) */
351/* (defined in fo_rev.cpp) */
352ADOLC_API int fos_reverse(short, int, int, const double *, double *);
353
354/* now pack the arrays into vectors for Fortran calling */
355ADOLC_API fint fos_reverse_(const fint *, const fint *, const fint *,
356 const fdouble *, fdouble *);
357
358/*--------------------------------------------------------------------------*/
359/* HOS */
360/* hos_reverse(tag, m, n, d, u[m], Z[n][d+1]) */
361/* (defined in ho_rev.cpp) */
362ADOLC_API int hos_reverse(short, int, int, int, const double *, double **);
363
364/* now pack the arrays into vectors for Fortran calling */
365ADOLC_API fint hos_reverse_(const fint *, const fint *, const fint *,
366 const fint *, const fdouble *, fdouble *);
367
368/*--------------------------------------------------------------------------*/
369/* HOS_TI */
370/* hos_ti_reverse(tag, m, n, d, U[m][d+1], Z[n][d+1]) */
371/* (defined in ho_rev.cpp) */
372ADOLC_API int hos_ti_reverse(short, int, int, int, const double *const *,
373 double **);
374
375/* now pack the arrays into vectors for Fortran calling */
376ADOLC_API fint hos_ti_reverse_(const fint *, const fint *, const fint *,
377 const fint *, const fdouble *, fdouble *);
378
379/*--------------------------------------------------------------------------*/
380/* HOS_OV */
381/* hos_ov_reverse(tag, m, n, d, p, U[m][d+1], Z[p][n][d+1]) */
382/* (defined in ho_rev.cpp) */
383ADOLC_API int hos_ov_reverse(short, int, int, int, int, const double *const *,
384 double ***);
385
386/* now pack the arrays into vectors for Fortran calling */
387ADOLC_API fint hos_ov_reverse_(const fint *, const fint *, const fint *,
388 const fint *, const fint *, const fdouble *,
389 fdouble ***);
390
391/*--------------------------------------------------------------------------*/
392/* FOV */
393/* fov_reverse(tag, m, n, p, U[p][m], Z[p][n]) */
394/* (defined in fo_rev.cpp) */
395ADOLC_API int fov_reverse(short, int, int, int, const double *const *,
396 double **);
397
398/* now pack the arrays into vectors for Fortran calling */
399ADOLC_API fint fov_reverse_(const fint *, const fint *, const fint *,
400 const fint *, const fdouble *, fdouble *);
401
402/*--------------------------------------------------------------------------*/
403/* HOV */
404/* hov_reverse(tag, m, n, d, p, U[p][m], Z[p][n][d+1], nz[p][n]) */
405/* (defined in ho_rev.cpp) */
406ADOLC_API int hov_reverse(short, int, int, int, int, const double *const *,
407 double ***, short **);
408
409/* now pack the arrays into vectors for Fortran calling */
410ADOLC_API fint hov_reverse_(const fint *, const fint *, const fint *,
411 const fint *, const fint *, const fdouble *,
412 fdouble *);
413
414/*--------------------------------------------------------------------------*/
415/* HOV_TI */
416/* hov_ti_reverse(tag, m, n, d, p, U[p][m][d+1], Z[p][n][d+1], nz[p][n]) */
417/* (defined in ho_rev.cpp) */
418ADOLC_API int hov_ti_reverse(short, int, int, int, int,
419 const double *const *const *, double ***,
420 short **);
421
422/* now pack the arrays into vectors for Fortran calling */
423ADOLC_API fint hov_ti_reverse_(const fint *, const fint *, const fint *,
424 const fint *, const fint *, const fdouble *,
425 fdouble *);
426
427/****************************************************************************/
428/* BIT PATTERN UTILITIES */
429/*--------------------------------------------------------------------------*/
430/* INT_REV, TIGHT */
431/* int_reverse_tight(tag, m, n, q, U[q][m], Z[q][n]) */
432
433ADOLC_API int int_reverse_tight(short, int, int, int, const bitword_t *const *,
434 bitword_t **);
435
436/*--------------------------------------------------------------------------*/
437/* INT_REV, SAFE */
438/* int_reverse_safe(tag, m, n, q, U[q][m], Z[q][n]) */
439
440ADOLC_API int int_reverse_safe(short, int, int, int, const bitword_t *const *,
441 bitword_t **);
442
443/*--------------------------------------------------------------------------*/
444ADOLC_API int zos_pl_forward(short, int, int, int, const double *, double *,
445 double *);
446ADOLC_API short firstsign(int, const double *, const double *);
447ADOLC_API short ext_firstsign(double, double, int, double *, double *);
448ADOLC_API short ext_firstsign2(double, int, double *, double *);
449ADOLC_API int fos_pl_forward(short, int, int, const double *, const double *,
450 double *, double *, double *, double *);
451ADOLC_API int fov_pl_forward(short, int, int, int, const double *,
452 const double *const *, double *, double **,
453 double *, double **, short *);
454ADOLC_API int fos_pl_sig_forward(short, int, int, const double *,
455 const double *, int, const short *,
456 const short *, double *, double *, double *,
457 double *, short *);
458ADOLC_API int fov_pl_sig_forward(short, int, int, int, const double *,
459 const double *const *, int, const short *,
460 const short *, double *, double **, double *,
461 double **, short *);
462ADOLC_API int indopro_forward_absnormal(short, int, int, int, const double *,
463 uint **);
464/*--------------------------------------------------------------------------*/
465
494ADOLC_API int fos_pl_reverse(short tag, int m, int n, int s,
495 const double *lagrange,
496 const double *lagrangeSwitch, double *results,
497 double *resultsSwitch);
498
517ADOLC_API int fov_pl_reverse(short tag, int m, int n, int s, int nrow,
518 const double *const *lagrange,
519 const double *const *lagrangeSwitch,
520 double **results, double **resultsSwitch);
521
522ADOLC_API int fos_pl_sig_reverse(short, int, int, int, const short *,
523 const double *, double *);
524
525END_C_DECLS
526
527#endif
ADOLC_API
#define ADOLC_API
Definition adolcexport.h:16
BEGIN_C_DECLS
#define BEGIN_C_DECLS
Definition common.h:115
uint
unsigned int uint
Definition common.h:39
bitword_t
uint32_t bitword_t
Definition common.h:37
END_C_DECLS
#define END_C_DECLS
Definition common.h:116
ext_firstsign
ADOLC_API short ext_firstsign(double, double, int, double *, double *)
int_forward_tight
ADOLC_API int int_forward_tight(short, int, int, int, const double *, const bitword_t *const *, double *, bitword_t **)
fov_pl_forward
ADOLC_API int fov_pl_forward(short, int, int, int, const double *, const double *const *, double *, double **, double *, double **, short *)
hos_reverse_
ADOLC_API fint hos_reverse_(const fint *, const fint *, const fint *, const fint *, const fdouble *, fdouble *)
int_reverse_safe
ADOLC_API int int_reverse_safe(short, int, int, int, const bitword_t *const *, bitword_t **)
fov_forward_partx
ADOLC_API int fov_forward_partx(short, int, int, const int *, int, const double *const *, const double *const *const *, double *, double **)
hos_ov_reverse
ADOLC_API int hos_ov_reverse(short, int, int, int, int, const double *const *, double ***)
hos_ov_reverse_
ADOLC_API fint hos_ov_reverse_(const fint *, const fint *, const fint *, const fint *, const fint *, const fdouble *, fdouble ***)
hov_forward_partx
ADOLC_API int hov_forward_partx(short, int, int, const int *, int, int, const double *const *, const double *const *const *const *, double *, double ***)
fov_reverse_
ADOLC_API fint fov_reverse_(const fint *, const fint *, const fint *, const fint *, const fdouble *, fdouble *)
fos_forward
ADOLC_API int fos_forward(short, int, int, int, const double *, const double *, double *, double *)
hov_forward
ADOLC_API int hov_forward(short, int, int, int, int, const double *, const double *const *const *, double *, double ***)
fos_reverse_
ADOLC_API fint fos_reverse_(const fint *, const fint *, const fint *, const fdouble *, fdouble *)
hov_wk_forward_
ADOLC_API fint hov_wk_forward_(const fint *, const fint *, const fint *, const fint *, const fint *, const fint *, fdouble *, fdouble *, fdouble *, fdouble *)
nonl_ind_forward_tight
ADOLC_API int nonl_ind_forward_tight(short, int, int, const double *, uint **)
indopro_forward_absnormal
ADOLC_API int indopro_forward_absnormal(short, int, int, int, const double *, uint **)
nonl_ind_old_forward_tight
ADOLC_API int nonl_ind_old_forward_tight(short, int, int, const double *, uint **)
hos_forward_
ADOLC_API fint hos_forward_(const fint *, const fint *, const fint *, const fint *, const fint *, const fdouble *, const fdouble *, fdouble *, fdouble *)
fos_reverse
ADOLC_API int fos_reverse(short, int, int, const double *, double *)
fos_forward_nk
ADOLC_API int fos_forward_nk(short, int, int, const double *, const double *, double *, double *)
indopro_forward_tight
ADOLC_API int indopro_forward_tight(short, int, int, const double *, uint **)
zos_forward_nk
ADOLC_API int zos_forward_nk(short, int, int, const double *, double *)
hov_ti_reverse_
ADOLC_API fint hov_ti_reverse_(const fint *, const fint *, const fint *, const fint *, const fint *, const fdouble *, fdouble *)
firstsign
ADOLC_API short firstsign(int, const double *, const double *)
fov_offset_forward
ADOLC_API int fov_offset_forward(short, int, int, int, int, const double *, const double *const *, double *, double **)
hos_forward_nk
ADOLC_API int hos_forward_nk(short, int, int, int, const double *, const double *const *, double *, double **)
fov_forward_
ADOLC_API fint fov_forward_(const fint *, const fint *, const fint *, const fint *, const fdouble *, const fdouble *, fdouble *, fdouble *)
int_reverse_tight
ADOLC_API int int_reverse_tight(short, int, int, int, const bitword_t *const *, bitword_t **)
fov_forward
ADOLC_API int fov_forward(short, int, int, int, const double *, const double *const *, double *, double **)
hos_ti_reverse_
ADOLC_API fint hos_ti_reverse_(const fint *, const fint *, const fint *, const fint *, const fdouble *, fdouble *)
nonl_ind_forward_safe
ADOLC_API int nonl_ind_forward_safe(short, int, int, const double *, uint **)
fos_pl_sig_reverse
ADOLC_API int fos_pl_sig_reverse(short, int, int, int, const short *, const double *, double *)
hov_forward_
ADOLC_API fint hov_forward_(const fint *, const fint *, const fint *, const fint *, const fint *, const fdouble *, const fdouble *, fdouble *, fdouble *)
fov_pl_sig_forward
ADOLC_API int fov_pl_sig_forward(short, int, int, int, const double *, const double *const *, int, const short *, const short *, double *, double **, double *, double **, short *)
hos_forward
ADOLC_API int hos_forward(short, int, int, int, int, const double *, const double *const *, double *, double **)
hos_reverse
ADOLC_API int hos_reverse(short, int, int, int, const double *, double **)
ext_firstsign2
ADOLC_API short ext_firstsign2(double, int, double *, double *)
fos_forward_partx
ADOLC_API int fos_forward_partx(short, int, int, const int *, const double *const *const *, double **)
zos_forward_partx
ADOLC_API int zos_forward_partx(short, int, int, const int *, const double *const *, double *)
hov_ti_reverse
ADOLC_API int hov_ti_reverse(short, int, int, int, int, const double *const *const *, double ***, short **)
nonl_ind_old_forward_safe
ADOLC_API int nonl_ind_old_forward_safe(short, int, int, const double *, uint **)
fov_reverse
ADOLC_API int fov_reverse(short, int, int, int, const double *const *, double **)
zos_pl_forward
ADOLC_API int zos_pl_forward(short, int, int, int, const double *, double *, double *)
int_forward_safe
ADOLC_API int int_forward_safe(short, int, int, int, const bitword_t *const *, bitword_t **)
hos_forward_partx
ADOLC_API int hos_forward_partx(short, int, int, const int *, int, const double *const *const *, double **)
hov_reverse_
ADOLC_API fint hov_reverse_(const fint *, const fint *, const fint *, const fint *, const fint *, const fdouble *, fdouble *)
zos_forward
BEGIN_C_DECLS ADOLC_API int zos_forward(short, int, int, int, const double *, double *)
fos_pl_sig_forward
ADOLC_API int fos_pl_sig_forward(short, int, int, const double *, const double *, int, const short *, const short *, double *, double *, double *, double *, short *)
hov_wk_forward
ADOLC_API int hov_wk_forward(short, int, int, int, int, int, const double *, const double *const *const *, double *, double ***)
indopro_forward_safe
ADOLC_API int indopro_forward_safe(short, int, int, const double *, uint **)
hov_reverse
ADOLC_API int hov_reverse(short, int, int, int, int, const double *const *, double ***, short **)
fos_pl_forward
ADOLC_API int fos_pl_forward(short, int, int, const double *, const double *, double *, double *, double *, double *)
hos_ti_reverse
ADOLC_API int hos_ti_reverse(short, int, int, int, const double *const *, double **)
fov_pl_reverse
ADOLC_API int fov_pl_reverse(short tag, int m, int n, int s, int nrow, const double *const *lagrange, const double *const *lagrangeSwitch, double **results, double **resultsSwitch)
Computes several vector-Jacobian product of the extended Jacobian of the abs-linearization.
fos_pl_reverse
ADOLC_API int fos_pl_reverse(short tag, int m, int n, int s, const double *lagrange, const double *lagrangeSwitch, double *results, double *resultsSwitch)
Computes vector-Jacobian product of the extended Jacobian of the abs-linearization.
ADOLC::Sparse::reverse
ADOLC_API int reverse(short tag, int m, int n, int q, std::vector< bitword_t * > &U, std::vector< bitword_t * > &Z)
Reverse-mode bit-pattern propagation (safe or tight control-flow).
Definition sparse_fo_rev.h:163
ADOLC::Sparse::forward
ADOLC_API int forward(short tag, int m, int n, int p, double *x, std::vector< bitword_t * > &X, double *y, std::vector< bitword_t * > &Y)
Forward-mode bit-pattern propagation (safe or tight control-flow).
Definition sparse_fo_rev.h:73
fint
#define fint
Definition usrparms.h:38
fdouble
#define fdouble
Definition usrparms.h:39
Generated by doxygen 1.9.8