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

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

fix the comment

From: Jean Utke <utke@…>

  • Property svn:keywords set to Author Date Id Revision
File size: 22.1 KB
Line 
1/*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File:     interfaces.h
4 Revision: $Id: interfaces.h 365 2012-11-15 11:51:21Z 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/****************************************************************************/
333/*                                                             REVERSE MODE */
334
335/*--------------------------------------------------------------------------*/
336/*                                                                      FOS */
337/* fos_reverse(tag, m, n, u[m], z[n])                                       */
338/* (defined  in fo_rev.mc)                                                  */
339ADOLC_DLL_EXPORT int fos_reverse(short,int,int,double*,double*);
340
341/* now pack the arrays into vectors for Fortran calling                     */
342ADOLC_DLL_EXPORT fint fos_reverse_(fint*,fint*,fint*,fdouble*,fdouble*);
343
344/*--------------------------------------------------------------------------*/
345/*                                                                      HOS */
346/*  hos_reverse(tag, m, n, d, u[m], Z[n][d+1])                              */
347/* (defined  in ho_rev.mc)                                                  */
348ADOLC_DLL_EXPORT int hos_reverse(short,int,int,int,double*,double**);
349
350/* now pack the arrays into vectors for Fortran calling                     */
351ADOLC_DLL_EXPORT fint hos_reverse_(fint*,fint*,fint*,fint*,fdouble*,fdouble*);
352
353/*--------------------------------------------------------------------------*/
354/*                                                                   HOS_TI */
355/*  hos_ti_reverse(tag, m, n, d, U[m][d+1], Z[n][d+1])                      */
356/* (defined  in ho_rev.mc)                                                  */
357ADOLC_DLL_EXPORT int hos_ti_reverse(short,int,int,int,double**,double**);
358
359/* now pack the arrays into vectors for Fortran calling                     */
360ADOLC_DLL_EXPORT fint hos_ti_reverse_(
361    fint*,fint*,fint*,fint*,fdouble*,fdouble*);
362
363/*--------------------------------------------------------------------------*/
364/*                                                                   HOS_OV */
365/*  hos_ov_reverse(tag, m, n, d, u[m], Z[n][d+1])                           */
366/* (defined  in ho_rev.mc)                                                  */
367ADOLC_DLL_EXPORT int hos_ov_reverse(short,int,int,int,int,double**,double***);
368
369/* now pack the arrays into vectors for Fortran calling                     */
370ADOLC_DLL_EXPORT fint hos_ov_reverse_(
371    fint*,fint*,fint*,fint*,fint*,fdouble*,fdouble***);
372
373/*--------------------------------------------------------------------------*/
374/*                                                                      FOV */
375/* fov_reverse(tag, m, n, p, U[p][m], Z[p][n])                              */
376/* (defined  in fo_rev.mc)                                                  */
377ADOLC_DLL_EXPORT int fov_reverse(short,int,int,int,double**,double**);
378
379/* now pack the arrays into vectors for Fortran calling                     */
380ADOLC_DLL_EXPORT fint fov_reverse_(fint*,fint*,fint*,fint*,fdouble*,fdouble*);
381
382/*--------------------------------------------------------------------------*/
383/*                                                                      HOV */
384/* hov_reverse(tag, m, n, d, p, U[p][m], Z[p][n][d+1], nz[p][n])            */
385/* (defined  in ho_rev.mc)                                                  */
386ADOLC_DLL_EXPORT int hov_reverse(
387    short,int,int,int,int,double**,double***,short**);
388
389/* now pack the arrays into vectors for Fortran calling      */
390ADOLC_DLL_EXPORT fint hov_reverse_(
391    fint*,fint*,fint*,fint*,fint*,fdouble*,fdouble*);
392
393/*--------------------------------------------------------------------------*/
394/*                                                                   HOV_TI */
395/* hov_ti_reverse(tag, m, n, d, p, U[p][m][d+1], Z[p][n][d+1], nz[p][n])    */
396/* (defined  in ho_rev.mc)                                                  */
397ADOLC_DLL_EXPORT int hov_ti_reverse(
398    short,int,int,int,int,double***,double***,short**);
399
400/* now pack the arrays into vectors for Fortran calling      */
401ADOLC_DLL_EXPORT fint hov_ti_reverse_(
402    fint*,fint*,fint*,fint*,fint*,fdouble*,fdouble*);
403
404/****************************************************************************/
405/*                                                    BIT PATTERN UTILITIES */
406/*--------------------------------------------------------------------------*/
407/*                                                           INT_REV, TIGHT */
408/* int_reverse_tight(tag, m, n, q, U[q][m], Z[q][n])                        */
409
410ADOLC_DLL_EXPORT int int_reverse_tight
411(short, int, int, int, unsigned long int**, unsigned long int**);
412
413
414/*--------------------------------------------------------------------------*/
415/*                                                            INT_REV, SAFE */
416/* int_reverse_safe(tag, m, n, q, U[q][m], Z[q][n])                         */
417
418ADOLC_DLL_EXPORT int int_reverse_safe
419(short, int, int, int, unsigned long int**, unsigned long int**);
420
421END_C_DECLS
422
423#endif
Note: See TracBrowser for help on using the repository browser.