Changeset 537


Ignore:
Timestamp:
Aug 15, 2014 10:10:48 AM (5 years ago)
Author:
kulshres
Message:

Merge changes from branch 'master' of 'gitclone' into 'svn'

The following changes have been merged:

commit 86c6feecd3bec771574ca75447082e7fdd57ec9e
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 14:22:15 2014 +0200

add new file to windows build too

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

commit 5c30f52c15c12a98fcfb4fc1718d5be89d4e055e
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 14:17:53 2014 +0200

Since we've broken tape format and ABI let's check properly

This tape is not consistent with those created by version 2.5.1
so check for 2.5.2 which may or may not be released. The next
version would most probably be 2.6.0

Also increment current version so check doesn't fail.

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

commit 766d7547631a296c87a35acb2e7bde09a987ee4f
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 14:02:28 2014 +0200

Add a simple example using parameters

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

commit 9a218ac29568a22e556dfaf64726402e800edb09
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 14:01:19 2014 +0200

forward and reverse implementation for new opcodes

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

commit 9797dda86306918dadea276599b8773d0016e731
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 14:00:53 2014 +0200

add implementations for new operators and functions

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

commit 6e8618758d0c6ee6386516d89f67de3f88bfe51b
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 13:59:53 2014 +0200

add new file to build

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

commit 0b67706cd4de32c30d14e67b9b59996ccb4a5fe6
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 13:59:37 2014 +0200

Discard parameters from value tape in reverse mode

Since parameters are read from value tape during
read_tape_stats already, we must simply discard them
when from the back of the value tape when opening it
for reverse mode.

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

commit 388f43fc0cb8732a2a8c717ed7fbc2b03af5695e
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 13:52:17 2014 +0200

Store and retrieve parameters from disk tapes

At the end of tracing in stop_trace we can copy the
parameters from the tracing store in GlobalTapeVars?
to the store in PersistentTapeInfos?. This way, we can
trace a different function after this one, with a
different set of parameters.

Also store these parameters contiguously at the end of
the value tape for persistence. These should be read at
the same time as the stats are read from disk tapes
when opening them, so that we can call forward and
reverse directly without any changes.

One can call set_param_vec() on any tape, if one wishes
to replace the parameters with new ones, before calling
forward. Taylor stack is invalidated if one does this,
so forward must be called before reverse.

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

commit 4de6c1d76c380c99eea898df18d4bd166d9b07d7
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 13:51:17 2014 +0200

create space and methods for tracing the parameters

we can use a separate StoreManager? to manage the indices
of the parameters during tracing. Do this in GlobalTapeVars?
just like for the active store.

The difference is that parameters don't get overwritten so
the management is really much simpler. This indices will all
only be freed once taping is complete.

Also add constructors and methods to tag parameters in user
code in a new file.

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

commit 2fd6d8b09d804f30a2723360d5283c53bcb4ee35
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 13:09:32 2014 +0200

Do not use memcpy to copy tape structures

using memcpy for copying the tape structure is wrong
for the same reason that using memset to initialize them
is wrong. So create a member function to copy which
uses the addresses of the fields directly.

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

commit 4b9964a7821e4861f5fb4880c56e346abba4155d
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 13:05:00 2014 +0200

clean up the initialization of tape stuctures

Firstly we need space to store parameters in
PersistentTapeInfos? since the parameters must survive
tape reuse.

Since we can use constructors and destructors, use them
also setting the structure to zero using memset is not
good. It may clobber information from C++. Do the zero
setting using the address of the fields inside the
constructor.

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

commit 427b164acf4e0e9fed7f3dc018b866c79e8b93b1
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 12:52:13 2014 +0200

remove inlined functions from cpp file

also correct the header, since advector.h is now
automatically included from adouble.h

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

commit c83072a1117a8f8af3a662b840cf24c3f23bd471
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 12:50:17 2014 +0200

Add the interface for parameter dependent functions

This introduces a new class pdouble, which represent
parameters. These are supposed to work in such a way
that they are really constants, which can be changed
from one evaluation of the function to the next, but
we do not compute derivatives with respect to these
parameters. This will speed up forward mode significantly
as it will reduce the number of real independent variables.

We also move the declarations of overloaded functions
to a separate file because these friend declarations
were repeated between badouble and adub classes, and now
new such functions with pdouble parameters are added.
In order to keep the declarations in sync we include
the extra internal headers inside each class declaration.

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

commit 833e176ba3fd373e828223b94157b1dca34f4d40
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 12:37:49 2014 +0200

ignore correct generated file after move

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

commit ba0537f87ecb8634e43d918b8284997d5d5af07e
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 13:45:55 2014 +0200

Move some internal header files to a subdirectory

these headers should never be included by a user
directly. They are always included from other
user interface headers. So we move them to
the 'internal' subdirectory to indicate this.

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

commit 688b6c45faa0b7890e8b1d9d709a82b98a47f94f
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 15 12:25:20 2014 +0200

The ABI seems to have been broken, change library version

The old library libadolc.so.1.1.1 seems to have conflicts
with the new library version libadolc.so.1.2.0 So increase
the major version. After this the new library will be
libadolc.so.2.1.0

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

Location:
trunk
Files:
9 added
35 edited
4 moved

Legend:

Unmodified
Added
Removed
  • trunk/ADOL-C/Makefile.am

    r499 r537  
    3232
    3333lib_LTLIBRARIES = lib@adolclib@.la
    34 lib@adolclib@_la_LDFLAGS  = -version-info 3:0:2 -no-undefined
     34lib@adolclib@_la_LDFLAGS  = -version-info 3:0:1 -no-undefined
    3535lib@adolclib@_la_SOURCES  = dummy.cpp
    3636
  • trunk/ADOL-C/examples/additional_examples/Makefile.am

    r406 r537  
    1717                       detexam helm lighthouse scal speelpenning taylor pow \
    1818                       checkpointing ext_diff_func fixpoint_exam openmp_exam \
    19                        cuda
     19                       cuda param
    2020endif
    2121
     
    2424                       detexam helm lighthouse scal speelpenning taylor pow \
    2525                       checkpointing ext_diff_func fixpoint_exam openmp_exam \
    26                        cuda
     26                       cuda param
    2727endif
  • trunk/ADOL-C/include/adolc/Makefile.am

    r429 r537  
    1212
    1313pkginclude_HEADERS   = adolc.h adalloc.h adouble.h adutils.h adutilsc.h \
    14                        common.h convolut.h dvlparms.h fortutils.h\
    15                        interfaces.h taping.h usrparms.h \
     14                       convolut.h fortutils.h \
     15                       interfaces.h taping.h \
    1616                       externfcts.h checkpointing.h fixpoint.h\
    1717                       adolc_sparse.h adolc_openmp.h \
    18                        revolve.h advector.h adolc_settings.h \
     18                       revolve.h advector.h \
    1919                       adtl.h adoublecuda.h
    2020
    21 SUBDIRS = drivers tapedoc
    22 
    23 EXTRA_DIST = adolc_settings.h.in
     21SUBDIRS = internal drivers tapedoc
    2422
    2523if SPARSE
  • trunk/ADOL-C/include/adolc/adalloc.h

    r364 r537  
    1616#define ADOLC_ADALLOC_H 1
    1717
    18 #include <adolc/common.h>
     18#include <adolc/internal/common.h>
    1919
    2020/****************************************************************************/
  • trunk/ADOL-C/include/adolc/adolc.h

    r354 r537  
    1919#define ADOLC_ADOLC_H 1
    2020
    21 #include <adolc/common.h>
     21#include <adolc/internal/common.h>
    2222
    2323/****************************************************************************/
  • trunk/ADOL-C/include/adolc/adolc_openmp.h

    r354 r537  
    2323#else
    2424
    25 #include <adolc/common.h>
     25#include <adolc/internal/common.h>
    2626
    2727extern void beginParallel();
  • trunk/ADOL-C/include/adolc/adouble.h

    r523 r537  
    3939using std::logic_error;
    4040
    41 #include <adolc/common.h>
     41#include <adolc/internal/common.h>
    4242
    4343/* NOTICE: There are automatic includes at the end of this file! */
     
    5050class adub;
    5151class badouble;
     52class pdouble;
    5253
    5354/*--------------------------------------------------------------------------*/
     
    7071*/
    7172class ADOLC_DLL_EXPORT badouble {
     73    friend ADOLC_DLL_EXPORT class pdouble;
    7274protected:
    7375    locint location;
     
    124126
    125127    /*--------------------------------------------------------------------------*/
     128    badouble& operator = (const pdouble&);
     129    badouble& operator += (const pdouble&);
     130    badouble& operator -= (const pdouble&);
     131    badouble& operator *= (const pdouble&);
     132    inline badouble& operator /= (const pdouble&);
     133    /*--------------------------------------------------------------------------*/
    126134    /* Comparison (friends) */
    127 #if defined(ADOLC_ADVANCED_BRANCHING)
    128     friend ADOLC_DLL_EXPORT adub operator != ( const badouble&, const badouble& );
    129     friend ADOLC_DLL_EXPORT adub operator == ( const badouble&, const badouble& );
    130     friend ADOLC_DLL_EXPORT adub operator <= ( const badouble&, const badouble& );
    131     friend ADOLC_DLL_EXPORT adub operator >= ( const badouble&, const badouble& );
    132     friend ADOLC_DLL_EXPORT adub operator >  ( const badouble&, const badouble& );
    133     friend ADOLC_DLL_EXPORT adub operator <  ( const badouble&, const badouble& );
    134 #else
     135#if !defined(ADOLC_ADVANCED_BRANCHING)
    135136    inline friend int operator != ( const badouble&, const badouble& );
    136137    inline friend int operator == ( const badouble&, const badouble& );
     
    155156
    156157    /*--------------------------------------------------------------------------*/
    157     /* sign operators (friends) */
    158     friend ADOLC_DLL_EXPORT adub operator + ( const badouble& x );
    159     friend ADOLC_DLL_EXPORT adub operator - ( const badouble& x );
    160 
    161     /*--------------------------------------------------------------------------*/
    162     /* binary operators (friends) */
    163     friend ADOLC_DLL_EXPORT adub operator + ( const badouble&, const badouble& );
    164     friend ADOLC_DLL_EXPORT adub operator + ( double, const badouble& );
    165     friend ADOLC_DLL_EXPORT adub operator + ( const badouble&, double );
    166     friend ADOLC_DLL_EXPORT adub operator - ( const badouble&, const badouble& );
    167     inline friend adub operator - ( const badouble&, double );
    168     friend ADOLC_DLL_EXPORT adub operator - ( double, const badouble& );
    169     friend ADOLC_DLL_EXPORT adub operator * ( const badouble&, const badouble& );
    170     friend ADOLC_DLL_EXPORT adub operator * ( double, const badouble& );
    171     inline friend adub operator * ( const badouble&, double );
    172     inline friend adub operator / ( const badouble&, double );
    173     friend ADOLC_DLL_EXPORT adub operator / ( const badouble&, const badouble& );
    174     friend ADOLC_DLL_EXPORT adub operator / ( double, const badouble& );
    175 
    176     /*--------------------------------------------------------------------------*/
    177     /* unary operators (friends) */
    178     friend ADOLC_DLL_EXPORT adub exp  ( const badouble& );
    179     friend ADOLC_DLL_EXPORT adub log  ( const badouble& );
    180     friend ADOLC_DLL_EXPORT adub sqrt ( const badouble& );
    181     friend ADOLC_DLL_EXPORT adub sin  ( const badouble& );
    182     friend ADOLC_DLL_EXPORT adub cos  ( const badouble& );
    183     friend ADOLC_DLL_EXPORT adub tan  ( const badouble& );
    184     friend ADOLC_DLL_EXPORT adub asin ( const badouble& );
    185     friend ADOLC_DLL_EXPORT adub acos ( const badouble& );
    186     friend ADOLC_DLL_EXPORT adub atan ( const badouble& );
     158    /* Functions friends with both badouble and adub */
     159#define _IN_CLASS_ 1
     160#define _IN_BADOUBLE_ 1
     161#include <adolc/internal/adubfunc.h>
     162#undef _IN_BADOUBLE_
     163#undef _IN_CLASS_
    187164
    188165    /*--------------------------------------------------------------------------*/
    189166    /* special operators (friends) */
    190167    friend ADOLC_DLL_EXPORT adouble atan2 ( const badouble&, const badouble& );
    191     /* no internal use of condassign: */
    192     friend ADOLC_DLL_EXPORT adub    pow   ( const badouble&, double );
    193168    /* uses condassign internally */
    194169    friend ADOLC_DLL_EXPORT adouble pow   ( const badouble&, const badouble& );
    195170    friend ADOLC_DLL_EXPORT adouble pow   ( double, const badouble& );
    196     friend ADOLC_DLL_EXPORT adub    log10 ( const badouble& );
    197171    /* User defined version of logarithm to test extend_quad macro */
    198172    friend ADOLC_DLL_EXPORT adouble myquad( const badouble& );
    199 
    200     /*--------------------------------------------------------------------------*/
    201     /* Additional ANSI C standard Math functions Added by DWJ on 8/6/90 */
    202     friend ADOLC_DLL_EXPORT adub sinh  ( const badouble& );
    203     friend ADOLC_DLL_EXPORT adub cosh  ( const badouble& );
    204     friend ADOLC_DLL_EXPORT adub tanh  ( const badouble& );
    205 #if defined(ATRIG_ERF)
    206     friend ADOLC_DLL_EXPORT adub asinh ( const badouble& );
    207     friend ADOLC_DLL_EXPORT adub acosh ( const badouble& );
    208     friend ADOLC_DLL_EXPORT adub atanh ( const badouble& );
    209 #endif
    210 
    211     friend ADOLC_DLL_EXPORT adub fabs  ( const badouble& );
    212     friend ADOLC_DLL_EXPORT adub ceil  ( const badouble& );
    213     friend ADOLC_DLL_EXPORT adub floor ( const badouble& );
    214 
    215     friend ADOLC_DLL_EXPORT adub fmax ( const badouble&, const badouble& );
    216     friend ADOLC_DLL_EXPORT adub fmax ( double, const badouble& );
    217     friend ADOLC_DLL_EXPORT adub fmax ( const badouble&, double );
    218     friend ADOLC_DLL_EXPORT adub fmin ( const badouble&, const badouble& );
    219     friend ADOLC_DLL_EXPORT adub fmin ( double, const badouble& );
    220     friend ADOLC_DLL_EXPORT adub fmin ( const badouble&, double );
    221 
    222     friend ADOLC_DLL_EXPORT adub ldexp ( const badouble&, int );
    223     friend ADOLC_DLL_EXPORT adub frexp ( const badouble&, int* );
    224     friend ADOLC_DLL_EXPORT adub erf   ( const badouble& );
    225173
    226174    /*--------------------------------------------------------------------------*/
     
    230178    friend ADOLC_DLL_EXPORT void condassign( adouble &res, const badouble &cond,
    231179            const badouble &arg );
     180
     181#define _IN_CLASS_ 1
     182#define _IN_BADOUBLE_ 1
     183#include <adolc/internal/paramfunc.h>
     184#undef _IN_BADOUBLE_
     185#undef _IN_CLASS_
     186
    232187};
    233188
     
    249204    friend ADOLC_DLL_EXPORT class advector;
    250205    friend ADOLC_DLL_EXPORT class adubref;
     206    friend ADOLC_DLL_EXPORT class pdouble;
    251207    friend ADOLC_DLL_EXPORT adub* adubp_from_adub(const adub&);
    252208    adub( adub const &) {
     
    277233
    278234    /*--------------------------------------------------------------------------*/
    279     /* Comparison (friends) */
    280 #if defined(ADOLC_ADVANCED_BRANCHING)
    281     friend ADOLC_DLL_EXPORT adub operator != ( const badouble&, const badouble& );
    282     friend ADOLC_DLL_EXPORT adub operator == ( const badouble&, const badouble& );
    283     friend ADOLC_DLL_EXPORT adub operator <= ( const badouble&, const badouble& );
    284     friend ADOLC_DLL_EXPORT adub operator >= ( const badouble&, const badouble& );
    285     friend ADOLC_DLL_EXPORT adub operator < ( const badouble&, const badouble& );
    286     friend ADOLC_DLL_EXPORT adub operator > ( const badouble&, const badouble& );
    287 #endif
    288     /*--------------------------------------------------------------------------*/
    289     /* sign operators (friends) */
    290     friend ADOLC_DLL_EXPORT adub operator + ( const badouble& x );
    291     friend ADOLC_DLL_EXPORT adub operator - ( const badouble& x );
    292 
    293     /*--------------------------------------------------------------------------*/
    294     /* binary operators (friends) */
    295     friend ADOLC_DLL_EXPORT adub operator + ( const badouble&, const badouble& );
    296     friend ADOLC_DLL_EXPORT adub operator + ( double, const badouble& );
    297     friend ADOLC_DLL_EXPORT adub operator + ( const badouble&, double );
    298     friend ADOLC_DLL_EXPORT adub operator - ( const badouble&, const badouble& );
    299     inline friend adub operator - ( const badouble&, double );
    300     friend ADOLC_DLL_EXPORT adub operator - ( double, const badouble& );
    301     friend ADOLC_DLL_EXPORT adub operator * ( const badouble&, const badouble& );
    302     friend ADOLC_DLL_EXPORT adub operator * ( double, const badouble& );
    303     inline friend adub operator * ( const badouble&, double );
    304     inline friend adub operator / ( const badouble&, double );
    305     friend ADOLC_DLL_EXPORT adub operator / ( const badouble&, const badouble& );
    306     friend ADOLC_DLL_EXPORT adub operator / ( double, const badouble& );
    307 
    308     /*--------------------------------------------------------------------------*/
    309     /* unary operators (friends) */
    310     friend ADOLC_DLL_EXPORT adub exp  ( const badouble& );
    311     friend ADOLC_DLL_EXPORT adub log  ( const badouble& );
    312     friend ADOLC_DLL_EXPORT adub sqrt ( const badouble& );
    313     friend ADOLC_DLL_EXPORT adub sin  ( const badouble& );
    314     friend ADOLC_DLL_EXPORT adub cos  ( const badouble& );
    315     friend ADOLC_DLL_EXPORT adub tan  ( const badouble& );
    316     friend ADOLC_DLL_EXPORT adub asin ( const badouble& );
    317     friend ADOLC_DLL_EXPORT adub acos ( const badouble& );
    318     friend ADOLC_DLL_EXPORT adub atan ( const badouble& );
    319 
    320     /*--------------------------------------------------------------------------*/
    321     /* special operators (friends) */
    322     /* no internal use of condassign: */
    323     friend ADOLC_DLL_EXPORT adub    pow   ( const badouble&, double );
    324     friend ADOLC_DLL_EXPORT adub    log10 ( const badouble& );
    325 
    326     /*--------------------------------------------------------------------------*/
    327     /* Additional ANSI C standard Math functions Added by DWJ on 8/6/90 */
    328     friend ADOLC_DLL_EXPORT adub sinh  ( const badouble& );
    329     friend ADOLC_DLL_EXPORT adub cosh  ( const badouble& );
    330     friend ADOLC_DLL_EXPORT adub tanh  ( const badouble& );
    331 #if defined(ATRIG_ERF)
    332     friend ADOLC_DLL_EXPORT adub asinh ( const badouble& );
    333     friend ADOLC_DLL_EXPORT adub acosh ( const badouble& );
    334     friend ADOLC_DLL_EXPORT adub atanh ( const badouble& );
    335 #endif
    336 
    337     friend ADOLC_DLL_EXPORT adub fabs  ( const badouble& );
    338     friend ADOLC_DLL_EXPORT adub ceil  ( const badouble& );
    339     friend ADOLC_DLL_EXPORT adub floor ( const badouble& );
    340 
    341     friend ADOLC_DLL_EXPORT adub fmax ( const badouble&, const badouble& );
    342     friend ADOLC_DLL_EXPORT adub fmax ( double, const badouble& );
    343     friend ADOLC_DLL_EXPORT adub fmax ( const badouble&, double );
    344     friend ADOLC_DLL_EXPORT adub fmin ( const badouble&, const badouble& );
    345     friend ADOLC_DLL_EXPORT adub fmin ( double, const badouble& );
    346     friend ADOLC_DLL_EXPORT adub fmin ( const badouble&, double );
    347 
    348     friend ADOLC_DLL_EXPORT adub ldexp ( const badouble&, int );
    349     friend ADOLC_DLL_EXPORT adub frexp ( const badouble&, int* );
    350     friend ADOLC_DLL_EXPORT adub erf   ( const badouble& );
     235    /* Functions friends with both badouble and adub */
     236#define _IN_CLASS_ 1
     237#define _IN_ADUB_ 1
     238#include <adolc/internal/adubfunc.h>
     239#undef _IN_ADUB_
     240#undef _IN_CLASS_
     241
     242    /*--------------------------------------------------------------------------*/
     243    /* Parameter dependent functions (friends) */
     244#define _IN_CLASS_ 1
     245#define _IN_ADUB_ 1
     246#include <adolc/internal/paramfunc.h>
     247#undef _IN_ADUB_
     248#undef _IN_CLASS_
    351249
    352250    ~adub();
     
    364262class ADOLC_DLL_EXPORT adouble:public badouble {
    365263    friend ADOLC_DLL_EXPORT class advector;
     264    friend ADOLC_DLL_EXPORT class pdouble;
    366265protected:
    367266    void initInternal(void); // Init for late initialization
     
    384283    adouble& operator = ( const adouble& );
    385284    adouble& operator = ( const adub& );
     285    adouble& operator = (const pdouble&);
    386286   
    387287    inline locint loc(void) const;
    388288};
    389289
     290#include <adolc/param.h>
     291#include <adolc/advector.h>
    390292
    391293/****************************************************************************/
     
    492394
    493395
     396inline badouble& badouble::operator /= (const pdouble& p) {
     397    *this *= recipr(p);
     398    return *this;
     399}
    494400/****************************************************************************/
    495401/*                                                                THAT'S ALL*/
  • trunk/ADOL-C/include/adolc/adtl.h

    r515 r537  
    1919
    2020#include <ostream>
    21 #include <adolc/common.h>
     21#include <adolc/internal/common.h>
    2222#include <list>
    2323#include <stdexcept>
  • trunk/ADOL-C/include/adolc/advector.h

    r427 r537  
    2121#ifdef __cplusplus
    2222#include <vector>
    23 
    24 #include <adolc/adouble.h>
    2523
    2624/****************************************************************************/
     
    4745    friend ADOLC_DLL_EXPORT class adub;
    4846    friend ADOLC_DLL_EXPORT class advector;
     47    friend ADOLC_DLL_EXPORT class pdouble;
    4948protected:
    5049    locint location;
     
    8180    adubref& operator = ( const badouble& );
    8281    adubref& operator = ( const adubref& );
     82    adubref& operator = ( const pdouble& );
    8383    adubref& operator +=  ( double );
    8484    adubref& operator +=  ( const badouble& );
     85    adubref& operator +=  ( const pdouble& );
    8586    adubref& operator -=  ( double x );
    8687    adubref& operator -=  ( const badouble& );
     88    adubref& operator -=  ( const pdouble& );
    8789    adubref& operator *=  ( double x );
    8890    adubref& operator *=  ( const badouble& );
    89     adubref& operator /=  ( double x );
    90     adubref& operator /=  ( const badouble& );
     91    adubref& operator *=  ( const pdouble& );
     92    inline adubref& operator /=  ( double x );
     93    inline adubref& operator /=  ( const badouble& );
     94    inline adubref& operator /=  ( const pdouble&);
     95
    9196    adubref& operator <<= ( double );
    9297    void declareIndependent();
     
    124129};
    125130
     131inline adubref& adubref::operator /= (double y) {
     132    *this *=  (1.0/y);
     133    return *this;
     134}
     135
     136
     137inline adubref& adubref::operator /= (const badouble& y) {
     138    *this *=  (1.0/y);
     139    return *this;
     140}
     141
     142inline adubref& adubref::operator /= (const pdouble& p) {
     143    *this *= recipr(p);
     144    return *this;
     145}
    126146#endif /* TAPELESS */
    127147#endif /* __cplusplus */
  • trunk/ADOL-C/include/adolc/checkpointing.h

    r354 r537  
    1616#define ADOLC_CHECKPOINTING_H 1
    1717
    18 #include <adolc/common.h>
     18#include <adolc/internal/common.h>
    1919#include <adolc/adouble.h>
    2020
  • trunk/ADOL-C/include/adolc/convolut.h

    r354 r537  
    1717#define ADOLC_CONVOLUT_H 1
    1818
    19 #include <adolc/common.h>
     19#include <adolc/internal/common.h>
    2020
    2121BEGIN_C_DECLS
  • trunk/ADOL-C/include/adolc/drivers/drivers.h

    r354 r537  
    1818#define ADOLC_DRIVERS_DRIVERS_H 1
    1919
    20 #include <adolc/common.h>
     20#include <adolc/internal/common.h>
    2121
    2222BEGIN_C_DECLS
  • trunk/ADOL-C/include/adolc/drivers/odedrivers.h

    r354 r537  
    1818#define ADOLC_DRIVERS_ODEDRIVERS_H 1
    1919
    20 #include <adolc/common.h>
     20#include <adolc/internal/common.h>
    2121#include <adolc/interfaces.h>
    2222
  • trunk/ADOL-C/include/adolc/drivers/taylor.h

    r450 r537  
    1616#define ADOLC_DRIVERS_TAYLOR_H 1
    1717
    18 #include <adolc/common.h>
     18#include <adolc/internal/common.h>
    1919
    2020BEGIN_C_DECLS
  • trunk/ADOL-C/include/adolc/externfcts.h

    r439 r537  
    1717#define ADOLC_EXTERNFCTS_H 1
    1818
    19 #include <adolc/common.h>
     19#include <adolc/internal/common.h>
    2020#include <adolc/adouble.h>
    2121
  • trunk/ADOL-C/include/adolc/fixpoint.h

    r354 r537  
    1717#define ADOLC_FIXPOINT_H 1
    1818
    19 #include <adolc/common.h>
     19#include <adolc/internal/common.h>
    2020
    2121BEGIN_C_DECLS
  • trunk/ADOL-C/include/adolc/fortutils.h

    r354 r537  
    1717#define ADOLC_FORTUTILS_H 1
    1818
    19 #include <adolc/common.h>
     19#include <adolc/internal/common.h>
    2020
    2121/****************************************************************************/
  • trunk/ADOL-C/include/adolc/interfaces.h

    r469 r537  
    4747#define ADOLC_INTERFACES_H 1
    4848
    49 #include <adolc/common.h>
     49#include <adolc/internal/common.h>
    5050
    5151#if defined(SPARSE)
  • trunk/ADOL-C/include/adolc/internal/common.h

    r536 r537  
    8181/*--------------------------------------------------------------------------*/
    8282/* developer and user parameters */
    83 #include <adolc/dvlparms.h>
    84 #include <adolc/usrparms.h>
    85 #include <adolc/adolc_settings.h>
     83#include <adolc/internal/dvlparms.h>
     84#include <adolc/internal/usrparms.h>
     85#include <adolc/internal/adolc_settings.h>
    8686
    8787/*--------------------------------------------------------------------------*/
  • trunk/ADOL-C/include/adolc/internal/dvlparms.h

    r536 r537  
    4141/*--------------------------------------------------------------------------*/
    4242/* TAPE IDENTIFICATION (ADOLC & version check) */
    43 #define statSpace   40
    44 #define adolcIDSize  5
    45 /* NOTE: adolcIDSize + statSize <= statSpace required! */
     43#define statSpace   42
     44/* NOTE: ADOLC_ID and stats must fit in statSpace locints required!         */
    4645
    4746/*--------------------------------------------------------------------------*/
  • trunk/ADOL-C/include/adolc/revolve.h

    r354 r537  
    1616#define ADOLC_REVOLVE_H 1
    1717
    18 #include <adolc/common.h>
     18#include <adolc/internal/common.h>
    1919
    2020BEGIN_C_DECLS
  • trunk/ADOL-C/include/adolc/sparse/sparse_fo_rev.h

    r354 r537  
    1616#define ADOLC_SPARSE_SPARSE_H 1
    1717
    18 #include <adolc/common.h>
     18#include <adolc/internal/common.h>
    1919
    2020#if defined(__cplusplus)
  • trunk/ADOL-C/include/adolc/sparse/sparsedrivers.h

    r354 r537  
    1515#define ADOLC_SPARSE_SPARSE_H 1
    1616
    17 #include <adolc/common.h>
     17#include <adolc/internal/common.h>
    1818
    1919
  • trunk/ADOL-C/include/adolc/tapedoc/tapedoc.h

    r354 r537  
    1717#define ADOLC_TAPEDOC_TAPEDOC_H 1
    1818
    19 #include <adolc/common.h>
     19#include <adolc/internal/common.h>
    2020
    2121BEGIN_C_DECLS
  • trunk/ADOL-C/include/adolc/taping.h

    r522 r537  
    1717#define ADOLC_TAPING_H 1
    1818
    19 #include <adolc/common.h>
     19#include <adolc/internal/common.h>
    2020
    2121BEGIN_C_DECLS
     
    3939    NO_MIN_MAX,  /* no use of min_op, deferred to abs_op for piecewise stuff */
    4040    NUM_SWITCHES,                   /* # of abs calls that can switch branch */
     41    NUM_PARAM, /* no of parameters (doubles) interchangable without retaping */
    4142    STAT_SIZE                     /* represents the size of the stats vector */
    4243};
  • trunk/ADOL-C/src/Makefile.am

    r471 r537  
    5050                       externfcts.cpp checkpointing.cpp \
    5151                       fixpoint.cpp fov_offset_forward.c revolve.c \
    52                        advector.cpp adouble_tl.cpp
     52                       advector.cpp adouble_tl.cpp param.cpp
    5353
    5454if SPARSE
  • trunk/ADOL-C/src/advector.cpp

    r515 r537  
    1717#include <cmath>
    1818
    19 #include <adolc/advector.h>
     19#include <adolc/adouble.h>
    2020#include "oplate.h"
    2121#include "taping_p.h"
     
    345345}
    346346
    347 adubref& adubref::operator /= (double y) {
    348     *this *=  (1.0/y);
    349     return *this;
    350 }
    351 
    352 adubref& adubref::operator /= (const badouble& y) {
    353     *this *=  (1.0/y);
    354     return *this;
    355 }
    356 
    357347void condassign( adubref res,         const badouble &cond,
    358348                 const badouble &arg1, const badouble &arg2 ) {
  • trunk/ADOL-C/src/fo_rev.c

    r515 r537  
    556556                /*--------------------------------------------------------------------------*/
    557557            case start_of_tape:                                  /* start_of_tape */
     558                break;
    558559            case end_of_tape:                                      /* end_of_tape */
     560                discard_params_r();
    559561                break;
    560562
     
    641643                break;
    642644
     645                /*--------------------------------------------------------------------------*/
     646            case neg_sign_p:
     647            case recipr_p:
     648            case assign_p:            /* assign an adouble variable a    assign_d */
     649                /* double value. (=) */
     650                arg   = get_locint_r();
     651                res   = get_locint_r();
     652#if !defined(_NTIGHT_)
     653                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     654#endif /* !_NTIGHT_ */
     655
     656                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     657
     658                FOR_0_LE_l_LT_p
     659#if defined(_INT_REV_)                 
     660                ARES_INC = 0;
     661#else
     662                ARES_INC = 0.0;
     663#endif
     664
     665#if !defined(_NTIGHT_)
     666                ADOLC_GET_TAYLOR(res);
     667#endif /* !_NTIGHT_ */
     668                break;
    643669                /*--------------------------------------------------------------------------*/
    644670            case assign_d_zero:  /* assign an adouble variable a    assign_d_zero */
     
    711737
    712738                /*--------------------------------------------------------------------------*/
     739            case eq_plus_p:            /* Add a floating point to an    eq_plus_d */
     740                /* adouble. (+=) */
     741                arg   = get_locint_r();
     742                res   = get_locint_r();
     743#if !defined(_NTIGHT_)
     744                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     745
     746                ADOLC_GET_TAYLOR(res);
     747#endif /* !_NTIGHT_ */
     748                break;
     749
     750                /*--------------------------------------------------------------------------*/
    713751            case eq_plus_a:             /* Add an adouble to another    eq_plus_a */
    714752                /* adouble. (+=) */
     
    743781
    744782                /*--------------------------------------------------------------------------*/
     783            case eq_min_p:       /* Subtract a floating point from an    eq_min_d */
     784                /* adouble. (-=) */
     785                arg   = get_locint_r();
     786                res   = get_locint_r();
     787#if !defined(_NTIGHT_)
     788                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     789
     790                ADOLC_GET_TAYLOR(res);
     791#endif /* !_NTIGHT_ */
     792               break;
     793
     794                /*--------------------------------------------------------------------------*/
    745795            case eq_min_a:        /* Subtract an adouble from another    eq_min_a */
    746796                /* adouble. (-=) */
     
    784834
    785835                /*--------------------------------------------------------------------------*/
     836            case eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
     837                /* flaoting point. (*=) */
     838                arg   = get_locint_r();
     839                res   = get_locint_r();
     840#if !defined(_NTIGHT_)
     841                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     842#endif /* !_NTIGHT_ */
     843
     844#if!defined(_INT_REV_)
     845                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     846
     847                FOR_0_LE_l_LT_p
     848                ARES_INC *= coval;
     849#endif
     850
     851#if !defined(_NTIGHT_)
     852                ADOLC_GET_TAYLOR(res);
     853#endif /* !_NTIGHT_ */
     854                break;
     855
     856                /*--------------------------------------------------------------------------*/
    786857            case eq_mult_a:       /* Multiply one adouble by another    eq_mult_a */
    787858                /* (*=) */
     
    857928#if !defined(_NTIGHT_)
    858929                coval = get_val_r();
     930#endif /* !_NTIGHT_ */
     931
     932                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     933                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
     934
     935                FOR_0_LE_l_LT_p
     936                { aTmp = ARES;
     937#if defined(_INT_REV_)
     938                  ARES_INC = 0;
     939                  AARG_INC |= aTmp;
     940#else
     941                  ARES_INC = 0.0;
     942                  AARG_INC += aTmp;
     943#endif
     944            }
     945
     946#if !defined(_NTIGHT_)
     947                ADOLC_GET_TAYLOR(res);
     948#endif /* !_NTIGHT_ */
     949                break;
     950
     951                /*--------------------------------------------------------------------------*/
     952            case plus_a_p:             /* Add an adouble and a double    plus_a_p */
     953            case min_a_p:                /* Subtract an adouble from a    min_d_a */
     954                /* (+) */
     955                arg1  = get_locint_r();
     956                res   = get_locint_r();
     957                arg   = get_locint_r();
     958#if !defined(_NTIGHT_)
     959                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
    859960#endif /* !_NTIGHT_ */
    860961
     
    10501151
    10511152                /*--------------------------------------------------------------------------*/
     1153            case mult_a_p:         /* Multiply an adouble by a double    mult_a_p */
     1154                /* (*) */
     1155                arg1  = get_locint_r();
     1156                res   = get_locint_r();
     1157                arg   = get_locint_r();
     1158#if !defined(_NTIGHT_)
     1159                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     1160#endif /* !_NTIGHT_ */
     1161
     1162                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     1163                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
     1164
     1165                FOR_0_LE_l_LT_p
     1166                { aTmp = ARES;
     1167#if defined(_INT_REV_)
     1168                  ARES_INC = 0;
     1169                  AARG_INC |= aTmp;
     1170#else
     1171                  ARES_INC = 0.0;
     1172                  AARG_INC += (aTmp==0)?0:(coval * aTmp);
     1173#endif
     1174            }
     1175
     1176#if !defined(_NTIGHT_)
     1177                ADOLC_GET_TAYLOR(res);
     1178#endif /* !_NTIGHT_ */
     1179                break;
     1180
     1181                /*--------------------------------------------------------------------------*/
    10521182            case div_a_a:           /* Divide an adouble by an adouble    div_a_a */
    10531183                /* (/) */
     
    10901220#if !defined(_NTIGHT_)
    10911221                coval = get_val_r();
     1222#endif /* !_NTIGHT_ */
     1223
     1224                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     1225                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
     1226
     1227#if !defined(_NTIGHT_)
     1228                /* olvo 980922 changed order to allow x=d/x */
     1229                r0 = -TRES;
     1230                if (arg == res)
     1231                    ADOLC_GET_TAYLOR(arg);
     1232                r0 /= TARG;
     1233#endif /* !_NTIGHT_ */
     1234
     1235                FOR_0_LE_l_LT_p
     1236                { aTmp = ARES;
     1237#if defined(_INT_REV_)
     1238                  ARES_INC = 0;
     1239                  AARG_INC |= aTmp;
     1240#else
     1241                  ARES_INC = 0.0;
     1242                  AARG_INC += (aTmp==0)?0:(aTmp * r0);
     1243#endif
     1244                }
     1245
     1246#if !defined(_NTIGHT_)
     1247                if (arg != res)
     1248                ADOLC_GET_TAYLOR(res);
     1249#endif /* !_NTIGHT_ */
     1250                break;
     1251
     1252
     1253                /****************************************************************************/
     1254            case div_p_a:             /* Division double - adouble (/)    div_p_a */
     1255                arg1  = get_locint_r();
     1256                res   = get_locint_r();
     1257                arg   = get_locint_r();
     1258
     1259#if !defined(_NTIGHT_)
     1260                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
    10921261#endif /* !_NTIGHT_ */
    10931262
     
    13191488#if !defined(_NTIGHT_)
    13201489                coval = get_val_r();
     1490#endif /* !_NTIGHT_ */
     1491
     1492                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     1493                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
     1494
     1495#if !defined(_NTIGHT_)
     1496                /* olvo 980921 changed order to allow x=pow(x,n) */
     1497                r0 = TRES;
     1498                if (arg == res)
     1499                    ADOLC_GET_TAYLOR(arg);
     1500                if (TARG == 0.0)
     1501                    r0 = 0.0;
     1502                else
     1503                    r0 *= coval/TARG;
     1504#endif /* !_NTIGHT_ */
     1505
     1506                FOR_0_LE_l_LT_p {
     1507                    aTmp = ARES;
     1508#if defined(_INT_REV_)
     1509                    ARES_INC = 0;
     1510                    AARG_INC |= aTmp;
     1511#else
     1512                    ARES_INC = 0.0;
     1513                    AARG_INC += (aTmp==0)?0:(aTmp * r0);
     1514#endif
     1515            }
     1516
     1517#if !defined(_NTIGHT_)
     1518                ADOLC_GET_TAYLOR(res);
     1519#endif /* !_NTIGHT_ */
     1520                break;
     1521
     1522                /*--------------------------------------------------------------------------*/
     1523            case pow_op_p:                                                /* pow_op_p */
     1524                arg1  = get_locint_r();
     1525                res   = get_locint_r();
     1526                arg   = get_locint_r();
     1527#if !defined(_NTIGHT_)
     1528                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
    13211529#endif /* !_NTIGHT_ */
    13221530
     
    17511959            case lt_a_a:
    17521960            case gt_a_a:
     1961            case neq_a_p:
     1962            case eq_a_p:
     1963            case le_a_p:
     1964            case ge_a_p:
     1965            case lt_a_p:
     1966            case gt_a_p:
    17531967                res = get_locint_r();
    17541968                arg1 = get_locint_r();
     
    19102124                break;
    19112125
     2126            case ref_assign_p:            /* assign an adouble variable a    assign_p */
     2127                arg    = get_locint_r();
     2128                arg1   = get_locint_r();
     2129#if !defined(_NTIGHT_)
     2130                res = (size_t)trunc(fabs(TARG1));
     2131                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     2132
     2133                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     2134
     2135                FOR_0_LE_l_LT_p
     2136#if defined(_INT_REV_)                 
     2137                ARES_INC = 0;
     2138#else
     2139                ARES_INC = 0.0;
     2140#endif
     2141
     2142                ADOLC_GET_TAYLOR(res);
     2143#else
     2144                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     2145                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
     2146#endif /* !_NTIGHT_ */
     2147                break;
     2148
    19122149            case ref_assign_d_zero:  /* assign an adouble variable a    assign_d_zero */
    19132150            case ref_assign_d_one:   /* double value (0 or 1). (=)       assign_d_one */
     
    19952232                break;
    19962233
     2234            case ref_eq_plus_p:            /* Add a floating point to an    eq_plus_d */
     2235                /* adouble. (+=) */
     2236                arg    = get_locint_r();
     2237                arg1   = get_locint_r();
     2238#if !defined(_NTIGHT_)
     2239                res = (size_t)trunc(fabs(TARG1));
     2240                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     2241
     2242                ADOLC_GET_TAYLOR(res);
     2243#else
     2244                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     2245                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
     2246#endif /* !_NTIGHT_ */
     2247                break;
     2248
    19972249            case ref_eq_plus_a:             /* Add an adouble to another    eq_plus_a */
    19982250                /* adouble. (+=) */
     
    20342286               break;
    20352287
     2288            case ref_eq_min_p:       /* Subtract a floating point from an    eq_min_p */
     2289                /* adouble. (-=) */
     2290                arg    = get_locint_r();
     2291                arg1   = get_locint_r();
     2292#if !defined(_NTIGHT_)
     2293                res = (size_t)trunc(fabs(TARG1));
     2294                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     2295
     2296                ADOLC_GET_TAYLOR(res);
     2297#else
     2298                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     2299                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
     2300#endif /* !_NTIGHT_ */
     2301               break;
     2302
    20362303            case ref_eq_min_a:        /* Subtract an adouble from another    eq_min_a */
    20372304                /* adouble. (-=) */
     
    20642331                res = (size_t)trunc(fabs(TARG1));
    20652332                coval = get_val_r();
     2333
     2334#if !defined(_INT_REV_)
     2335                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
     2336
     2337                FOR_0_LE_l_LT_p
     2338                ARES_INC *= coval;
     2339#endif
     2340
     2341                ADOLC_GET_TAYLOR(res);
     2342#else
     2343                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     2344                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
     2345#endif /* !_NTIGHT_ */
     2346                break;
     2347
     2348            case ref_eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
     2349                /* flaoting point. (*=) */
     2350                arg    = get_locint_r();
     2351                arg1   = get_locint_r();
     2352#if !defined(_NTIGHT_)
     2353                res = (size_t)trunc(fabs(TARG1));
     2354                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    20662355
    20672356#if !defined(_INT_REV_)
  • trunk/ADOL-C/src/ho_rev.c

    r536 r537  
    616616                /*----------------------------------------------------------*/
    617617            case start_of_tape:                            /* start_of_tape */
     618                break;
    618619            case end_of_tape:                                /* end_of_tape */
     620                discard_params_r();
    619621                break;
    620622
     
    692694
    693695                /*----------------------------------------------------------*/
     696            case neg_sign_p:
     697            case recipr_p:
     698            case assign_p:      /* assign an adouble variable a    assign_d */
     699                /* double value. (=) */
     700                arg   = get_locint_r();
     701                res   = get_locint_r();
     702                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     703
     704                ASSIGN_A(Ares, rpp_A[res])
     705
     706                FOR_0_LE_l_LT_pk1
     707                ARES_INC = 0.0;
     708
     709                GET_TAYL(res,k,p)
     710                break;
     711
     712                /*----------------------------------------------------------*/
    694713            case assign_d_zero: /* assign an adouble a        assign_d_zero */
    695714            case assign_d_one:  /* double value. (=)           assign_d_one */
     
    756775            res   = get_locint_r();
    757776                coval = get_val_r();
     777
     778                GET_TAYL(res,k,p)
     779                break;
     780
     781                /*--------------------------------------------------------------------------*/
     782        case eq_plus_p:            /* Add a floating point to an    eq_plus_p */
     783            /* adouble. (+=) */
     784           arg   = get_locint_r();
     785           res   = get_locint_r();
     786                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    758787
    759788                GET_TAYL(res,k,p)
     
    794823
    795824                /*--------------------------------------------------------------------------*/
     825            case eq_min_p:       /* Subtract a floating point from an    eq_min_p */
     826                /* adouble. (-=) */
     827                arg   = get_locint_r();
     828                res   = get_locint_r();
     829                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     830
     831                GET_TAYL(res,k,p)
     832                break;
     833
     834                /*--------------------------------------------------------------------------*/
    796835            case eq_min_a:        /* Subtract an adouble from another    eq_min_a */
    797836                /* adouble. (-=) */
     
    822861                res   = get_locint_r();
    823862                coval = get_val_r();
     863
     864                ASSIGN_A(Ares, rpp_A[res])
     865
     866                FOR_0_LE_l_LT_p
     867                if ( 0 == ARES_INC )
     868                    HOV_INC(Ares, k)
     869                    else
     870                        FOR_0_LE_i_LT_k
     871                        ARES_INC *= coval;
     872
     873                GET_TAYL(res,k,p)
     874                break;
     875
     876                /*--------------------------------------------------------------------------*/
     877            case eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
     878                /* flaoting point. (*=) */
     879                arg   = get_locint_r();
     880                res   = get_locint_r();
     881                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    824882
    825883                ASSIGN_A(Ares, rpp_A[res])
     
    920978
    921979                /*--------------------------------------------------------------------------*/
     980            case plus_a_p:             /* Add an adouble and a double    plus_a_p */
     981            case min_a_p:                /* Subtract an adouble from a    min_a_p */
     982                /* (+) */
     983                arg1  = get_locint_r();
     984                res   = get_locint_r();
     985                arg   = get_locint_r();
     986                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     987
     988                ASSIGN_A(Ares, rpp_A[res])
     989                ASSIGN_A(Aarg, rpp_A[arg])
     990
     991                FOR_0_LE_l_LT_p
     992                if  (0 == ARES) {
     993                    HOV_INC(Ares, k1)
     994                    HOV_INC(Aarg, k1)
     995                } else {
     996                    aTmp = ARES;
     997                    ARES_INC = 0.0;
     998                    MAXDEC(AARG,aTmp);
     999                    AARG_INC_O;
     1000                    FOR_0_LE_i_LT_k
     1001                    { aTmp = ARES;
     1002                      ARES_INC = 0.0;
     1003                      AARG_INC += aTmp;
     1004                    }
     1005                }
     1006
     1007                GET_TAYL(res,k,p)
     1008                break;
     1009
     1010                /*--------------------------------------------------------------------------*/
    9221011            case plus_d_a:             /* Add an adouble and a double    plus_d_a */
    9231012                /* (+) */
     
    11801269
    11811270                /*--------------------------------------------------------------------------*/
     1271            case mult_a_p:         /* Multiply an adouble by a double    mult_a_p */
     1272                /* (*) */
     1273                arg1  = get_locint_r();
     1274                res   = get_locint_r();
     1275                arg   = get_locint_r();
     1276                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     1277
     1278                ASSIGN_A(Ares, rpp_A[res])
     1279                ASSIGN_A(Aarg, rpp_A[arg])
     1280
     1281                FOR_0_LE_l_LT_p
     1282                if (0 == ARES) {
     1283                    HOV_INC(Ares, k1)
     1284                    HOV_INC(Aarg, k1)
     1285                } else {
     1286                    aTmp = ARES;
     1287                    ARES_INC = 0.0;
     1288                    MAXDEC(AARG,aTmp);
     1289                    AARG_INC_O;
     1290                    FOR_0_LE_i_LT_k
     1291                    { aTmp = ARES;
     1292                      ARES_INC = 0.0;
     1293                      AARG_INC += coval * aTmp;
     1294                    }
     1295                }
     1296
     1297                GET_TAYL(res,k,p)
     1298                break;
     1299
     1300                /*--------------------------------------------------------------------------*/
    11821301            case div_a_a:           /* Divide an adouble by an adouble    div_a_a */
    11831302                /* (/) */
     
    12441363                arg   = get_locint_r();
    12451364                coval = get_val_r();
     1365
     1366                ASSIGN_A(Ares, rpp_A[res])
     1367                ASSIGN_A(Aarg, rpp_A[arg])
     1368                ASSIGN_T(Tres, rpp_T[res])
     1369                ASSIGN_T(Targ, rpp_T[arg])
     1370
     1371                /* olvo 980922 allows reflexive operation */
     1372                if (arg == res) {
     1373                    FOR_0_LE_l_LT_pk
     1374                    rp_Ttemp2[l] = Tres[l];
     1375                    Tres = rp_Ttemp2;
     1376                    GET_TAYL(arg,k,p)
     1377                }
     1378
     1379                VEC_COMPUTED_INIT
     1380                FOR_0_LE_l_LT_p
     1381                { if (0 == ARES) {
     1382                  HOV_INC(Ares, k1)
     1383                      HOV_INC(Aarg, k1)
     1384                  } else {
     1385                      aTmp = ARES;
     1386                      ARES_INC = 0.0;
     1387                      MAXDEC(AARG,aTmp);
     1388                      MAXDEC(AARG,3.0);
     1389                      AARG_INC_O;
     1390
     1391                      VEC_COMPUTED_CHECK
     1392                      recipr(k,1.0,Targ,rp_Ttemp);
     1393                      conv0(k, rp_Ttemp,
     1394                           Tres, rp_Atemp);
     1395                      VEC_COMPUTED_END
     1396                      deconvZeroR(k,Ares,rp_Atemp,Aarg);
     1397
     1398                      HOV_INC(Ares, k)
     1399                      HOV_INC(Aarg, k)
     1400                      HOS_OV_INC(Tres, k)
     1401                      HOS_OV_INC(Targ, k)
     1402                  }
     1403            }
     1404
     1405                if (arg != res)
     1406                GET_TAYL(res,k,p)
     1407                break;
     1408
     1409
     1410                /****************************************************************************/
     1411            case div_p_a:             /* Division double - adouble (/)    div_p_a */
     1412                arg1  = get_locint_r();
     1413                res   = get_locint_r();
     1414                arg   = get_locint_r();
     1415                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
    12461416
    12471417                ASSIGN_A(Ares, rpp_A[res])
     
    16241794
    16251795                /*--------------------------------------------------------------------------*/
     1796            case pow_op_p:                                                /* pow_op_p */
     1797                arg1  = get_locint_r();
     1798                res   = get_locint_r();
     1799                arg   = get_locint_r();
     1800                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     1801
     1802                ASSIGN_T(Targ, rpp_T[arg])
     1803                ASSIGN_T(Tres, rpp_T[res])
     1804                ASSIGN_A(Ares, rpp_A[res])
     1805                ASSIGN_A(Aarg, rpp_A[arg])
     1806
     1807                /* olvo 980921 allows reflexive operation */
     1808                if (arg == res) {
     1809                    FOR_0_LE_l_LT_pk
     1810                    rp_Ttemp2[l] = Tres[l];
     1811                    Tres = rp_Ttemp2;
     1812                    GET_TAYL(arg,k,p)
     1813                }
     1814
     1815                VEC_COMPUTED_INIT
     1816                FOR_0_LE_l_LT_p
     1817                if (0 == ARES) {
     1818                    HOV_INC(Aarg, k1)
     1819                    HOV_INC(Ares, k1)
     1820                } else {
     1821                    aTmp = ARES;
     1822                    ARES_INC = 0.0;
     1823                    MAXDEC(AARG,aTmp);
     1824                    MAXDEC(AARG,4.0);
     1825                    AARG_INC_O;
     1826
     1827                    VEC_COMPUTED_CHECK
     1828                    if (fabs(Targ[0]) > ADOLC_EPS) {
     1829                        divide(k,Tres,Targ,rp_Ttemp);
     1830                        for (i=0;i<k;i++) {
     1831                            rp_Ttemp[i] *= coval;
     1832                            /*                 printf(" EPS i %d %f\n",i,rp_Ttemp[i]); */
     1833                        }
     1834                        inconv0(k,Ares,rp_Ttemp,Aarg);
     1835                    } else {
     1836                        if (coval <= 0.0) {
     1837                            FOR_0_LE_i_LT_k
     1838                            {
     1839                                Aarg[i] = make_nan();
     1840                                Ares[i] = 0;
     1841                            }
     1842                        } else {
     1843                            /* coval not a whole number */
     1844                            if (coval - floor(coval) != 0) {
     1845                                i = 0;
     1846                                FOR_0_LE_i_LT_k
     1847                                {
     1848                                    if (coval - i > 1) {
     1849                                    Aarg[i] = 0;
     1850                                        Ares[i] = 0;
     1851                                    }
     1852                                    if ((coval - i < 1) && (coval - i > 0)) {
     1853                                    Aarg[i] = make_inf();
     1854                                        Ares[i] = 0;
     1855                                    }
     1856                                    if (coval - i < 0) {
     1857                                    Aarg[i] = make_nan();
     1858                                        Ares[i] = 0;
     1859                                    }
     1860                                }
     1861                            } else {
     1862                                if (coval == 1) {
     1863                                    FOR_0_LE_i_LT_k
     1864                                    { /* ! no tempory */
     1865                                        Aarg[i] += Ares[i];
     1866                                        Ares[i] = 0.0;
     1867                                    }
     1868                                } else {
     1869                                    /* coval is an int > 1 */
     1870                                    /* the following is not efficient but at least it works */
     1871                                    /* it reformulates x^n into x* ... *x n times */
     1872
     1873                                    copyAndZeroset(k,Ares,rp_Atemp);
     1874                                    inconv(k,rp_Atemp,Targ,Aarg);
     1875                                    inconv(k,rp_Atemp,Targ,Aarg);
     1876                                    if (coval == 3) {
     1877                                        conv(k,Aarg,Targ,rp_Atemp);
     1878                                        FOR_0_LE_i_LT_k
     1879                                        Aarg[i] = 2.0 * rp_Atemp[i];
     1880                                   }
     1881                                }
     1882                            }
     1883                        }
     1884                    }
     1885                    VEC_COMPUTED_END
     1886
     1887                    HOV_INC(Ares, k)
     1888                    HOV_INC(Aarg, k)
     1889                    HOS_OV_INC(Tres, k)
     1890                    HOS_OV_INC(Targ, k)
     1891                }
     1892
     1893                GET_TAYL(res,k,p)
     1894                break;
     1895
     1896                /*--------------------------------------------------------------------------*/
    16261897            case sqrt_op:                                              /* sqrt_op */
    16271898                res = get_locint_r();
     
    20682339            case lt_a_a:
    20692340            case gt_a_a:
     2341            case neq_a_p:
     2342            case eq_a_p:
     2343            case le_a_p:
     2344            case ge_a_p:
     2345            case lt_a_p:
     2346            case gt_a_p:
    20702347                res = get_locint_r();
    20712348                arg1 = get_locint_r();
     
    21992476                break;
    22002477
     2478            case ref_assign_p:
     2479                arg    = get_locint_r();
     2480                arg1   = get_locint_r();
     2481                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     2482
     2483                ASSIGN_T(Targ1, rpp_T[arg1])
     2484                res = (size_t)trunc(fabs(TARG1));
     2485
     2486                ASSIGN_A(Ares, rpp_A[res])
     2487
     2488                FOR_0_LE_l_LT_pk1
     2489                ARES_INC = 0.0;
     2490
     2491                GET_TAYL(res,k,p)
     2492                break;
     2493
    22012494            case ref_assign_a:     /* assign an adouble variable an    assign_a */
    22022495                /* adouble value. (=) */
     
    22562549                res = (size_t)trunc(fabs(TARG1));
    22572550                coval = get_val_r();
     2551
     2552                GET_TAYL(res,k,p)
     2553                break;
     2554
     2555        case ref_eq_plus_p:            /* Add a floating point to an    eq_plus_d */
     2556            /* adouble. (+=) */
     2557                arg    = get_locint_r();
     2558                arg1   = get_locint_r();
     2559                ASSIGN_T(Targ1, rpp_T[arg1])
     2560                res = (size_t)trunc(fabs(TARG1));
     2561                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    22582562
    22592563                GET_TAYL(res,k,p)
  • trunk/ADOL-C/src/oplate.h

    r439 r537  
    102102  ref_cond_assign,
    103103  ref_cond_assign_s,
     104  assign_p = 98,
     105  eq_plus_p,
     106  eq_min_p,
     107  eq_mult_p,
     108  ref_assign_p,
     109  ref_eq_plus_p,
     110  ref_eq_min_p,
     111  ref_eq_mult_p,
     112  plus_a_p,
     113  min_a_p,
     114  mult_a_p,
     115  div_p_a,
     116  pow_op_p,
     117  neg_sign_p,
     118  recipr_p,
     119  eq_a_p = 119,
     120  neq_a_p,
     121  le_a_p,
     122  gt_a_p,
     123  ge_a_p,
     124  lt_a_p,
    104125  eq_a_a = 125,
    105126  neq_a_a,
     
    108129  ge_a_a,
    109130  lt_a_a,
    110   ampi_send,
     131  ampi_send = 131,
    111132  ampi_recv,
    112133  ampi_isend,
  • trunk/ADOL-C/src/sparse/sparsedrivers.cpp

    r515 r537  
    344344      setTapeInfoJacSparse(tag, sJinfos);
    345345      tapeInfos=getTapeInfos(tag);
    346       memcpy(&ADOLC_CURRENT_TAPE_INFOS, tapeInfos, sizeof(TapeInfos));
     346      ADOLC_CURRENT_TAPE_INFOS.copy(*tapeInfos);
    347347    }
    348348    else
    349349      {
    350350        tapeInfos=getTapeInfos(tag);
    351         memcpy(&ADOLC_CURRENT_TAPE_INFOS, tapeInfos, sizeof(TapeInfos));
     351        ADOLC_CURRENT_TAPE_INFOS.copy(*tapeInfos);
    352352        sJinfos.depen    = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.sJinfos.depen;
    353353        sJinfos.nnz_in    = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.sJinfos.nnz_in;
     
    482482          {
    483483            tapeInfos=getTapeInfos(tag);
    484             memcpy(&ADOLC_CURRENT_TAPE_INFOS, tapeInfos, sizeof(TapeInfos));
     484            ADOLC_CURRENT_TAPE_INFOS.copy(*tapeInfos);
    485485            if (indep != ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.sHinfos.indep) {
    486486                fprintf(DIAG_OUT,"ADOL-C Error: wrong number of independents stored in hessian pattern.\n");
     
    539539
    540540        tapeInfos=getTapeInfos(tag);
    541         memcpy(&ADOLC_CURRENT_TAPE_INFOS, tapeInfos, sizeof(TapeInfos));
     541        ADOLC_CURRENT_TAPE_INFOS.copy(*tapeInfos);
    542542
    543543    }
     
    545545      {
    546546        tapeInfos=getTapeInfos(tag);
    547         memcpy(&ADOLC_CURRENT_TAPE_INFOS, tapeInfos, sizeof(TapeInfos));
     547        ADOLC_CURRENT_TAPE_INFOS.copy(*tapeInfos);
    548548        sHinfos.nnz_in = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.sHinfos.nnz_in;
    549549        sHinfos.HP     = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.sHinfos.HP;
     
    665665
    666666    tapeInfos=getTapeInfos(tag);
    667     memcpy(&ADOLC_CURRENT_TAPE_INFOS, tapeInfos, sizeof(TapeInfos));
     667    ADOLC_CURRENT_TAPE_INFOS.copy(*tapeInfos);
    668668    sHinfos.nnz_in = 0;
    669669    deepcopy_HP(&sHinfos.HP,HP,indep);
     
    698698
    699699    tapeInfos=getTapeInfos(tag);
    700     memcpy(&ADOLC_CURRENT_TAPE_INFOS, tapeInfos, sizeof(TapeInfos));
     700    ADOLC_CURRENT_TAPE_INFOS.copy(*tapeInfos);
    701701    deepcopy_HP(HP,ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.sHinfos.HP,indep);
    702702}
  • trunk/ADOL-C/src/tape_handling.cpp

    r515 r537  
    4646  numLives = 0;
    4747  nominmaxFlag = 0;
     48  pStore = NULL;
     49  numparam = 0;
     50  maxparam = 0;
    4851  storeManagerPtr = new StoreManagerLocintBlock(store, storeSize, numLives);
     52  paramStoreMgrPtr = new StoreManagerLocintBlock(pStore, maxparam, numparam);
    4953}
    5054
    5155GlobalTapeVarsCL::~GlobalTapeVarsCL() {
    52   if (storeManagerPtr) {
     56  if (storeManagerPtr != NULL) {
    5357    delete storeManagerPtr;
    5458    storeManagerPtr = NULL;
     59  }
     60  if (paramStoreMgrPtr != NULL) {
     61      delete paramStoreMgrPtr;
     62      paramStoreMgrPtr = NULL;
    5563  }
    5664}
     
    7280    memcpy(store, gtv.store, storeSize*sizeof(double));
    7381    storeManagerPtr = new
    74         StoreManagerLocintBlock(
    75             dynamic_cast<StoreManagerLocintBlock*>(gtv.storeManagerPtr),
    76             store, storeSize, numLives);
     82        StoreManagerLocintBlock(
     83            dynamic_cast<StoreManagerLocintBlock*>(gtv.storeManagerPtr),
     84            store, storeSize, numLives);
     85    paramStoreMgrPtr = new
     86        StoreManagerLocintBlock(
     87            dynamic_cast<StoreManagerLocintBlock*>(gtv.paramStoreMgrPtr),
     88            pStore, maxparam, numparam);
    7789    return *this;
    7890}
     
    275287/* inits the struct for the new tape */
    276288void initTapeInfos(TapeInfos *newTapeInfos) {
    277     char *ptr;
    278 
    279     ptr = (char *)newTapeInfos;
    280     for (unsigned int i = 0; i < sizeof(TapeInfos) -
    281             sizeof(PersistantTapeInfos); ++i) ptr[i] = 0;
     289    char *ptr, *end;
     290
     291    ptr = (char *)(&newTapeInfos->tapeID);
     292    end = (char *)(&newTapeInfos->pTapeInfos);
     293    for ( ; ptr != end ; ptr++ )
     294        *ptr = 0;
    282295}
    283296
     
    403416    /* update tapeStack and save tapeInfos */
    404417    if (ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr != NULL) {
    405         memcpy(ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr,
    406                 &ADOLC_CURRENT_TAPE_INFOS, sizeof(TapeInfos));
     418        ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr->copy(
     419            ADOLC_CURRENT_TAPE_INFOS);
    407420        ADOLC_TAPE_STACK.push(ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr);
    408421    } else {
    409         memcpy(&ADOLC_CURRENT_TAPE_INFOS_FALLBACK,
    410                 &ADOLC_CURRENT_TAPE_INFOS, sizeof(TapeInfos));
     422        ADOLC_CURRENT_TAPE_INFOS_FALLBACK.copy(
     423                ADOLC_CURRENT_TAPE_INFOS);
    411424        ADOLC_TAPE_STACK.push(&ADOLC_CURRENT_TAPE_INFOS_FALLBACK);
    412425    }
     
    416429
    417430    /* set the new tape infos as current */
    418     memcpy(&ADOLC_CURRENT_TAPE_INFOS, newTapeInfos, sizeof(TapeInfos));
     431    ADOLC_CURRENT_TAPE_INFOS.copy(*newTapeInfos);
    419432    ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr = newTapeInfos;
    420433
     
    450463               }
    451464                if (ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr != NULL) {
    452                     memcpy(ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr,
    453                             &ADOLC_CURRENT_TAPE_INFOS, sizeof(TapeInfos));
     465                    ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr->copy(
     466                            ADOLC_CURRENT_TAPE_INFOS);
    454467                    ADOLC_TAPE_STACK.push(
    455468                            ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr);
    456469                } else {
    457                     memcpy(&ADOLC_CURRENT_TAPE_INFOS_FALLBACK,
    458                             &ADOLC_CURRENT_TAPE_INFOS, sizeof(TapeInfos));
     470                    ADOLC_CURRENT_TAPE_INFOS_FALLBACK.copy(
     471                            ADOLC_CURRENT_TAPE_INFOS);
    459472                    ADOLC_TAPE_STACK.push(&ADOLC_CURRENT_TAPE_INFOS_FALLBACK);
    460473                }
    461                 memcpy(&ADOLC_CURRENT_TAPE_INFOS, *tiIter, sizeof(TapeInfos));
     474                ADOLC_CURRENT_TAPE_INFOS.copy(**tiIter);
    462475                ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr = *tiIter;
    463476                return;
     
    482495    /* update tapeStack and save tapeInfos */
    483496    if (ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr != NULL) {
    484         memcpy(ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr,
    485                 &ADOLC_CURRENT_TAPE_INFOS, sizeof(TapeInfos));
     497        ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr->copy(
     498                ADOLC_CURRENT_TAPE_INFOS);
    486499        ADOLC_TAPE_STACK.push(ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr);
    487500    } else {
    488         memcpy(&ADOLC_CURRENT_TAPE_INFOS_FALLBACK,
    489                 &ADOLC_CURRENT_TAPE_INFOS, sizeof(TapeInfos));
     501        ADOLC_CURRENT_TAPE_INFOS_FALLBACK.copy(
     502                ADOLC_CURRENT_TAPE_INFOS);
    490503        ADOLC_TAPE_STACK.push(&ADOLC_CURRENT_TAPE_INFOS_FALLBACK);
    491504    }
    492505
    493506    /* set the new tape infos as current */
    494     memcpy(&ADOLC_CURRENT_TAPE_INFOS, tempTapeInfos, sizeof(TapeInfos));
     507    ADOLC_CURRENT_TAPE_INFOS.copy(*tempTapeInfos);
    495508    ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr = tempTapeInfos;
    496509}
     
    510523    }
    511524
    512     memcpy(ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr,
    513             &ADOLC_CURRENT_TAPE_INFOS, sizeof(TapeInfos));
     525    ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr->copy(
     526            ADOLC_CURRENT_TAPE_INFOS);
    514527    ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr = ADOLC_TAPE_STACK.top();
    515     memcpy(&ADOLC_CURRENT_TAPE_INFOS,
    516             ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr, sizeof(TapeInfos));
     528    ADOLC_CURRENT_TAPE_INFOS.copy(
     529            *ADOLC_GLOBAL_TAPE_VARS.currentTapeInfosPtr);
    517530    ADOLC_TAPE_STACK.pop();
    518531    if (ADOLC_TAPE_STACK.empty())
     
    680693    ADOLC_OPENMP_GET_THREAD_NUMBER;
    681694
    682     vector<TapeInfos *>::iterator tiIter;
    683     if (!ADOLC_TAPE_INFOS_BUFFER.empty()) {
    684         for (tiIter=ADOLC_TAPE_INFOS_BUFFER.begin();
    685                 tiIter!=ADOLC_TAPE_INFOS_BUFFER.end();
    686                 ++tiIter)
     695    TapeInfos** tiIter;
     696    while (!ADOLC_TAPE_INFOS_BUFFER.empty()) {
     697        tiIter = &ADOLC_TAPE_INFOS_BUFFER.back();
     698        ADOLC_TAPE_INFOS_BUFFER.pop_back();
    687699        {
    688700            /* close open files though they may be incomplete */
     
    792804
    793805            delete *tiIter;
     806            *tiIter = NULL;
    794807        }
    795808    }
     
    800813        delete[] ADOLC_GLOBAL_TAPE_VARS.store;
    801814        ADOLC_GLOBAL_TAPE_VARS.store = NULL;
     815    }
     816    if (ADOLC_GLOBAL_TAPE_VARS.pStore != NULL) {
     817        delete[] ADOLC_GLOBAL_TAPE_VARS.pStore;
     818        ADOLC_GLOBAL_TAPE_VARS.pStore = NULL;
    802819    }
    803820
     
    11571174#endif /* _OPENMP */
    11581175
    1159 static void clearPersistantTapeInfos(TapeInfos* newTapeInfos) {
    1160     char *ptr;
    1161     ptr = (char*) &(newTapeInfos->pTapeInfos);
    1162     for (unsigned int i=0; i < sizeof(PersistantTapeInfos); ++i)
    1163         ptr[i] = 0;
    1164 }
    1165 
    1166 TapeInfos::TapeInfos() {
     1176TapeInfos::TapeInfos() : pTapeInfos() {
    11671177    initTapeInfos(this);
    1168     clearPersistantTapeInfos(this);
    1169 }
    1170 
    1171 TapeInfos::TapeInfos(short _tapeID) {
     1178}
     1179
     1180TapeInfos::TapeInfos(short _tapeID) : pTapeInfos() {
    11721181    initTapeInfos(this);
    1173     clearPersistantTapeInfos(this);
    11741182    tapeID = _tapeID;
    11751183    pTapeInfos.op_fileName = createFileName(tapeID, OPERATIONS_TAPE);
     
    11771185    pTapeInfos.val_fileName = createFileName(tapeID, VALUES_TAPE);
    11781186    pTapeInfos.tay_fileName = NULL;
     1187}
     1188
     1189void TapeInfos::copy(const TapeInfos& tInfos) {
     1190    char *ptr, *end;
     1191    char const* tIptr = (char const*)(&tInfos.tapeID);
     1192
     1193    ptr = (char *)(&this->tapeID);
     1194    end = (char *)(&this->pTapeInfos);
     1195    for ( ; ptr != end ; ptr++, tIptr++ )
     1196        *ptr = *tIptr;
     1197    this->pTapeInfos.copy(tInfos.pTapeInfos);
     1198}
     1199
     1200PersistantTapeInfos::PersistantTapeInfos() {
     1201    char *ptr = (char*)(&forodec_nax), *end = (char*)(&paramstore);
     1202    for (; ptr != end ; ptr++ )
     1203        *ptr = 0;
     1204    paramstore = NULL;
     1205}
     1206
     1207void PersistantTapeInfos::copy(const PersistantTapeInfos& pTInfos) {
     1208    char *ptr = (char*)(&this->forodec_nax), *end = (char*)(&this->paramstore);
     1209    char const* pTIptr = (char const*)(&pTInfos.forodec_nax);
     1210    for (; ptr != end ; ptr++, pTIptr++ )
     1211        *ptr = *pTIptr;
     1212    paramstore = pTInfos.paramstore;
     1213}
     1214
     1215PersistantTapeInfos::~PersistantTapeInfos() {
     1216    if (paramstore != NULL) {
     1217        free(paramstore);
     1218        paramstore = NULL;
     1219    }
    11791220}
    11801221
     
    11981239    std::cerr << "StoreManagerIntegerBlock::~StoreManagerIntegerBlock()\n";
    11991240#endif
    1200     if (storePtr) {
     1241    if (storePtr != NULL) {
    12011242     delete[] storePtr;
    1202      storePtr = 0;
     1243     storePtr = NULL;
    12031244    }
    12041245    if (!indexFree.empty() ) {
     
    15001541    throw FatalError(errorcode, what, function, file, line);
    15011542}
     1543
     1544/* Only called during stop_trace() via save_params() */
     1545void free_all_taping_params() {
     1546    size_t np;
     1547    ADOLC_OPENMP_THREAD_NUMBER;
     1548    ADOLC_OPENMP_GET_THREAD_NUMBER;
     1549
     1550    np = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_PARAM];
     1551    while ( np > 0 )
     1552        ADOLC_GLOBAL_TAPE_VARS.paramStoreMgrPtr->free_loc(--np);
     1553}
  • trunk/ADOL-C/src/taping.c

    r534 r537  
    3030#endif
    3131
     32#include <adolc/param.h>
     33
    3234#if defined(_WINDOWS) && !__STDC__
    3335#define stat _stat
     
    4648 * => to work with older tapes use older ADOL-C version */
    4749#define ADOLC_NEW_TAPE_VERSION 2
    48 #define ADOLC_NEW_TAPE_SUBVERSION 3
    49 #define ADOLC_NEW_TAPE_PATCHLEVEL 0
     50#define ADOLC_NEW_TAPE_SUBVERSION 5
     51#define ADOLC_NEW_TAPE_PATCHLEVEL 2
    5052
    5153/****************************************************************************/
     
    7779            fprintf(DIAG_OUT, "ADOL-C error: "
    7880                    "reading integer tape number %d!\n",
     81                    failAdditionalInfo1);
     82            printError();
     83            break;
     84        case ADOLC_VALUE_TAPE_FOPEN_FAILED:
     85        case ADOLC_VALUE_TAPE_FREAD_FAILED:
     86            fprintf(DIAG_OUT, "ADOL-C error: "
     87                    "reading value tape number %d!\n",
    7988                    failAdditionalInfo1);
    8089            printError();
     
    11021111}
    11031112
     1113static void save_params() {
     1114    size_t np;
     1115    size_t ip, avail, remain, chunk;
     1116    ADOLC_OPENMP_THREAD_NUMBER;
     1117    ADOLC_OPENMP_GET_THREAD_NUMBER;
     1118
     1119    ADOLC_CURRENT_TAPE_INFOS.stats[NUM_PARAM] =
     1120        ADOLC_GLOBAL_TAPE_VARS.numparam;
     1121    if (ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore == NULL)
     1122        ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore =
     1123            malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_PARAM]*sizeof(double));
     1124    memcpy(ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore,
     1125           ADOLC_GLOBAL_TAPE_VARS.pStore,
     1126           ADOLC_CURRENT_TAPE_INFOS.stats[NUM_PARAM]*sizeof(double));
     1127    free_all_taping_params();
     1128    if (ADOLC_CURRENT_TAPE_INFOS.currVal +
     1129        ADOLC_CURRENT_TAPE_INFOS.stats[NUM_PARAM] <
     1130        ADOLC_CURRENT_TAPE_INFOS.lastValP1)
     1131        put_vals_notWriteBlock(ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore,
     1132                               ADOLC_CURRENT_TAPE_INFOS.stats[NUM_PARAM]);
     1133    else {
     1134        np = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_PARAM];
     1135        ip = 0;
     1136        while (ip < np) {
     1137            avail = ADOLC_CURRENT_TAPE_INFOS.lastValP1 - ADOLC_CURRENT_TAPE_INFOS.currVal;
     1138            remain = np - ip;
     1139            chunk = (avail<remain)?avail:remain;
     1140            put_vals_notWriteBlock(ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore + ip, chunk);
     1141            ip += chunk;
     1142            if (ip < np)
     1143                put_val_block(ADOLC_CURRENT_TAPE_INFOS.lastValP1);
     1144        }
     1145    }
     1146}
     1147
    11041148/****************************************************************************/
    11051149/* Stop Tracing.  Clean up, and turn off trace_flag.                        */
     
    11091153    ADOLC_OPENMP_GET_THREAD_NUMBER;
    11101154    put_op(end_of_tape);        /* Mark end of tape. */
     1155    save_params();
    11111156
    11121157    ADOLC_CURRENT_TAPE_INFOS.stats[NUM_INDEPENDENTS] =
     
    12901335    fprintf(stream, "Number of locations:    %10zu\n", stats[NUM_LOCATIONS]);
    12911336    fprintf(stream, "Number of values:       %10zu\n", stats[NUM_VALUES]);
     1337    fprintf(stream, "Number of parameters:   %10zu\n", stats[NUM_PARAM]);
    12921338    fprintf(stream, "\n");
    12931339    fprintf(stream, "Operation file written: %10zu\n", stats[OP_FILE_ACCESS]);
     
    13091355
    13101356/****************************************************************************/
     1357/* Returns the number of parameters recorded on tape                        */
     1358/****************************************************************************/
     1359size_t get_num_param(short tag) {
     1360    TapeInfos *tapeInfos;
     1361    tapeInfos = getTapeInfos(tag);
     1362    return tapeInfos->stats[NUM_PARAM];
     1363}
     1364
     1365/****************************************************************************/
     1366/* Reads parameters from the end of value tape for disk based tapes         */
     1367/****************************************************************************/
     1368static void read_params(TapeInfos* tapeInfos) {
     1369    FILE* val_file;
     1370    int i, chunks;
     1371    size_t number, remain, chunkSize, nVT;
     1372    double *valBuffer = NULL, *currVal = NULL, *lastValP1 = NULL;
     1373    size_t np, ip, avail, rsize;
     1374    if (tapeInfos->pTapeInfos.paramstore == NULL)
     1375        tapeInfos->pTapeInfos.paramstore =
     1376            malloc(tapeInfos->stats[NUM_PARAM]*sizeof(double));
     1377    valBuffer = (double*)
     1378        malloc(tapeInfos->stats[VAL_BUFFER_SIZE] *sizeof(double));
     1379    lastValP1 = valBuffer + tapeInfos->stats[VAL_BUFFER_SIZE];
     1380    if ((val_file = fopen(tapeInfos->pTapeInfos.val_fileName, "rb")) == NULL)
     1381        fail(ADOLC_VALUE_TAPE_FOPEN_FAILED);
     1382    number = (tapeInfos->stats[NUM_VALUES] /
     1383              tapeInfos->stats[VAL_BUFFER_SIZE]) *
     1384        tapeInfos->stats[VAL_BUFFER_SIZE];
     1385    fseek(val_file, number * sizeof(double), SEEK_SET);
     1386    number = tapeInfos->stats[NUM_VALUES] % tapeInfos->stats[VAL_BUFFER_SIZE];
     1387    if (number != 0) {
     1388        chunkSize = ADOLC_IO_CHUNK_SIZE / sizeof(double);
     1389        chunks = number / chunkSize;
     1390        for (i = 0; i < chunks; ++i)
     1391            if (fread(valBuffer + i * chunkSize, chunkSize * sizeof(double), 1,
     1392                      val_file) != 1 )
     1393                fail(ADOLC_VALUE_TAPE_FREAD_FAILED);
     1394        remain = number % chunkSize;
     1395        if (remain != 0)
     1396            if (fread(valBuffer + chunks * chunkSize, remain * sizeof(double), 1,
     1397                      val_file) != 1)
     1398                fail(ADOLC_VALUE_TAPE_FREAD_FAILED);
     1399    }
     1400    nVT = tapeInfos->stats[NUM_VALUES] - number;
     1401    currVal = valBuffer + number;
     1402    np = tapeInfos->stats[NUM_PARAM];
     1403    ip = np;
     1404    while ( ip > 0) {
     1405        avail = currVal - valBuffer;
     1406        rsize = (avail<ip)?avail:ip;
     1407        for ( i = 0; i < rsize; i++ )
     1408            tapeInfos->pTapeInfos.paramstore[--ip] = *--currVal;
     1409        if (ip > 0) {
     1410            number = tapeInfos->stats[VAL_BUFFER_SIZE];
     1411            fseek(val_file, sizeof(double)*(nVT - number), SEEK_SET);
     1412            chunkSize = ADOLC_IO_CHUNK_SIZE / sizeof(double);
     1413            chunks = number / chunkSize;
     1414            for (i = 0; i < chunks; ++i)
     1415                if (fread(valBuffer + i * chunkSize, chunkSize * sizeof(double), 1,
     1416                          val_file) != 1 )
     1417                    fail(ADOLC_VALUE_TAPE_FREAD_FAILED);
     1418            remain = number % chunkSize;
     1419            if (remain != 0)
     1420                if (fread(valBuffer + chunks * chunkSize, remain * sizeof(double), 1,
     1421                          val_file) != 1)
     1422                    fail(ADOLC_VALUE_TAPE_FREAD_FAILED);
     1423            nVT -= number;
     1424            currVal = lastValP1;
     1425        }
     1426    }
     1427    fclose(val_file);
     1428    free(valBuffer);
     1429}
     1430
     1431/****************************************************************************/
     1432/* Overrides the parameters for the next evaluations. This will invalidate  */
     1433/* the taylor stack, so next reverse call will fail, if not preceeded by a  */
     1434/* forward call after setting the parameters.                               */
     1435/****************************************************************************/
     1436void set_param_vec(short tag, size_t numparam, revreal* paramvec) {
     1437    size_t i;
     1438    ADOLC_OPENMP_THREAD_NUMBER;
     1439    ADOLC_OPENMP_GET_THREAD_NUMBER;
     1440
     1441    /* mark possible (hard disk) tape creation */
     1442    markNewTape();
     1443
     1444    /* make room for tapeInfos and read tape stats if necessary, keep value
     1445     * stack information */
     1446    openTape(tag, ADOLC_FORWARD);
     1447    if (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_PARAM] != numparam) {
     1448        fprintf(DIAG_OUT, "ADOL-C error: Setting parameters on tape %d "
     1449                "aborted!\nNumber of parameters (%zu) passed"
     1450                " is inconsistent with number recorded on tape (%zu)\n",
     1451                tag, numparam, ADOLC_CURRENT_TAPE_INFOS.stats[NUM_PARAM]);
     1452        adolc_exit(-1,"",__func__,__FILE__,__LINE__);
     1453    }
     1454    if (ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore == NULL)
     1455        ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore = (double*)
     1456            malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_PARAM]*sizeof(double));
     1457    for(i = 0; i < ADOLC_CURRENT_TAPE_INFOS.stats[NUM_PARAM]; i++)
     1458        ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[i] = paramvec[i];
     1459    taylor_close(0);
     1460    releaseTape();
     1461}
     1462
     1463/****************************************************************************/
    13111464/* Does the actual reading from the hard disk into the stats buffer         */
    13121465/****************************************************************************/
     
    13501503    fclose(loc_file);
    13511504    tapeInfos->tapingComplete = 1;
     1505    if (tapeInfos->stats[NUM_PARAM] > 0)
     1506        read_params(tapeInfos);
    13521507}
    13531508
     
    16871842            fopen(ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.op_fileName, "rb");
    16881843        if (ADOLC_CURRENT_TAPE_INFOS.op_file != NULL) {
    1689             #if defined(ADOLC_DEBUG)
     1844#if defined(ADOLC_DEBUG)
    16901845            fprintf(DIAG_OUT, "ADOL-C debug: Old tapefile %s gets removed!\n",
    16911846                    ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.op_fileName);
    1692             #endif
     1847#endif
    16931848            fclose(ADOLC_CURRENT_TAPE_INFOS.op_file);
    16941849            ADOLC_CURRENT_TAPE_INFOS.op_file = NULL;
     
    20732228
    20742229/****************************************************************************/
     2230/* Discards parameters from the end of value tape during reverse mode       */
     2231/****************************************************************************/
     2232void discard_params_r(void) {
     2233    size_t i, np, ip, avail, rsize, chunks;
     2234    size_t number, remain, chunkSize;
     2235    ADOLC_OPENMP_THREAD_NUMBER;
     2236    ADOLC_OPENMP_GET_THREAD_NUMBER;
     2237    np = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_PARAM];
     2238    ip = np;
     2239    while ( ip > 0 ) {
     2240        avail = ADOLC_CURRENT_TAPE_INFOS.currVal - ADOLC_CURRENT_TAPE_INFOS.valBuffer;
     2241        rsize = (avail<ip)?avail:ip;
     2242        ip -= rsize;
     2243        ADOLC_CURRENT_TAPE_INFOS.currVal -= rsize;
     2244        if ( ip > 0 ) {
     2245            number = ADOLC_CURRENT_TAPE_INFOS.stats[VAL_BUFFER_SIZE];
     2246            fseek(ADOLC_CURRENT_TAPE_INFOS.val_file, sizeof(double) *
     2247                (ADOLC_CURRENT_TAPE_INFOS.numVals_Tape - number), SEEK_SET);
     2248            chunkSize = ADOLC_IO_CHUNK_SIZE / sizeof(double);
     2249            chunks = number / chunkSize;
     2250            for (i = 0; i < chunks; ++i)
     2251                if (fread(ADOLC_CURRENT_TAPE_INFOS.valBuffer +
     2252                i * chunkSize, chunkSize * sizeof(double), 1,
     2253                ADOLC_CURRENT_TAPE_INFOS.val_file) != 1)
     2254                    fail(ADOLC_EVAL_VAL_TAPE_READ_FAILED);
     2255            remain = number % chunkSize;
     2256            if (remain != 0)
     2257                if (fread(ADOLC_CURRENT_TAPE_INFOS.valBuffer +
     2258                chunks * chunkSize, remain * sizeof(double), 1,
     2259                ADOLC_CURRENT_TAPE_INFOS.val_file) != 1)
     2260                    fail(ADOLC_EVAL_VAL_TAPE_READ_FAILED);
     2261            ADOLC_CURRENT_TAPE_INFOS.numVals_Tape -= number;
     2262            ADOLC_CURRENT_TAPE_INFOS.currVal =
     2263                ADOLC_CURRENT_TAPE_INFOS.lastValP1;
     2264        }
     2265    }
     2266}
     2267
     2268/****************************************************************************/
    20752269/* Returns a pointer to the first element of a values vector and skips the  */
    20762270/* vector. -- Forward Mode --                                               */
  • trunk/ADOL-C/src/taping_p.h

    r515 r537  
    7575    ADOLC_INTEGER_TAPE_FOPEN_FAILED,
    7676    ADOLC_INTEGER_TAPE_FREAD_FAILED,
     77    ADOLC_VALUE_TAPE_FOPEN_FAILED,
     78    ADOLC_VALUE_TAPE_FREAD_FAILED,
    7779    ADOLC_TAPE_TO_OLD,
    7880    ADOLC_WRONG_LOCINT_SIZE,
     
    198200    int skipFileCleanup;
    199201
     202    revreal *paramstore;
     203#ifdef __cplusplus
     204    PersistantTapeInfos();
     205    ~PersistantTapeInfos();
     206    void copy(const PersistantTapeInfos&);
     207#endif
    200208} PersistantTapeInfos;
    201209
     
    292300    TapeInfos();
    293301    TapeInfos(short tapeID);
     302    ~TapeInfos() {}
     303    void copy(const TapeInfos&);
    294304#endif
    295305}
     
    313323    TapeInfos *currentTapeInfosPtr;
    314324    uint nominmaxFlag;
     325    size_t numparam;
     326    size_t maxparam;
     327    double *pStore;
    315328#ifdef __cplusplus
     329    StoreManager *paramStoreMgrPtr;
    316330    StoreManager *storeManagerPtr;
    317331    GlobalTapeVarsCL();
     
    319333    const GlobalTapeVarsCL& operator=(const GlobalTapeVarsCL&);
    320334#else
     335    void *paramStoreMgrPtr;
    321336    void *storeManagerPtr;
    322337#endif
     
    668683void adolc_exit(int errorcode, const char *what, const char *function, const char* file, int line);
    669684
     685/****************************************************************************/
     686/* Discards parameters from the end of value tape during reverse mode       */
     687/****************************************************************************/
     688void discard_params_r();
     689
     690/****************************************************************************/
     691/* Frees parameter indices after taping is complete                         */
     692/****************************************************************************/
     693void free_all_taping_params();
     694
    670695END_C_DECLS
    671696
  • trunk/ADOL-C/src/uni5_for.c

    r515 r537  
    14741474
    14751475                /*--------------------------------------------------------------------------*/
     1476            case neg_sign_p:
     1477            case recipr_p:
     1478            case assign_p:            /* assign an adouble variable a    assign_d */
     1479                /* double value. (=) */
     1480                res   = get_locint_f();
     1481                arg   = get_locint_f();
     1482#if !defined(_NTIGHT_)
     1483                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     1484#endif
     1485
     1486                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     1487
     1488#if !defined(_NTIGHT_)
     1489                if (operation == recipr_p)
     1490                    coval = 1.0/coval;
     1491                else if (operation == neg_sign_p)
     1492                    coval = - coval;
     1493                dp_T0[res] = coval;
     1494#endif /* !_NTIGHT_ */
     1495
     1496#if defined(_INDO_)
     1497#if defined(_INDOPRO_)
     1498                ind_dom[res][0]=0;
     1499#endif
     1500#if defined(_NONLIND_)
     1501                fod[opind].entry = maxopind+2;
     1502                fod[opind].left = NULL;
     1503                fod[opind].right = NULL;
     1504                arg_index[res] = opind++;               
     1505#endif
     1506#else
     1507#if !defined(_ZOS_) /* BREAK_ZOS */
     1508                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     1509
     1510                FOR_0_LE_l_LT_pk
     1511                TRES_INC = 0;
     1512#endif
     1513#endif /* ALL_TOGETHER_AGAIN */
     1514                break;
     1515
     1516                /*--------------------------------------------------------------------------*/
    14761517            case assign_d_zero:  /* assign an adouble variable a    assign_d_zero */
    14771518                /* double value. (0) (=) */
     
    16411682
    16421683                /*--------------------------------------------------------------------------*/
     1684            case eq_plus_p:            /* Add a floating point to an    eq_plus_p */
     1685                /* adouble. (+=) */
     1686                res   = get_locint_f();
     1687                arg   = get_locint_f();
     1688#if !defined(_NTIGHT_)
     1689                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     1690#endif
     1691                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     1692
     1693#if !defined(_NTIGHT_)
     1694                dp_T0[res] += coval;
     1695#endif /* !_NTIGHT_ */
     1696                break;
     1697
     1698                /*--------------------------------------------------------------------------*/
    16431699            case eq_plus_a:             /* Add an adouble to another    eq_plus_a */
    16441700                /* adouble. (+=) */
     
    16861742#endif
    16871743                get_val_f();
     1744
     1745                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     1746
     1747#if !defined(_NTIGHT_)
     1748                dp_T0[res] -= coval;
     1749#endif /* !_NTIGHT_ */
     1750                break;
     1751
     1752                /*--------------------------------------------------------------------------*/
     1753            case eq_min_p:       /* Subtract a floating point from an    eq_min_p */
     1754                /* adouble. (-=) */
     1755                res = get_locint_f();
     1756                arg = get_locint_f();
     1757#if !defined(_NTIGHT_)
     1758                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     1759#endif
    16881760
    16891761                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    17401812#endif
    17411813                get_val_f();
     1814
     1815                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     1816
     1817#if !defined(_NTIGHT_)
     1818                dp_T0[res] *= coval;
     1819#endif /* !_NTIGHT_ */
     1820
     1821#if !defined(_INDO_)
     1822#if !defined(_ZOS_) /* BREAK_ZOS */
     1823#if !defined( _INT_FOR_)
     1824
     1825                FOR_0_LE_l_LT_pk
     1826                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     1827
     1828                FOR_0_LE_l_LT_pk
     1829                TRES_INC *= coval;
     1830#endif
     1831#endif
     1832#endif /* ALL_TOGETHER_AGAIN */
     1833                break;
     1834
     1835                /*--------------------------------------------------------------------------*/
     1836            case eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
     1837                /* flaoting point. (*=) */
     1838                res   = get_locint_f();
     1839                arg   = get_locint_f();
     1840#if !defined(_NTIGHT_)
     1841                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     1842#endif
    17421843
    17431844                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    18971998#if !defined(_NTIGHT_)
    18981999                dp_T0[res] = dp_T0[arg] + coval;
     2000#endif /* !_NTIGHT_ */
     2001
     2002#if defined(_INDO_)
     2003#if defined(_INDOPRO_)
     2004                copy_index_domain(res, arg, ind_dom);
     2005#endif
     2006#if defined(_NONLIND_)
     2007                arg_index[res] = arg_index[arg];
     2008#endif               
     2009#else
     2010#if !defined(_ZOS_) /* BREAK_ZOS */
     2011                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     2012                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
     2013
     2014                FOR_0_LE_l_LT_pk
     2015                TRES_INC = TARG_INC;
     2016#endif
     2017#endif /* ALL_TOGETHER_AGAIN */
     2018                break;
     2019
     2020                /*--------------------------------------------------------------------------*/
     2021            case plus_a_p:             /* Add an adouble and a double    plus_a_p */
     2022            case min_a_p:                /* Subtract an adouble from a    min_a_p */
     2023                /* (+) */
     2024                arg   = get_locint_f();
     2025                res   = get_locint_f();
     2026                arg1  = get_locint_f();
     2027#if !defined(_NTIGHT_)
     2028                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     2029#endif
     2030
     2031                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     2032
     2033#if !defined(_NTIGHT_)
     2034                if (operation == plus_a_p)
     2035                    dp_T0[res] = dp_T0[arg] + coval;
     2036                else if (operation == min_a_p)
     2037                    dp_T0[res] = dp_T0[arg] - coval;
    18992038#endif /* !_NTIGHT_ */
    19002039
     
    22412380
    22422381                /*--------------------------------------------------------------------------*/
     2382            case mult_a_p:         /* Multiply an adouble by a double    mult_a_p */
     2383                /* (*) */
     2384                arg   = get_locint_f();
     2385                res   = get_locint_f();
     2386                arg1  = get_locint_f();
     2387#if !defined(_NTIGHT_)
     2388                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     2389#endif
     2390
     2391                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     2392
     2393#if !defined(_NTIGHT_)
     2394                dp_T0[res] = dp_T0[arg] * coval;
     2395#endif /* !_NTIGHT_ */
     2396
     2397#if defined(_INDO_)
     2398#if defined(_INDOPRO_)
     2399                copy_index_domain(res, arg, ind_dom);
     2400#endif
     2401#if defined(_NONLIND_)
     2402                arg_index[res] = arg_index[arg];               
     2403#endif
     2404#else
     2405#if !defined(_ZOS_) /* BREAK_ZOS */
     2406                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     2407                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
     2408
     2409#ifdef _INT_FOR_
     2410                FOR_0_LE_l_LT_pk
     2411                TRES_INC = TARG_INC;
     2412#else
     2413                FOR_0_LE_l_LT_pk
     2414                TRES_INC = TARG_INC * coval;
     2415#endif
     2416#endif
     2417#endif /* ALL_TOGETHER_AGAIN */
     2418                break;
     2419
     2420                /*--------------------------------------------------------------------------*/
    22432421            case div_a_a:           /* Divide an adouble by an adouble    div_a_a */
    22442422                /* (/) */
     
    23162494#endif
    23172495                get_val_f();
     2496
     2497                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     2498
     2499                /* olvo 980922 necessary for reverse
     2500                   kk 20140508 I don't think so
     2501                if (arg == res) {
     2502                    IF_KEEP_WRITE_TAYLOR(arg,keep,k,p)
     2503                } */
     2504
     2505#if !defined(_NTIGHT_)
     2506#if !defined(_ZOS_) && !defined(_INT_FOR_) && !defined(_INDO_)
     2507                divs = 1.0 / dp_T0[arg];
     2508#endif /* ALL_TOGETHER_AGAIN */
     2509
     2510                dp_T0[res] = coval / dp_T0[arg];
     2511#endif /* !_NTIGHT_ */
     2512
     2513#if defined(_INDO_)
     2514#if defined(_INDOPRO_)
     2515                copy_index_domain(res, arg, ind_dom);
     2516#endif
     2517#if defined(_NONLIND_)
     2518                fod[opind].entry = maxopind+2;
     2519                fod[opind].left = &fod[arg_index[arg]];
     2520                fod[opind].right = NULL;
     2521                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2522                arg_index[res] = opind++;               
     2523#endif
     2524#if defined(_NONLIND_OLD_)
     2525                extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
     2526#endif
     2527#else
     2528#if !defined(_ZOS_) /* BREAK_ZOS */
     2529                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     2530                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
     2531
     2532#ifdef _INT_FOR_
     2533                FOR_0_LE_l_LT_p
     2534                TRES_FOINC = TARG_FOINC;
     2535#else
     2536                FOR_0_LE_l_LT_p
     2537                FOR_0_LE_i_LT_k
     2538                { /* olvo 980922 changed order to allow x = d/x */
     2539#if defined(_HIGHER_ORDER_)
     2540                    zOP      = dp_z+i;
     2541                    (*zOP--) = -(*Targ) * divs;
     2542#endif /* _HIGHER_ORDER_ */
     2543
     2544                    TRES_FOINC = dp_T0[res] * (-TARG_INC * divs);
     2545
     2546#if defined(_HIGHER_ORDER_)
     2547                    TresOP = Tres-i;
     2548
     2549                    for (j=0;j<i;j++)
     2550                    *Tres += (*TresOP++) * (*zOP--);
     2551                    Tres++;
     2552#endif /* _HIGHER_ORDER_ */
     2553                }
     2554#endif
     2555#endif
     2556#endif /* ALL_TOGETHER_AGAIN */
     2557                break;
     2558
     2559
     2560            /****************************************************************************/
     2561            /*--------------------------------------------------------------------------*/
     2562        case div_p_a:             /* Division double - adouble (/)    div_p_a */
     2563                arg   = get_locint_f();
     2564                res   = get_locint_f();
     2565                arg1  = get_locint_f();
     2566#if !defined(_NTIGHT_)
     2567                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     2568#endif
    23182569
    23192570                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    34813732
    34823733                /*--------------------------------------------------------------------------*/
     3734            case pow_op_p:                                                /* pow_op_p */
     3735                arg   = get_locint_f();
     3736                res   = get_locint_f();
     3737                arg1  = get_locint_f();
     3738#if !defined(_NTIGHT_)
     3739                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     3740#endif
     3741
     3742                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     3743
     3744                /* olvo 980921 necessary for reverse */
     3745                if (arg == res) {
     3746                    IF_KEEP_WRITE_TAYLOR(arg,keep,k,p)
     3747                }
     3748
     3749#if !defined(_NTIGHT_)
     3750
     3751#ifndef _ZOS_ /* BREAK_ZOS */
     3752#if !defined(_INT_FOR_) && !defined(_INDO_)
     3753                T0arg   = dp_T0[arg];
     3754#endif
     3755#endif /* ALL_TOGETHER_AGAIN */
     3756
     3757                dp_T0[res] =
     3758                    pow(dp_T0[arg], coval);
     3759#endif /* !_NTIGHT_ */
     3760
     3761                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
     3762#if defined(_INDO_)
     3763#if defined(_INDOPRO_)
     3764                copy_index_domain(res, arg, ind_dom);
     3765#endif
     3766#if defined(_NONLIND_)
     3767                fod[opind].entry = maxopind+2;
     3768                fod[opind].left = &fod[arg_index[arg]];
     3769                fod[opind].right = NULL;
     3770                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     3771                arg_index[res] = opind++;               
     3772#endif
     3773#if defined(_NONLIND_OLD_)
     3774                extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
     3775#endif
     3776#else
     3777#ifndef _ZOS_ /* BREAK_ZOS */
     3778                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     3779                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
     3780
     3781#ifdef _INT_FOR_
     3782                FOR_0_LE_l_LT_p
     3783                TRES_FOINC = TARG_INC;
     3784#else
     3785                if (T0arg == 0.0) {
     3786                    if (coval <= 0.0)
     3787                        FOR_0_LE_l_LT_pk
     3788                        TRES_INC = make_nan();
     3789                    else {
     3790                        /* coval not a whole number */
     3791                        if (coval - floor(coval) != 0) {
     3792                            FOR_0_LE_l_LT_p
     3793                            {
     3794                                i = 0;
     3795                                FOR_0_LE_i_LT_k
     3796                                {
     3797                                    if (coval - i > 1)
     3798                                    TRES_INC = 0;
     3799                                    if ((coval - i < 1) && (coval - i > 0))
     3800                                        TRES_INC = make_inf();
     3801                                        if (coval - i < 0)
     3802                                            TRES_INC = make_nan();
     3803                                        }
     3804                                    }
     3805                                } else {
     3806                        if (coval == 1) {
     3807                                FOR_0_LE_l_LT_pk
     3808                                TRES_INC = TARG_INC;
     3809                            } else
     3810                                /* coval is an int > 1 */
     3811                                /* the following is not efficient but at least it works */
     3812                                /* it reformulates x^n into x* ... *x n times */
     3813                            {
     3814                                INC_pk_1(Targ)
     3815                                INC_pk_1(Tres)
     3816
     3817                                FOR_p_GT_l_GE_0
     3818                                {
     3819                                    FOR_k_GT_i_GE_0
     3820                                    {
     3821                                        *Tres = 0;
     3822                                        DEC_TRES_FO
     3823#if defined(_HIGHER_ORDER_)
     3824                                        if (i == k-1) {
     3825                                        zOP = dp_z+k-1;
     3826                                        for(j=k-1;j>=0;j--) {
     3827                                                (*zOP--) = (*Targ--);
     3828                                            }
     3829                                        }
     3830                                        for (j=0;j<i;j++) {
     3831                                        *Tres += dp_z[j] *
     3832                                                     dp_z[i-j-1];
     3833                                        }
     3834                                        Tres--;
     3835#endif /* _HIGHER_ORDER_ */
     3836                                    }
     3837                                }
     3838                                for(ii=3;ii<=coval;ii++) {
     3839                                    ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     3840                                    ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
     3841                                    INC_pk_1(Targ)
     3842                                    INC_pk_1(Tres)
     3843
     3844                                    FOR_p_GT_l_GE_0
     3845                                    {
     3846                                        FOR_k_GT_i_GE_0
     3847                                        {
     3848                                            *Tres = 0;
     3849                                            DEC_TRES_FO
     3850#if defined(_HIGHER_ORDER_)
     3851                                            TresOP = Tres-i;
     3852                                            for (j=0;j<i;j++)
     3853                                            *Tres += TresOP[j] * dp_z[i-j-1];
     3854                                            Tres--;
     3855#endif /* _HIGHER_ORDER_ */
     3856                                        }
     3857                                    }
     3858                                }
     3859                        }
     3860                    }
     3861                }
     3862            } else {
     3863                r0 = 1.0 / T0arg;
     3864                FOR_0_LE_l_LT_p
     3865                FOR_0_LE_i_LT_k
     3866                { /* olvo 980921 changed order to allow x = pow(x,n) */
     3867#ifdef _HIGHER_ORDER_
     3868                    zOP      = dp_z+i;
     3869                    (*zOP--) = (*Targ) * r0;
     3870#endif /* _HIGHER_ORDER_ */
     3871
     3872                    TRES_FOINC = dp_T0[res] *
     3873                                 TARG_INC * coval * r0;
     3874
     3875#ifdef _HIGHER_ORDER_
     3876                    TresOP = Tres-i;
     3877
     3878                    (*Tres) *= i+1;
     3879                    y = coval*i -1;
     3880                    for (j=0;j<i;j++) {
     3881                        *Tres += (*TresOP++) * (*zOP--) * y;
     3882                            y -= coval + 1;
     3883                        }
     3884                        *Tres++ /= (i+1);
     3885#endif /* _HIGHER_ORDER_ */
     3886                    }
     3887                }
     3888#endif
     3889#endif
     3890#endif /* ALL_TOGETHER_AGAIN */
     3891                break;
     3892
     3893                /*--------------------------------------------------------------------------*/
    34833894            case sqrt_op:                                              /* sqrt_op */
    34843895                arg = get_locint_f();
     
    41834594            case lt_a_a:
    41844595            case gt_a_a:
     4596            case neq_a_p:
     4597            case eq_a_p:
     4598            case le_a_p:
     4599            case ge_a_p:
     4600            case lt_a_p:
     4601            case gt_a_p:
    41854602#if !defined(_NTIGHT_)
    41864603                coval =
     
    42194636                        opname = "lt_a_a";
    42204637                        break;
     4638                    case neq_a_p:
     4639                        retval = (revreal)(dp_T0[arg] != ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1]);
     4640                        opname = "neq_a_p";
     4641                        break;
     4642                    case eq_a_a:
     4643                        retval = (revreal)(dp_T0[arg] == ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1]);
     4644                        opname = "eq_a_p";
     4645                        break;
     4646                    case ge_a_a:
     4647                        retval = (revreal)(dp_T0[arg] >= ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1]);
     4648                        opname = "ge_a_p";
     4649                        break;
     4650                    case le_a_a:
     4651                        retval = (revreal)(dp_T0[arg] <= ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1]);
     4652                        opname = "le_a_p";
     4653                        break;
     4654                    case gt_a_a:
     4655                        retval = (revreal)(dp_T0[arg] > ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1]);
     4656                        opname = "gt_a_p";
     4657                        break;
     4658                    case lt_a_a:
     4659                        retval = (revreal)(dp_T0[arg] < ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1]);
     4660                        opname = "lt_a_p";
     4661                        break;
    42214662                    }
    42224663                    if (retval != coval && ADOLC_GLOBAL_TAPE_VARS.branchSwitchWarning)
     
    44124853                break;
    44134854
     4855            case ref_assign_p:
     4856                arg = get_locint_f();
     4857                res = get_locint_f();
     4858#if !defined(_NTIGHT_)
     4859                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[res];
     4860#endif
     4861               
     4862#if !defined(_NTIGHT_)
     4863                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
     4864                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p)
     4865                dp_T0[arg1] = coval;
     4866#if defined(_INDO_)
     4867#if defined(_INDOPRO_)
     4868                ind_dom[arg1][0] = 0;
     4869#endif
     4870#if defined(_NONLIND_)
     4871                fod[opind].entry = maxopind+2;
     4872                fod[opind].left = NULL;
     4873                fod[opind].right = NULL;
     4874                arg_index[arg1] = opind++;
     4875#endif
     4876#else
     4877#if !defined(_ZOS_)
     4878                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
     4879
     4880                FOR_0_LE_l_LT_pk
     4881                TARG1_INC = 0;
     4882#endif
     4883#endif
     4884#else
     4885                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     4886                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
     4887#endif
     4888                break;
     4889
    44144890            case ref_assign_d_zero:
    44154891                arg = get_locint_f();
     
    45665042
    45675043                /*--------------------------------------------------------------------------*/
     5044            case ref_eq_plus_p:            /* Add a floating point to an    eq_plus_p */
     5045                /* adouble. (+=) */
     5046                arg  = get_locint_f();
     5047                arg1  = get_locint_f();
     5048#if !defined(_NTIGHT_)
     5049                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     5050#endif
     5051
     5052#if !defined(_NTIGHT_)
     5053                res = (size_t)trunc(fabs(dp_T0[arg]));
     5054                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     5055                dp_T0[res] += coval;
     5056#else
     5057                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     5058                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
     5059#endif /* !_NTIGHT_ */
     5060                break;
     5061
     5062                /*--------------------------------------------------------------------------*/
    45685063            case ref_eq_plus_a:             /* Add an adouble to another    eq_plus_a */
    45695064                /* adouble. (+=) */
     
    46235118                break;
    46245119
     5120            case ref_eq_min_p:       /* Subtract a floating point from an    eq_min_p */
     5121                /* adouble. (-=) */
     5122                arg = get_locint_f();
     5123                arg1 = get_locint_f();
     5124#if !defined(_NTIGHT_)
     5125                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     5126#endif
     5127
     5128#if !defined(_NTIGHT_)
     5129                res = (size_t)trunc(fabs(dp_T0[arg]));
     5130                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     5131                dp_T0[res] -= coval;
     5132#else
     5133                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     5134                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
     5135#endif /* !_NTIGHT_ */
     5136                break;
     5137
    46255138                /*--------------------------------------------------------------------------*/
    46265139            case ref_eq_min_a:        /* Subtract an adouble from another    eq_min_a */
     
    46705183#endif
    46715184                get_val_f();
     5185
     5186#if !defined(_NTIGHT_)
     5187                res = (size_t)trunc(fabs(dp_T0[arg]));
     5188                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     5189                dp_T0[res] *= coval;
     5190#if !defined(_INDO_)
     5191#if !defined(_ZOS_) /* BREAK_ZOS */
     5192#if !defined( _INT_FOR_)
     5193
     5194                FOR_0_LE_l_LT_pk
     5195                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     5196
     5197                FOR_0_LE_l_LT_pk
     5198                TRES_INC *= coval;
     5199#endif
     5200#endif
     5201#endif
     5202#else
     5203                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     5204                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
     5205#endif /* ALL_TOGETHER_AGAIN */
     5206                break;
     5207
     5208            case ref_eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
     5209                /* flaoting point. (*=) */
     5210                arg = get_locint_f();
     5211                arg1 = get_locint_f();
     5212#if !defined(_NTIGHT_)
     5213                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     5214#endif
    46725215
    46735216#if !defined(_NTIGHT_)
  • trunk/MSVisualStudio/v10/adolc.vcxproj

    r480 r537  
    212212    <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\fov_an_forward.c" />
    213213    <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\zos_an_forward.c" />
     214    <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\param.cpp" />
    214215  </ItemGroup>
    215216  <ItemGroup>
     
    223224    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\advector.h" />
    224225    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\checkpointing.h" />
    225     <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\common.h" />
     226    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\internal\common.h" />
    226227    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\convolut.h" />
    227228    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\drivers\drivers.h" />
    228229    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\drivers\odedrivers.h" />
    229230    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\drivers\taylor.h" />
    230     <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\dvlparms.h" />
     231    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\internal\dvlparms.h" />
    231232    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\externfcts.h" />
    232233    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\fixpoint.h" />
     
    240241    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\tapedoc\tapedoc.h" />
    241242    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\taping.h" />
    242     <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\usrparms.h" />
    243     <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\adolc_settings.h" />
     243    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\internal\usrparms.h" />
     244    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\internal\adolc_settings.h" />
    244245    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\src\buffer_temp.h" />
    245246    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\src\externfcts_p.h" />
     
    247248    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\src\taping_p.h" />
    248249    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\adtl.h" />
     250    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\param.h" />
     251    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\internal\adubfunc.h" />
     252    <ClInclude Include="$(ProjectDir)..\..\ADOL-C\include\adolc\internal\paramfunc.h" />
    249253  </ItemGroup>
    250254  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  • trunk/configure.ac

    r532 r537  
    1010define([ADOLC_VER], [2])
    1111define([ADOLC_SUB], [5])
    12 define([ADOLC_LVL], [1])
     12define([ADOLC_LVL], [2])
    1313
    1414AC_PREREQ(2.67)
     
    480480                ADOL-C/include/Makefile
    481481                ADOL-C/include/adolc/Makefile
    482                 ADOL-C/include/adolc/adolc_settings.h
     482                ADOL-C/include/adolc/internal/adolc_settings.h
    483483                ADOL-C/include/adolc/drivers/Makefile
     484                ADOL-C/include/adolc/internal/Makefile
    484485                ADOL-C/include/adolc/sparse/Makefile
    485486                ADOL-C/include/adolc/tapedoc/Makefile
     
    510511                ADOL-C/examples/additional_examples/pow/Makefile
    511512                ADOL-C/examples/additional_examples/timing/Makefile
     513                ADOL-C/examples/additional_examples/param/Makefile
    512514                ADOL-C/test/Makefile
    513515                MSVisualStudio/v10/sparse/config.h
Note: See TracChangeset for help on using the changeset viewer.