Changeset 427


Ignore:
Timestamp:
Apr 3, 2013 5:30:24 AM (9 years ago)
Author:
kulshres
Message:

Merge branch 'master' of 'gitclone' into svn trunk

The following changes were merged:
commit 02942597253216bdf58b5c7f2f9a5288ce274777
Author: Max Sagebaum <sagebaum@…>
Date: Wed Apr 3 10:55:33 2013 +0200

Allow adouble objects to be initialized late

This functionality is specially required for large codes that allocate
memory using malloc/calloc and we only wish to substitute the double
datatype with adouble for tracing purposes. With malloc/calloc the
adouble constructor is not called, creating problems later in the code.
Late initialization defers some of the initialization to the first use
of an allocated space as an adouble object. This is only possible because
the class heirarchy in ADOL-C does not require polymorphism, and virtual
tables to be allocated, which can only be done in a chained superclass
constructor call.

The functionality is disabled by default and can be enabled by a configure
switch --enable-lateinit

This code is experimental and has only be tested with particular codes.

From: Max Sagebaum <sagebaum@…>
Signed-off-by: Kshitij Kulshreshtha <kshitij@…>
CC: Andrea Walther <andrea.walther@…>
CC: Nicolas Gauger <gauger@…>

commit 768851025e58a7605f0e9b6a65f51bfc3c2977f4
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Apr 2 11:14:50 2013 +0200

add dvi file to gitignore

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

commit 80357742a527a4f4b9ef6323553279eb260cc7df
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Apr 2 11:14:37 2013 +0200

remove as many compiler warnings from gcc -Wall as possible

only -Wunused-value remains, as we do indeed ignore some
values computed when we are in INDO, NONL_IND or
INT_FOR, INT_REV modes.

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

Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/ADOL-C/include/adolc/adouble.h

    r378 r427  
    9090    explicit badouble( locint lo ) {
    9191        location = lo;
     92        isInit = true;
    9293    };
     94
     95    bool isInit;  // marker if the badouble is properly initialized
    9396
    9497public:
     
    9699    badouble( const badouble& a ) {
    97100        location = a.location;
     101        isInit = true;
    98102    }
    99103    ;           /* ctor */
     
    366370class ADOLC_DLL_EXPORT adouble:public badouble {
    367371    friend ADOLC_DLL_EXPORT class advector;
     372protected:
     373    void initInternal(void); // Init for late initialization
    368374public:
    369375    adouble( const adub& );
     
    382388    adouble& operator = ( double );
    383389    adouble& operator = ( const badouble& );
    384     /* adouble& operator = ( const adouble& );
    385        !!! olvo 991210 was the same as badouble-assignment */
     390    adouble& operator = ( const adouble& );
    386391    adouble& operator = ( const adub& );
     392   
     393    inline locint loc(void) const;
    387394};
    388395
     
    393400/*--------------------------------------------------------------------------*/
    394401inline locint badouble::loc( void ) const {
     402    return location;
     403}
     404
     405inline locint adouble::loc( void ) const {
     406    const_cast<adouble*>(this)->initInternal();
    395407    return location;
    396408}
  • trunk/ADOL-C/include/adolc/advector.h

    r408 r427  
    113113    ADOLC_DLL_EXPORT ~advector() {}
    114114    ADOLC_DLL_EXPORT advector(const advector& x) : blk(x.data.size()), data(x.data) { delete blk.dflt; }
    115     ADOLC_DLL_EXPORT advector(const vector<adouble>& v) : blk(v.size()), data(v) { delete blk.dflt; }
     115    ADOLC_DLL_EXPORT advector(const std::vector<adouble>& v) : blk(v.size()), data(v) { delete blk.dflt; }
    116116    ADOLC_DLL_EXPORT size_t size() const { return data.size(); }
    117     ADOLC_DLL_EXPORT operator const vector<adouble>&() const { return data; }
    118     ADOLC_DLL_EXPORT operator vector<adouble>&() { return data; }
     117    ADOLC_DLL_EXPORT operator const std::vector<adouble>&() const { return data; }
     118    ADOLC_DLL_EXPORT operator std::vector<adouble>&() { return data; }
    119119    ADOLC_DLL_EXPORT adub operator[](const badouble& index) const;
    120120    ADOLC_DLL_EXPORT adubref operator[](const badouble& index);
  • trunk/ADOL-C/include/adolc/common.h

    r392 r427  
    2626#   include <cstdlib>
    2727#   include <cstdio>
    28     using namespace std;
    2928#endif
    3029
  • trunk/ADOL-C/src/adouble.cpp

    r376 r427  
    5151
    5252/*--------------------------------------------------------------------------*/
     53#if defined(ADOLC_ADOUBLE_LATEINIT)
     54void adouble::initInternal(void) {
     55  if (isInit)
     56    return;
     57  location = next_loc();
     58  ADOLC_OPENMP_THREAD_NUMBER;
     59  ADOLC_OPENMP_GET_THREAD_NUMBER;
     60
     61#if defined(ADOLC_ADOUBLE_STDCZERO)
     62  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
     63    put_op(assign_d_zero);
     64    ADOLC_PUT_LOCINT(location);   // = res
     65  }
     66
     67  ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     68  if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     69    ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
     70
     71  ADOLC_GLOBAL_TAPE_VARS.store[location] = 0.;
     72#endif
     73  isInit = true;
     74}
     75#else
     76void adouble::initInternal(void) {}
     77#endif
     78
     79/*--------------------------------------------------------------------------*/
    5380adouble::adouble() {
    5481    location = next_loc();
     82    isInit = true;
    5583    ADOLC_OPENMP_THREAD_NUMBER;
    5684    ADOLC_OPENMP_GET_THREAD_NUMBER;
     
    73101adouble::adouble( double coval ) {
    74102    location = next_loc();
     103    isInit = true;
    75104    ADOLC_OPENMP_THREAD_NUMBER;
    76105    ADOLC_OPENMP_GET_THREAD_NUMBER;
     
    101130adouble::adouble( const adouble& a ) {
    102131    location = next_loc();
     132    isInit = true;
    103133    ADOLC_OPENMP_THREAD_NUMBER;
    104134    ADOLC_OPENMP_GET_THREAD_NUMBER;
     
    120150adouble::adouble( const adub& a ) {
    121151    location = next_loc();
     152    isInit = true;
    122153    ADOLC_OPENMP_THREAD_NUMBER;
    123154    ADOLC_OPENMP_GET_THREAD_NUMBER;
     
    160191    ADOLC_OPENMP_THREAD_NUMBER;
    161192    ADOLC_OPENMP_GET_THREAD_NUMBER;
    162     return ADOLC_GLOBAL_TAPE_VARS.store[location];
     193    return ADOLC_GLOBAL_TAPE_VARS.store[loc()];
    163194}
    164195
     
    166197    ADOLC_OPENMP_THREAD_NUMBER;
    167198    ADOLC_OPENMP_GET_THREAD_NUMBER;
    168     ADOLC_GLOBAL_TAPE_VARS.store[location]=x;
     199    ADOLC_GLOBAL_TAPE_VARS.store[loc()]=x;
    169200}
    170201
     
    180211        if (coval == 0) {
    181212            put_op(assign_d_zero);
    182             ADOLC_PUT_LOCINT(location);   // = res
     213            ADOLC_PUT_LOCINT(loc());   // = res
    183214        } else
    184215            if (coval == 1.0) {
    185216                put_op(assign_d_one);
    186                 ADOLC_PUT_LOCINT(location); // = res
     217                ADOLC_PUT_LOCINT(loc()); // = res
    187218            } else {
    188219                put_op(assign_d);
    189                 ADOLC_PUT_LOCINT(location); // = res
     220                ADOLC_PUT_LOCINT(loc()); // = res
    190221                ADOLC_PUT_VAL(coval);       // = coval
    191222            }
     
    193224        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    194225        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    195             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    196     }
    197 
    198     ADOLC_GLOBAL_TAPE_VARS.store[location] = coval;
     226            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     227    }
     228
     229    ADOLC_GLOBAL_TAPE_VARS.store[loc()] = coval;
    199230    return *this;
    200231}
     
    203234/* Assign an adouble variable a constant value. */
    204235adouble& adouble::operator = ( double coval ) {
     236    this->loc();  // call for late init
    205237    (*this).badouble::operator=(coval);
    206238    return (*this);
     
    216248
    217249        put_op(assign_ind);
    218         ADOLC_PUT_LOCINT(location); // = res
    219 
    220         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    221         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    222             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    223     }
    224 
    225     ADOLC_GLOBAL_TAPE_VARS.store[location] = coval;
     250        ADOLC_PUT_LOCINT(loc()); // = res
     251
     252        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     253        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     254            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     255    }
     256
     257    ADOLC_GLOBAL_TAPE_VARS.store[loc()] = coval;
    226258    return *this;
    227259}
     
    235267
    236268        put_op(assign_ind);
    237         ADOLC_PUT_LOCINT(location); // = res
    238 
    239         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    240         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    241             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
     269        ADOLC_PUT_LOCINT(loc()); // = res
     270
     271        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     272        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     273            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
    242274    }
    243275}
     
    252284
    253285        put_op(assign_dep);
    254         ADOLC_PUT_LOCINT(location); // = res
    255     }
    256 
    257     coval = double (ADOLC_GLOBAL_TAPE_VARS.store[location]);
     286        ADOLC_PUT_LOCINT(loc()); // = res
     287    }
     288
     289    coval = double (ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
    258290    return *this;
    259291}
     
    266298
    267299        put_op(assign_dep);
    268         ADOLC_PUT_LOCINT(location); // = res
     300        ADOLC_PUT_LOCINT(loc()); // = res
    269301    }
    270302}
     
    276308    ADOLC_OPENMP_GET_THREAD_NUMBER;
    277309    locint x_loc = x.loc();
    278     if (location!=x_loc)
     310    if (loc()!=x_loc)
    279311        /* test this to avoid for x=x statements adjoint(x)=0 in reverse mode */
    280     { if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old:  write_assign_a(location,x.location);
     312    { if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old:  write_assign_a(loc(),x.loc());
    281313            put_op(assign_a);
    282314            ADOLC_PUT_LOCINT(x_loc);    // = arg
    283             ADOLC_PUT_LOCINT(location);   // = res
     315            ADOLC_PUT_LOCINT(loc());   // = res
    284316
    285317            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    286318            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    287                 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    288         }
    289 
    290         ADOLC_GLOBAL_TAPE_VARS.store[location]=ADOLC_GLOBAL_TAPE_VARS.store[x_loc];
     319                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     320        }
     321
     322        ADOLC_GLOBAL_TAPE_VARS.store[loc()]=ADOLC_GLOBAL_TAPE_VARS.store[x_loc];
    291323    }
    292324    return *this;
     
    296328/* Assign an Badouble variable an Badouble value. */
    297329adouble& adouble::operator = ( const badouble& x ) {
     330    this->loc();  // call for late init
    298331    (*this).badouble::operator=(x);
    299332    return (*this);
    300333}
    301334
     335/*--------------------------------------------------------------------------*/
     336/* Assign an adouble variable an adouble value. */
     337adouble& adouble::operator = ( const adouble& x ) {
     338    this->loc();  // call for late init
     339    x.loc(); // cal for late init
     340    (*this).badouble::operator=(x);
     341    return (*this);
     342}
    302343/*--------------------------------------------------------------------------*/
    303344/* Assign an adouble an adub */
     
    310351    /* 981020 olvo  skip upd_resloc(..) if no tracing performed */
    311352    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag)
    312         upd = upd_resloc(a_loc,location);
     353        upd = upd_resloc(a_loc,loc());
    313354    if (upd) { /* olvo 980708 new n2l & 980921 changed interface */
    314355        revreal tempVal = ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
    315356        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    316             ADOLC_OVERWRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location],&ADOLC_GLOBAL_TAPE_VARS.store[a_loc]);
    317         ADOLC_GLOBAL_TAPE_VARS.store[location] = tempVal;
     357            ADOLC_OVERWRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()],&ADOLC_GLOBAL_TAPE_VARS.store[a_loc]);
     358        ADOLC_GLOBAL_TAPE_VARS.store[loc()] = tempVal;
    318359    } else {
    319         if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(location,a_loc);
     360        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(loc(),a_loc);
    320361            put_op(assign_a);
    321362            ADOLC_PUT_LOCINT(a_loc);    // = arg
    322             ADOLC_PUT_LOCINT(location); // = res
     363            ADOLC_PUT_LOCINT(loc()); // = res
    323364
    324365            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    325366            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    326                 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    327         }
    328         ADOLC_GLOBAL_TAPE_VARS.store[location] = ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
     367                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     368        }
     369        ADOLC_GLOBAL_TAPE_VARS.store[loc()] = ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
    329370    }
    330371
     
    336377/* olvo 980517 new version griewank */
    337378adouble& adouble::operator = ( const adub& a ) {
     379    this->loc();  // call for late init
    338380    (*this).badouble::operator=(a);
    339381    return (*this);
     
    349391    ADOLC_OPENMP_THREAD_NUMBER;
    350392    ADOLC_OPENMP_GET_THREAD_NUMBER;
    351     return out << ADOLC_GLOBAL_TAPE_VARS.store[y.location] << "(a)" ;
     393    return out << ADOLC_GLOBAL_TAPE_VARS.store[y.loc()] << "(a)" ;
    352394}
    353395
     
    359401    ADOLC_OPENMP_GET_THREAD_NUMBER;
    360402    in >> coval;
    361     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_d(y.location,coval);
     403    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_d(y.loc(),coval);
    362404        if (coval == 0) {
    363405            put_op(assign_d_zero);
    364             ADOLC_PUT_LOCINT(y.location);   // = res
     406            ADOLC_PUT_LOCINT(y.loc());   // = res
    365407        } else
    366408            if (coval == 1.0) {
    367409                put_op(assign_d_one);
    368                 ADOLC_PUT_LOCINT(y.location); // = res
     410                ADOLC_PUT_LOCINT(y.loc()); // = res
    369411            } else {
    370412                put_op(assign_d);
    371                 ADOLC_PUT_LOCINT(y.location);   // = res
     413                ADOLC_PUT_LOCINT(y.loc());   // = res
    372414                ADOLC_PUT_VAL(coval);         // = coval
    373415            }
     
    375417        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    376418        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    377             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.location]);
    378     }
    379 
    380     ADOLC_GLOBAL_TAPE_VARS.store[y.location] = coval;
     419            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.loc()]);
     420    }
     421
     422    ADOLC_GLOBAL_TAPE_VARS.store[y.loc()] = coval;
    381423    return in;
    382424}
     
    392434    ADOLC_OPENMP_GET_THREAD_NUMBER;
    393435
    394     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(locat,location);
     436    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(locat,loc());
    395437        put_op(assign_a);
    396         ADOLC_PUT_LOCINT(location); // = arg
     438        ADOLC_PUT_LOCINT(loc()); // = arg
    397439        ADOLC_PUT_LOCINT(locat);    // = res
    398440
     
    402444    }
    403445
    404     ADOLC_GLOBAL_TAPE_VARS.store[locat]=ADOLC_GLOBAL_TAPE_VARS.store[location];
    405 
    406     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_incr_decr_a(incr_a,location);
     446    ADOLC_GLOBAL_TAPE_VARS.store[locat]=ADOLC_GLOBAL_TAPE_VARS.store[loc()];
     447
     448    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_incr_decr_a(incr_a,loc());
    407449        put_op(incr_a);
    408         ADOLC_PUT_LOCINT(location); // = res
    409 
    410         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    411         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    412             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    413     }
    414 
    415     ADOLC_GLOBAL_TAPE_VARS.store[location]++;
     450        ADOLC_PUT_LOCINT(loc()); // = res
     451
     452        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     453        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     454            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     455    }
     456
     457    ADOLC_GLOBAL_TAPE_VARS.store[loc()]++;
    416458    return locat;
    417459}
     
    424466    ADOLC_OPENMP_GET_THREAD_NUMBER;
    425467
    426     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(locat,location);
     468    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(locat,loc());
    427469        put_op(assign_a);
    428         ADOLC_PUT_LOCINT(location); // = arg
     470        ADOLC_PUT_LOCINT(loc()); // = arg
    429471        ADOLC_PUT_LOCINT(locat);    // = res
    430472
     
    434476    }
    435477
    436     ADOLC_GLOBAL_TAPE_VARS.store[locat]=ADOLC_GLOBAL_TAPE_VARS.store[location];
    437     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_incr_decr_a(decr_a,location);
     478    ADOLC_GLOBAL_TAPE_VARS.store[locat]=ADOLC_GLOBAL_TAPE_VARS.store[loc()];
     479    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_incr_decr_a(decr_a,loc());
    438480        put_op(decr_a);
    439         ADOLC_PUT_LOCINT(location); // = res
    440 
    441         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    442         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    443             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    444     }
    445 
    446     ADOLC_GLOBAL_TAPE_VARS.store[location]--;
     481        ADOLC_PUT_LOCINT(loc()); // = res
     482
     483        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     484        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     485            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     486    }
     487
     488    ADOLC_GLOBAL_TAPE_VARS.store[loc()]--;
    447489    return locat;
    448490}
     
    453495    ADOLC_OPENMP_THREAD_NUMBER;
    454496    ADOLC_OPENMP_GET_THREAD_NUMBER;
    455     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_incr_decr_a(incr_a,location);
     497    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_incr_decr_a(incr_a,loc());
    456498        put_op(incr_a);
    457         ADOLC_PUT_LOCINT(location); // = res
    458 
    459         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    460         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    461             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    462     }
    463 
    464     ADOLC_GLOBAL_TAPE_VARS.store[location]++;
     499        ADOLC_PUT_LOCINT(loc()); // = res
     500
     501        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     502        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     503            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     504    }
     505
     506    ADOLC_GLOBAL_TAPE_VARS.store[loc()]++;
    465507    return *this;
    466508}
     
    471513    ADOLC_OPENMP_THREAD_NUMBER;
    472514    ADOLC_OPENMP_GET_THREAD_NUMBER;
    473     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_incr_decr_a(decr_a,location);
     515    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_incr_decr_a(decr_a,loc());
    474516        put_op(decr_a);
    475         ADOLC_PUT_LOCINT(location); // = res
    476 
    477         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    478         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    479             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    480     }
    481 
    482     ADOLC_GLOBAL_TAPE_VARS.store[location]--;
     517        ADOLC_PUT_LOCINT(loc()); // = res
     518
     519        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     520        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     521            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     522    }
     523
     524    ADOLC_GLOBAL_TAPE_VARS.store[loc()]--;
    483525    return *this;
    484526}
     
    492534    ADOLC_OPENMP_THREAD_NUMBER;
    493535    ADOLC_OPENMP_GET_THREAD_NUMBER;
    494     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_plus_d,location,coval);
     536    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_plus_d,loc(),coval);
    495537        put_op(eq_plus_d);
    496         ADOLC_PUT_LOCINT(location); // = res
     538        ADOLC_PUT_LOCINT(loc()); // = res
    497539        ADOLC_PUT_VAL(coval);       // = coval
    498540
    499541        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    500542        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    501             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    502     }
    503 
    504     ADOLC_GLOBAL_TAPE_VARS.store[location] += coval;
     543            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     544    }
     545
     546    ADOLC_GLOBAL_TAPE_VARS.store[loc()] += coval;
    505547    return *this;
    506548}
     
    512554    ADOLC_OPENMP_THREAD_NUMBER;
    513555    ADOLC_OPENMP_GET_THREAD_NUMBER;
    514     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_min_d,location,coval);
     556    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_min_d,loc(),coval);
    515557        put_op(eq_min_d);
    516         ADOLC_PUT_LOCINT(location); // = res
     558        ADOLC_PUT_LOCINT(loc()); // = res
    517559        ADOLC_PUT_VAL(coval);       // = coval
    518560
    519561        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    520562        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    521             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    522     }
    523 
    524     ADOLC_GLOBAL_TAPE_VARS.store[location] -= coval;
     563            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     564    }
     565
     566    ADOLC_GLOBAL_TAPE_VARS.store[loc()] -= coval;
    525567    return *this;
    526568}
     
    532574    ADOLC_OPENMP_GET_THREAD_NUMBER;
    533575    locint y_loc = y.loc();
    534     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_a_same_arg(eq_plus_a,location,y.location);
     576    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_a_same_arg(eq_plus_a,loc(),y.loc());
    535577        put_op(eq_plus_a);
    536578        ADOLC_PUT_LOCINT(y_loc); // = arg
    537         ADOLC_PUT_LOCINT(location);   // = res
    538 
    539         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    540         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    541             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    542     }
    543 
    544     ADOLC_GLOBAL_TAPE_VARS.store[location] += ADOLC_GLOBAL_TAPE_VARS.store[y_loc];
     579        ADOLC_PUT_LOCINT(loc());   // = res
     580
     581        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     582        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     583            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     584    }
     585
     586    ADOLC_GLOBAL_TAPE_VARS.store[loc()] += ADOLC_GLOBAL_TAPE_VARS.store[y_loc];
    545587    return *this;
    546588}
     
    555597    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag)
    556598      {
    557         upd = upd_resloc_inc_prod(a_loc,location,eq_plus_prod);
     599        upd = upd_resloc_inc_prod(a_loc,loc(),eq_plus_prod);
    558600      }
    559601    if (upd) {
    560         ADOLC_GLOBAL_TAPE_VARS.store[location] += ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
     602        ADOLC_GLOBAL_TAPE_VARS.store[loc()] += ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
    561603        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    562604            ADOLC_DELETE_SCAYLOR(&ADOLC_GLOBAL_TAPE_VARS.store[a_loc]);
     
    564606        ++ADOLC_CURRENT_TAPE_INFOS.num_eq_prod;
    565607    } else {
    566         if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(location,a_loc);
     608        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(loc(),a_loc);
    567609            put_op(eq_plus_a);
    568610            ADOLC_PUT_LOCINT(a_loc);    // = arg
    569             ADOLC_PUT_LOCINT(location); // = res
     611            ADOLC_PUT_LOCINT(loc()); // = res
    570612
    571613            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    572614            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    573                 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    574         }
    575         ADOLC_GLOBAL_TAPE_VARS.store[location] += ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
     615                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     616        }
     617        ADOLC_GLOBAL_TAPE_VARS.store[loc()] += ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
    576618    }
    577619
     
    585627    ADOLC_OPENMP_GET_THREAD_NUMBER;
    586628    locint y_loc = y.loc();
    587     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_a_same_arg(eq_min_a,location,y.location);
     629    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_a_same_arg(eq_min_a,loc(),y.loc());
    588630        put_op(eq_min_a);
    589631        ADOLC_PUT_LOCINT(y_loc); // = arg
    590         ADOLC_PUT_LOCINT(location);   // = res
    591 
    592         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    593         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    594             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    595     }
    596 
    597     ADOLC_GLOBAL_TAPE_VARS.store[location] -= ADOLC_GLOBAL_TAPE_VARS.store[y_loc];
     632        ADOLC_PUT_LOCINT(loc());   // = res
     633
     634        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     635        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     636            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     637    }
     638
     639    ADOLC_GLOBAL_TAPE_VARS.store[loc()] -= ADOLC_GLOBAL_TAPE_VARS.store[y_loc];
    598640    return *this;
    599641}
     
    608650    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag)
    609651      {
    610         upd = upd_resloc_inc_prod(a_loc,location,eq_min_prod);
     652        upd = upd_resloc_inc_prod(a_loc,loc(),eq_min_prod);
    611653      }
    612654    if (upd) {
    613         ADOLC_GLOBAL_TAPE_VARS.store[location] -= ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
     655        ADOLC_GLOBAL_TAPE_VARS.store[loc()] -= ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
    614656        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    615657            ADOLC_DELETE_SCAYLOR(&ADOLC_GLOBAL_TAPE_VARS.store[a_loc]);
     
    617659        ++ADOLC_CURRENT_TAPE_INFOS.num_eq_prod;
    618660    } else {
    619         if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(location,a_loc);
     661        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(loc(),a_loc);
    620662            put_op(eq_min_a);
    621663            ADOLC_PUT_LOCINT(a_loc);    // = arg
    622             ADOLC_PUT_LOCINT(location); // = res
     664            ADOLC_PUT_LOCINT(loc()); // = res
    623665
    624666            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    625667            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    626                 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    627         }
    628         ADOLC_GLOBAL_TAPE_VARS.store[location] -= ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
     668                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     669        }
     670        ADOLC_GLOBAL_TAPE_VARS.store[loc()] -= ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
    629671    }
    630672
     
    637679    ADOLC_OPENMP_THREAD_NUMBER;
    638680    ADOLC_OPENMP_GET_THREAD_NUMBER;
    639     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_mult_d,location,coval);
     681    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_mult_d,loc(),coval);
    640682        put_op(eq_mult_d);
    641         ADOLC_PUT_LOCINT(location); // = res
     683        ADOLC_PUT_LOCINT(loc()); // = res
    642684        ADOLC_PUT_VAL(coval);       // = coval
    643685
    644686        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    645687        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    646             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    647     }
    648 
    649     ADOLC_GLOBAL_TAPE_VARS.store[location] *= coval;
     688            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     689    }
     690
     691    ADOLC_GLOBAL_TAPE_VARS.store[loc()] *= coval;
    650692    return *this;
    651693}
     
    657699    ADOLC_OPENMP_GET_THREAD_NUMBER;
    658700    locint y_loc = y.loc();
    659     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_a_same_arg(eq_mult_a,location,y.location);
     701    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_a_same_arg(eq_mult_a,loc(),y.loc());
    660702        put_op(eq_mult_a);
    661703        ADOLC_PUT_LOCINT(y_loc); // = arg
    662         ADOLC_PUT_LOCINT(location);   // = res
    663 
    664         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    665         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    666             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
    667     }
    668 
    669     ADOLC_GLOBAL_TAPE_VARS.store[location] *= ADOLC_GLOBAL_TAPE_VARS.store[y_loc];
     704        ADOLC_PUT_LOCINT(loc());   // = res
     705
     706        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     707        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     708            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
     709    }
     710
     711    ADOLC_GLOBAL_TAPE_VARS.store[loc()] *= ADOLC_GLOBAL_TAPE_VARS.store[y_loc];
    670712    return *this;
    671713}
     
    694736    else {
    695737        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    696             put_op(ADOLC_GLOBAL_TAPE_VARS.store[v.location] ? neq_zero : eq_zero);
    697             ADOLC_PUT_LOCINT(v.location);
    698         }
    699         return (ADOLC_GLOBAL_TAPE_VARS.store[v.location] != 0);
     738            put_op(ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] ? neq_zero : eq_zero);
     739            ADOLC_PUT_LOCINT(v.loc());
     740        }
     741        return (ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] != 0);
    700742    }
    701743}
     
    710752    else {
    711753        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    712             put_op(ADOLC_GLOBAL_TAPE_VARS.store[v.location] ? neq_zero : eq_zero);
    713             ADOLC_PUT_LOCINT(v.location);
    714         }
    715         return (ADOLC_GLOBAL_TAPE_VARS.store[v.location] == 0);
     754            put_op(ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] ? neq_zero : eq_zero);
     755            ADOLC_PUT_LOCINT(v.loc());
     756        }
     757        return (ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] == 0);
    716758    }
    717759}
     
    725767        return (-coval+v <= 0);
    726768    else {
    727         int b = (ADOLC_GLOBAL_TAPE_VARS.store[v.location] <= 0);
     769        int b = (ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] <= 0);
    728770        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    729771            put_op(b ? le_zero : gt_zero);
    730             ADOLC_PUT_LOCINT(v.location);
     772            ADOLC_PUT_LOCINT(v.loc());
    731773        }
    732774        return b;
     
    742784        return (-coval+v >= 0);
    743785    else {
    744         int b = (ADOLC_GLOBAL_TAPE_VARS.store[v.location] >= 0);
     786        int b = (ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] >= 0);
    745787        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    746788            put_op(b ? ge_zero : lt_zero);
    747             ADOLC_PUT_LOCINT(v.location);
     789            ADOLC_PUT_LOCINT(v.loc());
    748790        }
    749791        return b;
     
    759801        return (-coval+v > 0);
    760802    else {
    761         int b = (ADOLC_GLOBAL_TAPE_VARS.store[v.location] > 0);
     803        int b = (ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] > 0);
    762804        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    763805            put_op(b ? gt_zero : le_zero);
    764             ADOLC_PUT_LOCINT(v.location);
     806            ADOLC_PUT_LOCINT(v.loc());
    765807        }
    766808        return b;
     
    776818        return (-coval+v < 0);
    777819    else {
    778         int b = (ADOLC_GLOBAL_TAPE_VARS.store[v.location] < 0);
     820        int b = (ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] < 0);
    779821        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    780822            put_op(b ? lt_zero : ge_zero);
    781             ADOLC_PUT_LOCINT(v.location);
     823            ADOLC_PUT_LOCINT(v.loc());
    782824        }
    783825        return b;
     
    797839    locint locat = next_loc();
    798840
    799     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_pos_sign_a(locat,x.location);
     841    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_pos_sign_a(locat,x.loc());
    800842        put_op(pos_sign_a);
    801         ADOLC_PUT_LOCINT(x.location); // = arg
    802         ADOLC_PUT_LOCINT(locat);      // = res
    803 
    804         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    805         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    806             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
    807     }
    808 
    809     ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[x.location];
     843        ADOLC_PUT_LOCINT(x.loc()); // = arg
     844        ADOLC_PUT_LOCINT(locat);      // = res
     845
     846        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     847        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     848            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
     849    }
     850
     851    ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
    810852    return locat;
    811853}
     
    818860    locint locat = next_loc();
    819861
    820     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_neg_sign_a(locat,x.location);
     862    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_neg_sign_a(locat,x.loc());
    821863        put_op(neg_sign_a);
    822         ADOLC_PUT_LOCINT(x.location); // = arg
    823         ADOLC_PUT_LOCINT(locat);      // = res
    824 
    825         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    826         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    827             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
    828     }
    829 
    830     ADOLC_GLOBAL_TAPE_VARS.store[locat] = -ADOLC_GLOBAL_TAPE_VARS.store[x.location];
     864        ADOLC_PUT_LOCINT(x.loc()); // = arg
     865        ADOLC_PUT_LOCINT(locat);      // = res
     866
     867        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     868        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     869            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
     870    }
     871
     872    ADOLC_GLOBAL_TAPE_VARS.store[locat] = -ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
    831873    return locat;
    832874}
     
    846888    locint locat = next_loc();
    847889
    848     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_two_a_rec(plus_a_a,locat,x.location,y.location);
     890    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_two_a_rec(plus_a_a,locat,x.loc(),y.loc());
    849891        put_op(plus_a_a);
    850         ADOLC_PUT_LOCINT(x.location); // = arg1
    851         ADOLC_PUT_LOCINT(y.location); // = arg2
    852         ADOLC_PUT_LOCINT(locat);      // = res
    853 
    854         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    855         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    856             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
    857     }
    858 
    859     ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[x.location] + ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     892        ADOLC_PUT_LOCINT(x.loc()); // = arg1
     893        ADOLC_PUT_LOCINT(y.loc()); // = arg2
     894        ADOLC_PUT_LOCINT(locat);      // = res
     895
     896        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     897        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     898            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
     899    }
     900
     901    ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()] + ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    860902    return locat;
    861903}
     
    870912    /* olvo 980708 test coval to be zero */
    871913    if (coval) {
    872         if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(plus_d_a,locat,coval,y.location);
     914        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(plus_d_a,locat,coval,y.loc());
    873915            put_op(plus_d_a);
    874             ADOLC_PUT_LOCINT(y.location); // = arg
     916            ADOLC_PUT_LOCINT(y.loc()); // = arg
    875917            ADOLC_PUT_LOCINT(locat);      // = res
    876918            ADOLC_PUT_VAL(coval);         // = coval
     
    881923        }
    882924
    883         ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval + ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     925        ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval + ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    884926    } else {
    885         if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_pos_sign_a(locat,y.location);
     927        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_pos_sign_a(locat,y.loc());
    886928            put_op(pos_sign_a);
    887             ADOLC_PUT_LOCINT(y.location); // = arg
     929            ADOLC_PUT_LOCINT(y.loc()); // = arg
    888930            ADOLC_PUT_LOCINT(locat);      // = res
    889931
     
    893935        }
    894936
    895         ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     937        ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    896938    }
    897939
     
    907949    /* olvo 980708 test coval to be zero */
    908950    if (coval) {
    909         if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(plus_d_a,locat,coval,y.location);
     951        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(plus_d_a,locat,coval,y.loc());
    910952            put_op(plus_d_a);
    911             ADOLC_PUT_LOCINT(y.location); // = arg
     953            ADOLC_PUT_LOCINT(y.loc()); // = arg
    912954            ADOLC_PUT_LOCINT(locat);      // = res
    913955            ADOLC_PUT_VAL(coval);         // = coval
     
    918960        }
    919961
    920         ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval + ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     962        ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval + ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    921963    } else {
    922         if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_pos_sign_a(locat,y.location);
     964        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_pos_sign_a(locat,y.loc());
    923965            put_op(pos_sign_a);
    924             ADOLC_PUT_LOCINT(y.location); // = arg
     966            ADOLC_PUT_LOCINT(y.loc()); // = arg
    925967            ADOLC_PUT_LOCINT(locat);      // = res
    926968
     
    930972        }
    931973
    932         ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     974        ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    933975    }
    934976
     
    943985    locint locat = next_loc();
    944986
    945     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_two_a_rec(min_a_a,locat,x.location,y.location);
     987    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_two_a_rec(min_a_a,locat,x.loc(),y.loc());
    946988        put_op(min_a_a);
    947         ADOLC_PUT_LOCINT(x.location); // = arg1
    948         ADOLC_PUT_LOCINT(y.location); // = arg2
    949         ADOLC_PUT_LOCINT(locat);      // = res
    950 
    951         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    952         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    953             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
    954     }
    955 
    956     ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[x.location] - ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     989        ADOLC_PUT_LOCINT(x.loc()); // = arg1
     990        ADOLC_PUT_LOCINT(y.loc()); // = arg2
     991        ADOLC_PUT_LOCINT(locat);      // = res
     992
     993        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     994        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     995            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
     996    }
     997
     998    ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()] - ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    957999    return locat;
    9581000}
     
    9681010    /* olvo 980708 test coval to be zero */
    9691011    if (coval) {
    970         if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(min_d_a,locat,coval,y.location);
     1012        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(min_d_a,locat,coval,y.loc());
    9711013            put_op(min_d_a);
    972             ADOLC_PUT_LOCINT(y.location); // = arg
     1014            ADOLC_PUT_LOCINT(y.loc()); // = arg
    9731015            ADOLC_PUT_LOCINT(locat);      // = res
    9741016            ADOLC_PUT_VAL(coval);         // = coval
     
    9791021        }
    9801022
    981         ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval - ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1023        ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval - ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    9821024    } else {
    983         if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_neg_sign_a(locat,y.location);
     1025        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_neg_sign_a(locat,y.loc());
    9841026            put_op(neg_sign_a);
    985             ADOLC_PUT_LOCINT(y.location); // = arg
     1027            ADOLC_PUT_LOCINT(y.loc()); // = arg
    9861028            ADOLC_PUT_LOCINT(locat);      // = res
    9871029
     
    9911033        }
    9921034
    993         ADOLC_GLOBAL_TAPE_VARS.store[locat] = -ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1035        ADOLC_GLOBAL_TAPE_VARS.store[locat] = -ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    9941036    }
    9951037
     
    10041046    locint locat = next_loc();
    10051047
    1006     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_two_a_rec(mult_a_a,locat,x.location,y.location);
     1048    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_two_a_rec(mult_a_a,locat,x.loc(),y.loc());
    10071049        put_op(mult_a_a);
    1008         ADOLC_PUT_LOCINT(x.location); // = arg1
    1009         ADOLC_PUT_LOCINT(y.location); // = arg2
    1010         ADOLC_PUT_LOCINT(locat);      // = res
    1011 
    1012         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    1013         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    1014             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
    1015     }
    1016 
    1017     ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[x.location] * ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1050        ADOLC_PUT_LOCINT(x.loc()); // = arg1
     1051        ADOLC_PUT_LOCINT(y.loc()); // = arg2
     1052        ADOLC_PUT_LOCINT(locat);      // = res
     1053
     1054        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     1055        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     1056            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
     1057    }
     1058
     1059    ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()] * ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    10181060    return locat;
    10191061}
     
    10281070
    10291071    if ( coval == 1.0 ) {
    1030         if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_pos_sign_a(locat,y.location);
     1072        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_pos_sign_a(locat,y.loc());
    10311073            put_op(pos_sign_a);
    1032             ADOLC_PUT_LOCINT(y.location); // = arg
     1074            ADOLC_PUT_LOCINT(y.loc()); // = arg
    10331075            ADOLC_PUT_LOCINT(locat);      // = res
    10341076
     
    10381080        }
    10391081
    1040         ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1082        ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    10411083    } else
    10421084        if ( coval == -1.0 ) {
    1043             if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_neg_sign_a(locat,y.location);
     1085            if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_neg_sign_a(locat,y.loc());
    10441086                put_op(neg_sign_a);
    1045                 ADOLC_PUT_LOCINT(y.location); // = arg
     1087                ADOLC_PUT_LOCINT(y.loc()); // = arg
    10461088                ADOLC_PUT_LOCINT(locat);      // = res
    10471089
     
    10511093            }
    10521094
    1053             ADOLC_GLOBAL_TAPE_VARS.store[locat] = -ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1095            ADOLC_GLOBAL_TAPE_VARS.store[locat] = -ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    10541096        } else {
    1055             if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(mult_d_a,locat,coval,y.location);
     1097            if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(mult_d_a,locat,coval,y.loc());
    10561098                put_op(mult_d_a);
    1057                 ADOLC_PUT_LOCINT(y.location); // = arg
     1099                ADOLC_PUT_LOCINT(y.loc()); // = arg
    10581100                ADOLC_PUT_LOCINT(locat);      // = res
    10591101                ADOLC_PUT_VAL(coval);         // = coval
     
    10641106            }
    10651107
    1066             ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval * ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1108            ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval * ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    10671109        }
    10681110    return locat;
     
    10761118    locint locat = next_loc();
    10771119
    1078     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_two_a_rec(div_a_a,locat,x.location,y.location);
     1120    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_two_a_rec(div_a_a,locat,x.loc(),y.loc());
    10791121        put_op(div_a_a);
    1080         ADOLC_PUT_LOCINT(x.location); // = arg1
    1081         ADOLC_PUT_LOCINT(y.location); // = arg2
    1082         ADOLC_PUT_LOCINT(locat);      // = res
    1083 
    1084         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    1085         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    1086             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
    1087     }
    1088 
    1089     ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[x.location] / ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1122        ADOLC_PUT_LOCINT(x.loc()); // = arg1
     1123        ADOLC_PUT_LOCINT(y.loc()); // = arg2
     1124        ADOLC_PUT_LOCINT(locat);      // = res
     1125
     1126        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     1127        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     1128            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
     1129    }
     1130
     1131    ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()] / ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    10901132    return locat;
    10911133}
     
    10981140    locint locat = next_loc();
    10991141
    1100     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(div_d_a,locat,coval,y.location);
     1142    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(div_d_a,locat,coval,y.loc());
    11011143        put_op(div_d_a);
    1102         ADOLC_PUT_LOCINT(y.location); // = arg
     1144        ADOLC_PUT_LOCINT(y.loc()); // = arg
    11031145        ADOLC_PUT_LOCINT(locat);      // = res
    11041146        ADOLC_PUT_VAL(coval);         // = coval
     
    11091151    }
    11101152
    1111     ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval  / ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1153    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval  / ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    11121154    return locat;
    11131155}
     
    11241166    locint locat = next_loc();
    11251167
    1126     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_single_op(exp_op,locat,x.location);
     1168    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_single_op(exp_op,locat,x.loc());
    11271169        put_op(exp_op);
    1128         ADOLC_PUT_LOCINT(x.location); // = arg
     1170        ADOLC_PUT_LOCINT(x.loc()); // = arg
    11291171        ADOLC_PUT_LOCINT(locat);      // = res
    11301172
     
    11351177
    11361178    ADOLC_GLOBAL_TAPE_VARS.store[locat] =
    1137         ADOLC_MATH_NSP::exp(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
     1179        ADOLC_MATH_NSP::exp(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
    11381180    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    11391181    return locat;
     
    11471189    locint locat = next_loc();
    11481190
    1149     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_single_op(log_op,locat,x.location);
     1191    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_single_op(log_op,locat,x.loc());
    11501192        put_op(log_op);
    1151         ADOLC_PUT_LOCINT(x.location); // = arg
     1193        ADOLC_PUT_LOCINT(x.loc()); // = arg
    11521194        ADOLC_PUT_LOCINT(locat);      // = res
    11531195
     
    11581200
    11591201    ADOLC_GLOBAL_TAPE_VARS.store[locat] =
    1160         ADOLC_MATH_NSP::log(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
     1202        ADOLC_MATH_NSP::log(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
    11611203    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    11621204    return locat;
     
    11701212    locint locat = next_loc();
    11711213
    1172     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_single_op(sqrt_op,locat,x.location);
     1214    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_single_op(sqrt_op,locat,x.loc());
    11731215        put_op(sqrt_op);
    1174         ADOLC_PUT_LOCINT(x.location); // = arg
     1216        ADOLC_PUT_LOCINT(x.loc()); // = arg
    11751217        ADOLC_PUT_LOCINT(locat);      // = res
    11761218
     
    11811223
    11821224    ADOLC_GLOBAL_TAPE_VARS.store[locat] =
    1183         ADOLC_MATH_NSP::sqrt(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
     1225        ADOLC_MATH_NSP::sqrt(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
    11841226    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    11851227    return locat;
     
    12001242    adouble y;
    12011243
    1202     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(sin_op,locat,x.location,y.location);
     1244    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(sin_op,locat,x.loc(),y.loc());
    12031245        put_op(sin_op);
    1204         ADOLC_PUT_LOCINT(x.location); // = arg1
    1205         ADOLC_PUT_LOCINT(y.location); // = arg2
     1246        ADOLC_PUT_LOCINT(x.loc()); // = arg1
     1247        ADOLC_PUT_LOCINT(y.loc()); // = arg2
    12061248        ADOLC_PUT_LOCINT(locat);      // = res
    12071249
    12081250        ADOLC_CURRENT_TAPE_INFOS.numTays_Tape += 2;
    12091251        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors) { /* olvo 980921 changed order */
    1210             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.location]);
     1252            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.loc()]);
    12111253            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
    12121254        }
     
    12141256
    12151257    ADOLC_GLOBAL_TAPE_VARS.store[locat] =
    1216         ADOLC_MATH_NSP::sin(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
    1217     ADOLC_GLOBAL_TAPE_VARS.store[y.location] =
    1218         ADOLC_MATH_NSP::cos(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
     1258        ADOLC_MATH_NSP::sin(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
     1259    ADOLC_GLOBAL_TAPE_VARS.store[y.loc()] =
     1260        ADOLC_MATH_NSP::cos(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
    12191261    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    12201262    return locat;
     
    12301272    adouble y;
    12311273
    1232     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(cos_op, locat,x.location,y.location);
     1274    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(cos_op, locat,x.loc(),y.loc());
    12331275        put_op(cos_op);
    1234         ADOLC_PUT_LOCINT(x.location); // = arg1
    1235         ADOLC_PUT_LOCINT(y.location); // = arg2
     1276        ADOLC_PUT_LOCINT(x.loc()); // = arg1
     1277        ADOLC_PUT_LOCINT(y.loc()); // = arg2
    12361278        ADOLC_PUT_LOCINT(locat);      // = res
    12371279
    12381280        ADOLC_CURRENT_TAPE_INFOS.numTays_Tape += 2;
    12391281        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors) { /* olvo 980921 changed order */
    1240             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.location]);
     1282            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.loc()]);
    12411283            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
    12421284        }
     
    12441286
    12451287    ADOLC_GLOBAL_TAPE_VARS.store[locat] =
    1246         ADOLC_MATH_NSP::cos(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
    1247     ADOLC_GLOBAL_TAPE_VARS.store[y.location] =
    1248         ADOLC_MATH_NSP::sin(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
     1288        ADOLC_MATH_NSP::cos(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
     1289    ADOLC_GLOBAL_TAPE_VARS.store[y.loc()] =
     1290        ADOLC_MATH_NSP::sin(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
    12491291    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    12501292    return locat;
     
    12661308    adouble y = 1.0 / sqrt(1.0 - x*x);
    12671309
    1268     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old:  write_quad(asin_op,locat,x.location,y.location);
     1310    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old:  write_quad(asin_op,locat,x.loc(),y.loc());
    12691311        put_op(asin_op);
    1270         ADOLC_PUT_LOCINT(x.location); // = arg1
    1271         ADOLC_PUT_LOCINT(y.location); // = arg2
     1312        ADOLC_PUT_LOCINT(x.loc()); // = arg1
     1313        ADOLC_PUT_LOCINT(y.loc()); // = arg2
    12721314        ADOLC_PUT_LOCINT(locat);      // = res
    12731315
     
    12781320
    12791321    ADOLC_GLOBAL_TAPE_VARS.store[locat] =
    1280         ADOLC_MATH_NSP::asin(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
     1322        ADOLC_MATH_NSP::asin(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
    12811323    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    12821324    return locat;
     
    12921334    adouble y = -1.0 / sqrt(1.0 - x*x);
    12931335
    1294     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(acos_op,locat,x.location,y.location);
     1336    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(acos_op,locat,x.loc(),y.loc());
    12951337        put_op(acos_op);
    1296         ADOLC_PUT_LOCINT(x.location); // = arg1
    1297         ADOLC_PUT_LOCINT(y.location); // = arg2
     1338        ADOLC_PUT_LOCINT(x.loc()); // = arg1
     1339        ADOLC_PUT_LOCINT(y.loc()); // = arg2
    12981340        ADOLC_PUT_LOCINT(locat);      // = res
    12991341
     
    13041346
    13051347    ADOLC_GLOBAL_TAPE_VARS.store[locat] =
    1306         ADOLC_MATH_NSP::acos(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
     1348        ADOLC_MATH_NSP::acos(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
    13071349    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    13081350    return locat;
     
    13181360    adouble y = 1.0 / (1.0 + x*x);
    13191361
    1320     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(atan_op,locat,x.location,y.location);
     1362    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(atan_op,locat,x.loc(),y.loc());
    13211363        put_op(atan_op);
    1322         ADOLC_PUT_LOCINT(x.location); // = arg1
    1323         ADOLC_PUT_LOCINT(y.location); // = arg2
     1364        ADOLC_PUT_LOCINT(x.loc()); // = arg1
     1365        ADOLC_PUT_LOCINT(y.loc()); // = arg2
    13241366        ADOLC_PUT_LOCINT(locat);      // = res
    13251367
     
    13301372
    13311373    ADOLC_GLOBAL_TAPE_VARS.store[locat] =
    1332         ADOLC_MATH_NSP::atan(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
     1374        ADOLC_MATH_NSP::atan(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
    13331375    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    13341376    return locat;
     
    13551397    locint locat = next_loc();
    13561398
    1357     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(pow_op,locat,cocval,x.location);
     1399    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(pow_op,locat,cocval,x.loc());
    13581400        put_op(pow_op);
    1359         ADOLC_PUT_LOCINT(x.location); // = arg
     1401        ADOLC_PUT_LOCINT(x.loc()); // = arg
    13601402        ADOLC_PUT_LOCINT(locat);      // = res
    13611403        ADOLC_PUT_VAL(coval);         // = coval
     
    13671409
    13681410    ADOLC_GLOBAL_TAPE_VARS.store[locat] =
    1369         ADOLC_MATH_NSP::pow(ADOLC_GLOBAL_TAPE_VARS.store[x.location],coval);
     1411        ADOLC_MATH_NSP::pow(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()],coval);
    13701412    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    13711413    return locat;
     
    14561498    locint locat=next_loc();
    14571499
    1458     double coval = ADOLC_MATH_NSP::ceil(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
    1459 
    1460     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(ceil_op,locat,coval,x.location);
     1500    double coval = ADOLC_MATH_NSP::ceil(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
     1501
     1502    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(ceil_op,locat,coval,x.loc());
    14611503        put_op(ceil_op);
    1462         ADOLC_PUT_LOCINT(x.location); // = arg
     1504        ADOLC_PUT_LOCINT(x.loc()); // = arg
    14631505        ADOLC_PUT_LOCINT(locat);      // = res
    14641506        ADOLC_PUT_VAL(coval);         // = coval
     
    14811523
    14821524    double coval =
    1483         ADOLC_MATH_NSP::floor(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
    1484 
    1485     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(floor_op,locat,coval,x.location);
     1525        ADOLC_MATH_NSP::floor(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
     1526
     1527    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(floor_op,locat,coval,x.loc());
    14861528        put_op(floor_op);
    1487         ADOLC_PUT_LOCINT(x.location); // = arg
     1529        ADOLC_PUT_LOCINT(x.loc()); // = arg
    14881530        ADOLC_PUT_LOCINT(locat);      // = res
    14891531        ADOLC_PUT_VAL(coval);         // = coval
     
    15101552    adouble y = 1.0 / sqrt(1.0 + x*x);
    15111553
    1512     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(asinh_op,locat,x.location,y.location);
     1554    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(asinh_op,locat,x.loc(),y.loc());
    15131555        put_op(asinh_op);
    1514         ADOLC_PUT_LOCINT(x.location); // = arg1
    1515         ADOLC_PUT_LOCINT(y.location); // = arg2
     1556        ADOLC_PUT_LOCINT(x.loc()); // = arg1
     1557        ADOLC_PUT_LOCINT(y.loc()); // = arg2
    15161558        ADOLC_PUT_LOCINT(locat);      // = res
    15171559
     
    15221564
    15231565    ADOLC_GLOBAL_TAPE_VARS.store[locat] =
    1524         ADOLC_MATH_NSP_ERF::asinh(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
     1566        ADOLC_MATH_NSP_ERF::asinh(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
    15251567    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    15261568    return locat;
     
    15361578    adouble y = 1.0 / sqrt(1.0 - x*x);
    15371579
    1538     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(acosh_op,locat,x.location,y.location);
     1580    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(acosh_op,locat,x.loc(),y.loc());
    15391581        put_op(acosh_op);
    1540         ADOLC_PUT_LOCINT(x.location); // = arg1
    1541         ADOLC_PUT_LOCINT(y.location); // = arg2
     1582        ADOLC_PUT_LOCINT(x.loc()); // = arg1
     1583        ADOLC_PUT_LOCINT(y.loc()); // = arg2
    15421584        ADOLC_PUT_LOCINT(locat);      // = res
    15431585
     
    15481590
    15491591    ADOLC_GLOBAL_TAPE_VARS.store[locat] =
    1550         ADOLC_MATH_NSP_ERF::acosh(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
     1592        ADOLC_MATH_NSP_ERF::acosh(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
    15511593    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    15521594    return locat;
     
    15621604    adouble y = 1.0 / (1.0 - x*x);
    15631605
    1564     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(atanh_op,locat,x.location,y.location);
     1606    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(atanh_op,locat,x.loc(),y.loc());
    15651607        put_op(atanh_op);
    1566         ADOLC_PUT_LOCINT(x.location); // = arg1
    1567         ADOLC_PUT_LOCINT(y.location); // = arg2
     1608        ADOLC_PUT_LOCINT(x.loc()); // = arg1
     1609        ADOLC_PUT_LOCINT(y.loc()); // = arg2
    15681610        ADOLC_PUT_LOCINT(locat);      // = res
    15691611
     
    15741616
    15751617    ADOLC_GLOBAL_TAPE_VARS.store[locat] =
    1576         ADOLC_MATH_NSP_ERF::atanh(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
     1618        ADOLC_MATH_NSP_ERF::atanh(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
    15771619    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    15781620    return locat;
     
    15891631        ADOLC_MATH_NSP_ERF::sqrt(ADOLC_MATH_NSP::acos(-1.0))*exp(-x*x);
    15901632
    1591     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(erf_op,locat,x.location,y.location);
     1633    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(erf_op,locat,x.loc(),y.loc());
    15921634        put_op(erf_op);
    1593         ADOLC_PUT_LOCINT(x.location); // = arg1
    1594         ADOLC_PUT_LOCINT(y.location); // = arg2
     1635        ADOLC_PUT_LOCINT(x.loc()); // = arg1
     1636        ADOLC_PUT_LOCINT(y.loc()); // = arg2
    15951637        ADOLC_PUT_LOCINT(locat);      // = res
    15961638
     
    16011643
    16021644    ADOLC_GLOBAL_TAPE_VARS.store[locat] =
    1603         ADOLC_MATH_NSP_ERF::erf(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
     1645        ADOLC_MATH_NSP_ERF::erf(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
    16041646    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    16051647    return locat;
     
    16161658
    16171659    double coval = 1.0;
    1618     double temp  = ADOLC_MATH_NSP::fabs(ADOLC_GLOBAL_TAPE_VARS.store[x.location]);
    1619     if (temp != ADOLC_GLOBAL_TAPE_VARS.store[x.location])
     1660    double temp  = ADOLC_MATH_NSP::fabs(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
     1661    if (temp != ADOLC_GLOBAL_TAPE_VARS.store[x.loc()])
    16201662        coval = 0.0;
    16211663
    1622     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { /*  write_args_d_a(abs_val,locat,coval,x.location); */
     1664    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { /*  write_args_d_a(abs_val,locat,coval,x.loc()); */
    16231665        put_op(abs_val);
    1624         ADOLC_PUT_LOCINT(x.location);   /* arg */
     1666        ADOLC_PUT_LOCINT(x.loc());   /* arg */
    16251667        ADOLC_PUT_LOCINT(locat);        /* res */
    16261668        ADOLC_PUT_VAL(coval);           /* coval */
     
    16411683    locint locat = next_loc();
    16421684
    1643     if (ADOLC_GLOBAL_TAPE_VARS.store[y.location] < ADOLC_GLOBAL_TAPE_VARS.store[x.location]) {
    1644         if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_min_op(x.location,y.location,locat,0.0);
     1685    if (ADOLC_GLOBAL_TAPE_VARS.store[y.loc()] < ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]) {
     1686        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_min_op(x.loc(),y.loc(),locat,0.0);
    16451687            put_op(min_op);
    1646             ADOLC_PUT_LOCINT(x.location); // = arg1
    1647             ADOLC_PUT_LOCINT(y.location); // = arg2
     1688            ADOLC_PUT_LOCINT(x.loc()); // = arg1
     1689            ADOLC_PUT_LOCINT(y.loc()); // = arg2
    16481690            ADOLC_PUT_LOCINT(locat);      // = res
    16491691            ADOLC_PUT_VAL(0.0);           // = coval
     
    16541696        }
    16551697
    1656         ADOLC_GLOBAL_TAPE_VARS.store[locat]=ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1698        ADOLC_GLOBAL_TAPE_VARS.store[locat]=ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    16571699    } else {
    1658         if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_min_op(x.location,y.location,locat,1.0);
     1700        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_min_op(x.loc(),y.loc(),locat,1.0);
    16591701            put_op(min_op);
    1660             ADOLC_PUT_LOCINT(x.location); // = arg1
    1661             ADOLC_PUT_LOCINT(y.location); // = arg2
     1702            ADOLC_PUT_LOCINT(x.loc()); // = arg1
     1703            ADOLC_PUT_LOCINT(y.loc()); // = arg2
    16621704            ADOLC_PUT_LOCINT(locat);      // = res
    16631705            ADOLC_PUT_VAL(1.0);           // = coval
     
    16681710        }
    16691711
    1670         ADOLC_GLOBAL_TAPE_VARS.store[locat]=ADOLC_GLOBAL_TAPE_VARS.store[x.location];
     1712        ADOLC_GLOBAL_TAPE_VARS.store[locat]=ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
    16711713    }
    16721714    return locat;
     
    17231765    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) \
    17241766    { put_op(gen_quad); \
    1725       ADOLC_PUT_LOCINT(arg.location); \
    1726       ADOLC_PUT_LOCINT(val.location); \
    1727       ADOLC_PUT_LOCINT(temp.location); \
     1767      ADOLC_PUT_LOCINT(arg.loc()); \
     1768      ADOLC_PUT_LOCINT(val.loc()); \
     1769      ADOLC_PUT_LOCINT(temp.loc()); \
    17281770      ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape; \
    17291771      if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors) \
    1730         ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[temp.location]); \
     1772        ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[temp.loc()]); \
    17311773    } \
    1732     ADOLC_GLOBAL_TAPE_VARS.store[temp.location]=func(ADOLC_GLOBAL_TAPE_VARS.store[arg.location]); \
     1774    ADOLC_GLOBAL_TAPE_VARS.store[temp.loc()]=func(ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()]); \
    17331775    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) \
    1734     { ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[arg.location]); \
    1735       ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[temp.location]); \
     1776    { ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()]); \
     1777      ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[temp.loc()]); \
    17361778    } \
    17371779    return temp; }
     
    17551797    ADOLC_OPENMP_THREAD_NUMBER;
    17561798    ADOLC_OPENMP_GET_THREAD_NUMBER;
    1757     double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.location];
    1758     double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1799    double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
     1800    double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    17591801    double res = (double)(xval != yval);
    17601802    locint locat = next_loc();
    17611803    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    17621804        put_op(neq_a_a);
    1763         ADOLC_PUT_LOCINT(x.location); // arg
    1764         ADOLC_PUT_LOCINT(y.location); // arg1
     1805        ADOLC_PUT_LOCINT(x.loc()); // arg
     1806        ADOLC_PUT_LOCINT(y.loc()); // arg1
    17651807        ADOLC_PUT_VAL(res);           // check for branch switch
    17661808        ADOLC_PUT_LOCINT(locat);      // res
     
    17771819    ADOLC_OPENMP_THREAD_NUMBER;
    17781820    ADOLC_OPENMP_GET_THREAD_NUMBER;
    1779     double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.location];
    1780     double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1821    double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
     1822    double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    17811823    double res = (double)(xval == yval);
    17821824    locint locat = next_loc();
    17831825    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    17841826        put_op(eq_a_a);
    1785         ADOLC_PUT_LOCINT(x.location); // arg
    1786         ADOLC_PUT_LOCINT(y.location); // arg1
     1827        ADOLC_PUT_LOCINT(x.loc()); // arg
     1828        ADOLC_PUT_LOCINT(y.loc()); // arg1
    17871829        ADOLC_PUT_VAL(res);           // check for branch switch
    17881830        ADOLC_PUT_LOCINT(locat);      // res
     
    17991841    ADOLC_OPENMP_THREAD_NUMBER;
    18001842    ADOLC_OPENMP_GET_THREAD_NUMBER;
    1801     double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.location];
    1802     double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1843    double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
     1844    double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    18031845    double res = (double)(xval <= yval);
    18041846    locint locat = next_loc();
    18051847    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    18061848        put_op(le_a_a);
    1807         ADOLC_PUT_LOCINT(x.location); // arg
    1808         ADOLC_PUT_LOCINT(y.location); // arg1
     1849        ADOLC_PUT_LOCINT(x.loc()); // arg
     1850        ADOLC_PUT_LOCINT(y.loc()); // arg1
    18091851        ADOLC_PUT_VAL(res);           // check for branch switch
    18101852        ADOLC_PUT_LOCINT(locat);      // res
     
    18211863    ADOLC_OPENMP_THREAD_NUMBER;
    18221864    ADOLC_OPENMP_GET_THREAD_NUMBER;
    1823     double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.location];
    1824     double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1865    double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
     1866    double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    18251867    double res = (double)(xval >= yval);
    18261868    locint locat = next_loc();
    18271869    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    18281870        put_op(ge_a_a);
    1829         ADOLC_PUT_LOCINT(x.location); // arg
    1830         ADOLC_PUT_LOCINT(y.location); // arg1
     1871        ADOLC_PUT_LOCINT(x.loc()); // arg
     1872        ADOLC_PUT_LOCINT(y.loc()); // arg1
    18311873        ADOLC_PUT_VAL(res);           // check for branch switch
    18321874        ADOLC_PUT_LOCINT(locat);      // res
     
    18431885    ADOLC_OPENMP_THREAD_NUMBER;
    18441886    ADOLC_OPENMP_GET_THREAD_NUMBER;
    1845     double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.location];
    1846     double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1887    double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
     1888    double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    18471889    double res = (double)(xval > yval);
    18481890    locint locat = next_loc();
    18491891    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    18501892        put_op(gt_a_a);
    1851         ADOLC_PUT_LOCINT(x.location); // arg
    1852         ADOLC_PUT_LOCINT(y.location); // arg1
     1893        ADOLC_PUT_LOCINT(x.loc()); // arg
     1894        ADOLC_PUT_LOCINT(y.loc()); // arg1
    18531895        ADOLC_PUT_VAL(res);           // check for branch switch
    18541896        ADOLC_PUT_LOCINT(locat);      // res
     
    18651907    ADOLC_OPENMP_THREAD_NUMBER;
    18661908    ADOLC_OPENMP_GET_THREAD_NUMBER;
    1867     double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.location];
    1868     double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.location];
     1909    double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
     1910    double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
    18691911    double res = (double)(xval < yval);
    18701912    locint locat = next_loc();
    18711913    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    18721914        put_op(lt_a_a);
    1873         ADOLC_PUT_LOCINT(x.location); // arg
    1874         ADOLC_PUT_LOCINT(y.location); // arg1
     1915        ADOLC_PUT_LOCINT(x.loc()); // arg
     1916        ADOLC_PUT_LOCINT(y.loc()); // arg1
    18751917        ADOLC_PUT_VAL(res);           // check for branch switch
    18761918        ADOLC_PUT_LOCINT(locat);      // res
     
    18901932    ADOLC_OPENMP_THREAD_NUMBER;
    18911933    ADOLC_OPENMP_GET_THREAD_NUMBER;
    1892     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign(res.location,cond.location,arg1.location,
    1893         //                   arg2.location);
     1934    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign(res.loc(),cond.loc(),arg1.loc(),
     1935        //                   arg2.loc());
    18941936        put_op(cond_assign);
    1895         ADOLC_PUT_LOCINT(cond.location); // = arg
    1896         ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.location]);
    1897         ADOLC_PUT_LOCINT(arg1.location); // = arg1
    1898         ADOLC_PUT_LOCINT(arg2.location); // = arg2
    1899         ADOLC_PUT_LOCINT(res.location);  // = res
    1900 
    1901         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    1902         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    1903             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.location]);
    1904     }
    1905 
    1906     if (ADOLC_GLOBAL_TAPE_VARS.store[cond.location] > 0)
    1907         ADOLC_GLOBAL_TAPE_VARS.store[res.location] = ADOLC_GLOBAL_TAPE_VARS.store[arg1.location];
     1937        ADOLC_PUT_LOCINT(cond.loc()); // = arg
     1938        ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
     1939        ADOLC_PUT_LOCINT(arg1.loc()); // = arg1
     1940        ADOLC_PUT_LOCINT(arg2.loc()); // = arg2
     1941        ADOLC_PUT_LOCINT(res.loc());  // = res
     1942
     1943        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     1944        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     1945            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
     1946    }
     1947
     1948    if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
     1949        ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg1.loc()];
    19081950    else
    1909         ADOLC_GLOBAL_TAPE_VARS.store[res.location] = ADOLC_GLOBAL_TAPE_VARS.store[arg2.location];
     1951        ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg2.loc()];
    19101952}
    19111953
     
    19141956    ADOLC_OPENMP_THREAD_NUMBER;
    19151957    ADOLC_OPENMP_GET_THREAD_NUMBER;
    1916     if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign2(res.location,cond.location,arg.location);
     1958    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign2(res.loc(),cond.loc(),arg.loc());
    19171959        put_op(cond_assign_s);
    1918         ADOLC_PUT_LOCINT(cond.location); // = arg
    1919         ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.location]);
    1920         ADOLC_PUT_LOCINT(arg.location);  // = arg1
    1921         ADOLC_PUT_LOCINT(res.location);  // = res
    1922 
    1923         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
    1924         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
    1925             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.location]);
    1926     }
    1927 
    1928     if (ADOLC_GLOBAL_TAPE_VARS.store[cond.location] > 0)
    1929         ADOLC_GLOBAL_TAPE_VARS.store[res.location] = ADOLC_GLOBAL_TAPE_VARS.store[arg.location];
     1960        ADOLC_PUT_LOCINT(cond.loc()); // = arg
     1961        ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
     1962        ADOLC_PUT_LOCINT(arg.loc());  // = arg1
     1963        ADOLC_PUT_LOCINT(res.loc());  // = res
     1964
     1965        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     1966        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     1967            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
     1968    }
     1969
     1970    if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
     1971        ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()];
    19301972}
    19311973
  • trunk/ADOL-C/src/advector.cpp

    r408 r427  
    420420    locint locat = next_loc();
    421421    size_t n = data.size();
    422     static size_t callcounter  = 0;
    423422    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    424423        put_op(subscript);
     
    434433
    435434    if (idx >= n)
    436         fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting n=%z, idx=%z\n", n, idx);
     435        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting n=%zu, idx=%zu\n", n, idx);
    437436
    438437    ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[data[idx].loc()];
     
    459458
    460459    if (idx >= n)
    461         fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting (ref) n=%z, idx=%z\n", n, idx);
     460        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting (ref) n=%zu, idx=%zu\n", n, idx);
    462461
    463462    ADOLC_GLOBAL_TAPE_VARS.store[locat] = data[idx].loc();
     
    476475    adouble r = 0;
    477476    size_t n = data.size();
    478     for (int i = 0; i < n; i++)
     477    for (size_t i = 0; i < n; i++)
    479478        condassign(r, x - data[i]*y, (adouble) (i+1));
    480479    return r;
  • trunk/ADOL-C/src/externfcts.cpp

    r370 r427  
    8080{
    8181    int i = 0, ret;
    82     locint numVals;
    83     double *vals;
     82    locint numVals = 0;
     83    double *vals = NULL;
    8484    ADOLC_OPENMP_THREAD_NUMBER;
    8585    ADOLC_OPENMP_GET_THREAD_NUMBER;
    8686
    87     if (xa[n-1].loc()-xa[0].loc()!=n-1 || ya[m-1].loc()-ya[0].loc()!=m-1) fail(ADOLC_EXT_DIFF_LOCATIONGAP);
     87    if (xa[n-1].loc()-xa[0].loc()!=(unsigned)n-1 || ya[m-1].loc()-ya[0].loc()!=(unsigned)m-1) fail(ADOLC_EXT_DIFF_LOCATIONGAP);
    8888    if (edfct==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_STRUCT);
    8989
  • trunk/ADOL-C/src/fo_rev.c

    r376 r427  
    268268
    269269#if !defined (_NTIGHT_)
    270     double coval = 0, *d = 0;
     270    double coval = 0;
    271271#endif
    272272
     
    17001700            case subscript:
    17011701                {
    1702                     double val = get_val_r();
    1703                     size_t cnt, idx, numval = (size_t)trunc(fabs(val));
     1702#if !defined(_NTIGHT_)
     1703                    double val =
     1704#endif
     1705                    get_val_r();
     1706#if !defined(_NTIGHT_)
     1707                    size_t idx, numval = (size_t)trunc(fabs(val));
    17041708                    locint vectorloc;
    1705                     vectorloc = get_locint_r();
     1709                    vectorloc =
     1710#endif
     1711                    get_locint_r();
    17061712                    res = get_locint_r();
    17071713                    arg = get_locint_r();
     
    17091715                    idx = (size_t)trunc(fabs(TARG));
    17101716                    if (idx >= numval)
    1711                         fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting n=%z, idx=%z\n", numval, idx);
     1717                        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting n=%zu, idx=%zu\n", numval, idx);
    17121718                    arg1 = vectorloc+idx;
    17131719                    ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
     
    17331739            case subscript_ref:
    17341740                {
    1735                     double val = get_val_r();
    1736                     size_t cnt, idx, numval = (size_t)trunc(fabs(val));
     1741#if !defined(_NTIGHT_)
     1742                    double val =
     1743#endif
     1744                    get_val_r();
     1745#if !defined(_NTIGHT_)
     1746                    size_t idx, numval = (size_t)trunc(fabs(val));
    17371747                    locint vectorloc;
    1738                     vectorloc = get_locint_r();
     1748                    vectorloc =
     1749#endif
     1750                    get_locint_r();
    17391751                    res = get_locint_r();
    17401752                    arg = get_locint_r();
     
    17421754                    idx = (size_t)trunc(fabs(TARG));
    17431755                    if (idx >= numval)
    1744                         fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting (ref) n=%z, idx=%z\n", numval, idx);
     1756                        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting (ref) n=%zu, idx=%zu\n", numval, idx);
    17451757                    arg1 = (size_t)trunc(fabs(TRES));
    17461758                    // This is actually NOP
     
    17481760                    // so doing a check here is probably good
    17491761                    if (arg1 != vectorloc+idx) {
    1750                         fprintf(DIAG_OUT, "ADOL-C error: indexed active position does not match referenced position\nindexed = %d, referenced = %d\n", vectorloc+idx, arg1);
     1762                        fprintf(DIAG_OUT, "ADOL-C error: indexed active position does not match referenced position\nindexed = %zu, referenced = %d\n", vectorloc+idx, arg1);
    17511763                        exit(-2);
    17521764                    }
     
    20202032        case ref_cond_assign:                                      /* cond_assign */
    20212033           {
    2022                 locint ref    = get_locint_r();
     2034#if !defined(_NTIGHT_)
     2035                locint ref    =
     2036#endif
     2037                get_locint_r();
    20232038                arg2   = get_locint_r();
    20242039                arg1   = get_locint_r();
     
    21242139                size = get_locint_r();
    21252140#if !defined(_NTIGHT_)
    2126                 d    = get_val_v_r(size);
     2141                get_val_v_r(size);
    21272142#endif /* !_NTIGHT_ */
    21282143
  • trunk/ADOL-C/src/ho_rev.c

    r376 r427  
    375375    locint arg2 = 0;
    376376
    377     double coval = 0, *d = 0;
     377    double coval = 0;
    378378
    379379    int indexi = 0,  indexd = 0;
     
    20672067                coval = get_val_r();
    20682068                {
    2069                     size_t cnt, idx, numval = (size_t)trunc(fabs(coval));
     2069                    size_t idx, numval = (size_t)trunc(fabs(coval));
    20702070                    locint vectorloc;
    20712071                    vectorloc = get_locint_r();
     
    20752075                    idx = (size_t)trunc(fabs(TARG));
    20762076                    if (idx >= numval)
    2077                         fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting n=%z, idx=%z\n", numval, idx);
     2077                        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting n=%zu, idx=%zu\n", numval, idx);
    20782078                    arg1 = vectorloc+idx;
    20792079                    ASSIGN_A(Aarg1, rpp_A[arg1])
     
    21012101                coval = get_val_r();
    21022102                {
    2103                     size_t cnt, idx, numval = (size_t)trunc(fabs(coval));
     2103                    size_t idx, numval = (size_t)trunc(fabs(coval));
    21042104                    locint vectorloc;
    21052105                    vectorloc = get_locint_r();
     
    21102110                    idx = (size_t)trunc(fabs(TARG));
    21112111                    if (idx >= numval)
    2112                         fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting (ref) n=%z, idx=%z\n", numval, idx);
     2112                        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting (ref) n=%zu, idx=%zu\n", numval, idx);
    21132113                    arg1 = (size_t)trunc(fabs(TRES));
    21142114                    // This is actually NOP
     
    21162116                    // so doing a check here is probably good
    21172117                    if (arg1 != vectorloc+idx) {
    2118                         fprintf(DIAG_OUT, "ADOL-C error: indexed active position does not match referenced position\nindexed = %d, referenced = %d\n", vectorloc+idx, arg1);
     2118                        fprintf(DIAG_OUT, "ADOL-C error: indexed active position does not match referenced position\nindexed = %zu, referenced = %d\n", vectorloc+idx, arg1);
    21192119                        exit(-2);
    21202120                    }
     
    25142514                res = get_locint_r();
    25152515                size = get_locint_r();
    2516                 d = get_val_v_r(size);
     2516                get_val_v_r(size);
    25172517
    25182518                res += size;
  • trunk/ADOL-C/src/sparse/sparsedrivers.cpp

    r373 r427  
    115115#if HAVE_LIBCOLPACK
    116116{
    117   int dummy, i, j;
     117  int dummy;
    118118
    119119    BipartiteGraphPartialColoringInterface *g = new BipartiteGraphPartialColoringInterface(SRC_MEM_ADOLC, JP, m, n);
     
    197197#if HAVE_LIBCOLPACK
    198198{
    199   int seed_rows, i, j;
     199  int seed_rows;
    200200
    201201  GraphColoringInterface *g = new GraphColoringInterface(SRC_MEM_ADOLC, HP, n);
     
    263263    unsigned int j;
    264264    SparseJacInfos sJinfos;
    265     int dummy;
    266     int ret_val;
     265    int ret_val = 0;
    267266    BipartiteGraphPartialColoringInterface *g;
    268267    TapeInfos *tapeInfos;
     
    691690#ifdef SPARSE
    692691{
    693     SparseHessInfos sHinfos;
    694692    TapeInfos *tapeInfos;
    695693
     
    10551053                        void *jr1d, int seed_rows, int seed_clms, int depen)
    10561054{
    1057     int i;
    10581055    if(y)
    10591056      myfree1(y);
     
    10841081                         void *g, void *hr, int p, int indep)
    10851082{
    1086     int i;
    1087 
    10881083    if(Hcomp)
    10891084      myfree2(Hcomp);
  • trunk/ADOL-C/src/storemanager.h

    r408 r427  
    125125    };
    126126
    127     list<struct FreeBlock> indexFree;
     127    std::list<struct FreeBlock> indexFree;
    128128    size_t &maxsize;
    129129    size_t &currentfill;
  • trunk/ADOL-C/src/tape_handling.cpp

    r353 r427  
    115115    head = stm->head;
    116116    indexFree = new locint[maxsize];
    117     for (int i = 0; i < maxsize; i++)
     117    for (size_t i = 0; i < maxsize; i++)
    118118        indexFree[i] = stm->indexFree[i];
    119119}
  • trunk/ADOL-C/src/tapedoc/tapedoc.c

    r337 r427  
    297297        fprintf(DIAG_OUT,"Number of dependent (%d) and/or independent (%d) "
    298298                "variables passed to Tape_doc is\ninconsistent with "
    299                 "number recorded on tape %d (%d:%d)\n", depcheck,
     299                "number recorded on tape %d (%zu:%zu)\n", depcheck,
    300300                indcheck, tag, ADOLC_CURRENT_TAPE_INFOS.stats[NUM_DEPENDENTS],
    301301                ADOLC_CURRENT_TAPE_INFOS.stats[NUM_INDEPENDENTS]);
  • trunk/ADOL-C/src/taping.c

    r370 r427  
    181181                    "              variables passed to reverse is "
    182182                    "inconsistent\n"
    183                     "              with number recorded on tape(%u/%u)!\n",
     183                    "              with number recorded on tape(%zu/%zu)!\n",
    184184                    ADOLC_CURRENT_TAPE_INFOS.tapeID, failAdditionalInfo3,
    185185                    failAdditionalInfo4,
  • trunk/ADOL-C/src/uni5_for.c

    r376 r427  
    763763    locint arg2 = 0;
    764764
    765     double coval = 0, *d = 0;
     765#if !defined(_NTIGHT_)
     766    double coval = 0;
     767    double *d=NULL;
     768#endif
    766769
    767770    int indexi = 0,  indexd = 0;
     
    789792#endif
    790793#if defined (_INDO_)
     794#if defined(_INDOPRO_)
    791795    int l=0;
    792796    int max_ind_dom;
    793 #if defined(_INDOPRO_)
    794797    /* index domains */
    795798    locint** ind_dom;
     
    810813    /* nonlinear interaction domains */
    811814    locint** nonl_dom;
    812     locint*  temp;
    813     locint*  temp1;
    814815#endif
    815816#endif
     
    820821#if !defined (_INT_FOR_)
    821822    double r0=0.0, x, y, divs;
     823#if defined(_HIGHER_ORDER_)
    822824    int even;
     825#endif
    823826#endif
    824827#endif
     
    828831#ifdef _TIGHT_
    829832    double  *dp_T0;
    830     double y, divs;
     833    double y;
    831834#endif /* _TIGHT_ */
    832835
     
    845848#ifdef _TIGHT_
    846849    double  *dp_T0;
    847     double  T0temp;
    848     double divs;
    849850#endif /* _TIGHT_ */
    850851#define T0res  T0temp
     
    970971                "Number of dependent(%u) and/or independent(%u) variables passed"
    971972                " to forward is\ninconsistent with number "
    972                 "recorded on tape (%d, %d) \n", tnum,
     973                "recorded on tape (%zu, %zu) \n", tnum,
    973974                depcheck, indcheck,
    974975                ADOLC_CURRENT_TAPE_INFOS.stats[NUM_DEPENDENTS],
     
    13161317                /* double value. (=) */
    13171318                res   = get_locint_f();
    1318                 coval = get_val_f();
     1319#if !defined(_NTIGHT_)
     1320                coval =
     1321#endif
     1322                get_val_f();
    13191323
    13201324                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    14991503                /* adouble. (+=) */
    15001504                res   = get_locint_f();
    1501                 coval = get_val_f();
     1505#if !defined(_NTIGHT_)
     1506                coval =
     1507#endif
     1508                get_val_f();
    15021509
    15031510                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    15501557                /* adouble. (-=) */
    15511558                res = get_locint_f();
    1552                 coval = get_val_f();
     1559#if !defined(_NTIGHT_)
     1560                coval =
     1561#endif
     1562                get_val_f();
    15531563
    15541564                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    16011611                /* flaoting point. (*=) */
    16021612                res   = get_locint_f();
    1603                 coval = get_val_f();
     1613#if !defined(_NTIGHT_)
     1614                coval =
     1615#endif
     1616                get_val_f();
    16041617
    16051618                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    17501763                arg   = get_locint_f();
    17511764                res   = get_locint_f();
    1752                 coval = get_val_f();
     1765#if !defined(_NTIGHT_)
     1766                coval =
     1767#endif
     1768                get_val_f();
    17531769
    17541770                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    18231839                arg =get_locint_f();
    18241840                res = get_locint_f();
    1825                 coval = get_val_f();
     1841#if !defined(_NTIGHT_)
     1842                coval =
     1843#endif
     1844                get_val_f();
    18261845
    18271846                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    20622081                arg   = get_locint_f();
    20632082                res   = get_locint_f();
    2064                 coval = get_val_f();
     2083#if !defined(_NTIGHT_)
     2084                coval =
     2085#endif
     2086                get_val_f();
    20652087
    20662088                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    21032125
    21042126#if !defined(_NTIGHT_)
    2105 #if !defined(_ZOS_) /* BREAK_ZOS */
     2127#if !defined(_ZOS_) && !defined(_INT_FOR_) && !defined(_INDO_)
    21062128                divs = 1.0 / dp_T0[arg2];
    21072129#endif /* ALL_TOGETHER_AGAIN */
     
    21652187            arg   = get_locint_f();
    21662188                res   = get_locint_f();
    2167                 coval = get_val_f();
     2189#if !defined(_NTIGHT_)
     2190                coval =
     2191#endif
     2192                get_val_f();
    21682193
    21692194                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    21752200
    21762201#if !defined(_NTIGHT_)
    2177 #if !defined(_ZOS_) /* BREAK_ZOS */
     2202#if !defined(_ZOS_) && !defined(_INT_FOR_) && !defined(_INDO_)
    21782203                divs = 1.0 / dp_T0[arg];
    21792204#endif /* ALL_TOGETHER_AGAIN */
     
    31733198                res   = get_locint_f();
    31743199
    3175                 coval = get_val_f();
     3200#if !defined(_NTIGHT_)
     3201                coval =
     3202#endif
     3203                get_val_f();
    31763204
    31773205                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    31853213
    31863214#ifndef _ZOS_ /* BREAK_ZOS */
    3187 #if !defined(_INT_FOR_)
     3215#if !defined(_INT_FOR_) && !defined(_INDO_)
    31883216                T0arg   = dp_T0[arg];
    31893217#endif
     
    33863414                  Targ = TargOP;
    33873415
     3416#if defined(_HIGHER_ORDER_)
    33883417                  even = 1;
     3418#endif
    33893419                  FOR_0_LE_i_LT_k
    33903420                  { TRES_FOINC = r0 * TARG_INC;
     
    34253455#endif /* !_NTIGHT_ */
    34263456
    3427                 coval = get_val_f();
     3457#if !defined(_NTIGHT_)
     3458                coval =
     3459#endif
     3460                get_val_f();
    34283461
    34293462                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    34793512                arg2  = get_locint_f();
    34803513                res   = get_locint_f();
    3481                 coval = get_val_f();
     3514#if !defined(_NTIGHT_)
     3515                coval =
     3516#endif
     3517                get_val_f();
    34823518
    34833519                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    36453681                arg   = get_locint_f();
    36463682                res   = get_locint_f();
    3647                 coval = get_val_f();
     3683#if !defined(_NTIGHT_)
     3684                coval =
     3685#endif
     3686                get_val_f();
    36483687
    36493688                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    37313770                arg   = get_locint_f();
    37323771                res   = get_locint_f();
    3733                 coval = get_val_f();
     3772#if !defined(_NTIGHT_)
     3773                coval =
     3774#endif
     3775                get_val_f();
    37343776
    37353777                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    37673809                arg   = get_locint_f();
    37683810                res   = get_locint_f();
    3769                 coval = get_val_f();
     3811#if !defined(_NTIGHT_)
     3812                coval =
     3813#endif
     3814                get_val_f();
    37703815
    37713816                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    38093854                arg2  = get_locint_f();
    38103855                res   = get_locint_f();
    3811                 coval = get_val_f();
     3856#if !defined(_NTIGHT_)
     3857                coval =
     3858#endif
     3859                get_val_f();
    38123860
    38133861                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    39223970                arg1  = get_locint_f();
    39233971                res   = get_locint_f();
    3924                 coval = get_val_f();
     3972#if !defined(_NTIGHT_)
     3973                coval =
     3974#endif
     3975                get_val_f();
    39253976
    39263977                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     
    39914042            case lt_a_a:
    39924043            case gt_a_a:
    3993                 coval = get_val_f();
     4044#if !defined(_NTIGHT_)
     4045                coval =
     4046#endif
     4047                get_val_f();
    39944048                arg = get_locint_f();
    39954049                arg1 = get_locint_f();
     
    40574111                /*--------------------------------------------------------------------------*/
    40584112            case subscript:
    4059                 coval = get_val_f();
     4113#if !defined(_NTIGHT_)
     4114                coval =
     4115#endif
     4116                get_val_f();
    40604117                arg = get_locint_f();
    40614118                res = get_locint_f();
    40624119                {
    4063                     size_t cnt, idx, numvar = (size_t)trunc(fabs(coval));
     4120#if !defined(_NTIGHT_)
     4121                    size_t idx, numvar = (size_t)trunc(fabs(coval));
    40644122                    locint vectorloc;
    4065                     vectorloc = get_locint_f();
     4123                    vectorloc =
     4124#endif
     4125                    get_locint_f();
    40664126#if !defined(_NTIGHT_)
    40674127                    idx = (size_t)trunc(fabs(dp_T0[arg]));
    40684128                    if (idx >= numvar)
    4069                         fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting n=%z, idx=%z\n", numvar, idx);
     4129                        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting n=%zu, idx=%zu\n", numvar, idx);
    40704130                    arg1 = vectorloc+idx;
    40714131                    IF_KEEP_WRITE_TAYLOR(res,keep,k,p);
     
    40954155
    40964156            case subscript_ref:
    4097                 coval = get_val_f();
     4157#if !defined(_NTIGHT_)
     4158                coval =
     4159#endif
     4160                get_val_f();
    40984161                arg = get_locint_f();
    40994162                res = get_locint_f();
    41004163                {
    4101                     size_t cnt, idx, numvar = (size_t)trunc(fabs(coval));
     4164#if !defined(_NTIGHT_)
     4165                    size_t idx, numvar = (size_t)trunc(fabs(coval));
    41024166                    locint vectorloc;
    4103                     vectorloc = get_locint_f();
     4167                    vectorloc =
     4168#endif
     4169                    get_locint_f();
    41044170#if !defined(_NTIGHT_)
    41054171                    idx = (size_t)trunc(fabs(dp_T0[arg]));
    41064172                    if (idx >= numvar)
    4107                         fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting (ref) n=%z, idx=%z\n", numvar, idx);
     4173                        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting (ref) n=%zu, idx=%zu\n", numvar, idx);
    41084174                    arg1 = vectorloc+idx;
    41094175                    IF_KEEP_WRITE_TAYLOR(res,keep,k,p);
     
    41714237            case ref_assign_d:
    41724238                arg = get_locint_f();
    4173                 coval = get_val_f();
     4239#if !defined(_NTIGHT_)
     4240                coval =
     4241#endif
     4242                get_val_f();
    41744243               
    41754244#if !defined(_NTIGHT_)
     
    43384407                /* adouble. (+=) */
    43394408                arg  = get_locint_f();
    4340                 coval = get_val_f();
     4409#if !defined(_NTIGHT_)
     4410                coval =
     4411#endif
     4412                get_val_f();
    43414413
    43424414
     
    43944466                /* adouble. (-=) */
    43954467                arg = get_locint_f();
    4396                 coval = get_val_f();
     4468#if !defined(_NTIGHT_)
     4469                coval =
     4470#endif
     4471                get_val_f();
    43974472
    43984473#if !defined(_NTIGHT_)
     
    44494524                /* flaoting point. (*=) */
    44504525                arg = get_locint_f();
    4451                 coval = get_val_f();
     4526#if !defined(_NTIGHT_)
     4527                coval =
     4528#endif
     4529                get_val_f();
    44524530
    44534531#if !defined(_NTIGHT_)
     
    45374615                arg2  = get_locint_f();
    45384616                {
    4539                     locint ref = get_locint_f();
    4540                     coval = get_val_f();
     4617#if !defined(_NTIGHT_)
     4618                    locint ref =
     4619#endif
     4620                    get_locint_f();
     4621#if !defined(_NTIGHT_)
     4622                    coval =
     4623#endif
     4624                    get_val_f();
    45414625#if !defined(_NTIGHT_)
    45424626                    res   = (size_t)trunc(fabs(dp_T0[ref]));
     
    46354719                arg1  = get_locint_f();
    46364720                arg2   = get_locint_f();
    4637                 coval = get_val_f();
     4721#if !defined(_NTIGHT_)
     4722                coval =
     4723#endif
     4724                get_val_f();
    46384725
    46394726#if !defined(_NTIGHT_)
     
    46994786                size = get_locint_f();
    47004787                res  = get_locint_f();
    4701                 d    = get_val_v_f(size);
     4788#if !defined(_NTIGHT_)
     4789                d =
     4790#endif
     4791                get_val_v_f(size);
    47024792
    47034793                for (ls=0;ls<size;ls++) {
     
    50605150
    50615151  IndexElement_sod *temp, *temp1;
    5062   int ii;
    50635152
    50645153  if (tree->left != NULL)
     
    51595248{
    51605249  int index,num,num1, num2, i,j,k,l,m;
    5161   locint *temp_nonl, *index_nonl_dom, *arg1_ind_dom, *arg2_ind_dom;
     5250  locint *temp_nonl, *index_nonl_dom;
    51625251
    51635252  num = ind_dom[arg2][0];
  • trunk/configure.ac

    r410 r427  
    229229if test x$adolc_stdczero == xyes; then
    230230AC_DEFINE(ADOLC_ADOUBLE_STDCZERO,1,[ADOL-C adouble zeroing mode])
     231fi
     232
     233AC_MSG_CHECKING(wether the adouble varaibles have a late initialize option for functions like malloc/realloc)
     234AC_ARG_ENABLE(lateinit,
     235              [
     236AS_HELP_STRING([--enable-lateinit],[adouble constructors need to be called. With malloc or realloc that is not the case. With this option the adouble can do an late initialization.) [default=disabled]])],
     237  [
     238  adolc_late_init=yes
     239  AC_MSG_RESULT(yes)
     240  ],
     241  [
     242  adolc_late_init=no
     243  AC_MSG_RESULT(no)
     244  ])
     245
     246if test x$adolc_late_init == xyes; then
     247AC_DEFINE(ADOLC_ADOUBLE_LATEINIT,1,[ADOL-C adouble late initialization mode])
    231248fi
    232249
     
    526543echo \
    527544"  Use ADOL-C safe extern mode:        ${adolc_safe_extern}
     545  Use ADOL-C late init mode:          ${adolc_late_init}
    528546
    529547  Build sparse drivers:               ${sparse}
Note: See TracChangeset for help on using the changeset viewer.