Changeset 708 for trunk/ADOL-C/src


Ignore:
Timestamp:
Jul 12, 2016 4:18:44 AM (3 years ago)
Author:
kulshres
Message:

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

The following changes have been merged:

commit e2291bde44a282a133894b0db350aeb0b92a87db
Author: Mladen Banovic <mladenbanovic2705@…>
Date: Fri Jul 8 10:15:51 2016 +0200

Add methods getNumLiveVar and getNumDir in adtl.h, change counter type in FOR_I_EQ_0_LT_NUMDIR macro to size_t (instead of int). Update chunk size of BOOST pool in adouble_tl.cpp according to adouble::numDir.

commit 2ffb294465b973bfd4bf1f73d84478f8233c0d2f
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Jun 23 12:32:14 2016 +0200

implement missing ref_eq_mult_p und ref_eq_min_p in ho_rev.c

somehow these were left out when parameters were being implemented.

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

commit 8cf0e5c1bd36f1dcf3be72cd67de631b2e1d0ee6
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Jun 23 12:31:04 2016 +0200

make sure the result is the last locint written in trace for each operation

since we're trying to generate ascii traces in the future, we'll need this
convention that the last location is the result, and previous locations
are arguments. This has been the case for almost all operations anyway
except for a few new one's that I wrote without keeping this in mind.

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

commit 9ae0ff220f37463f2ed85cafc8a626c24e472f2f
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Jun 21 14:16:27 2016 +0200

on some compilers newer boost interferes with AC_FUNC_MALLOC test

so do AC_FUNC_MALLOC and AC_FUNC_REALLOC as usual and check for boost
library later.

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

commit b746f620772cc8cce53e8f350adc6281279caf72
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Jun 20 15:32:22 2016 +0200

make Klaus Röbenack's name UTF-8 instead of ISO-8859-1

These are the only places where we're not simple ASCII or UTF-8 already

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

commit 1171aa3961b5eb46a5d2ee64751c02a393a8a6f5
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Jun 17 10:42:39 2016 +0200

correct short_ref document about include file

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

commit 2c6b2aac2ef04431ece2c6ff80e574aa2e58814b
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Jun 17 10:40:34 2016 +0200

correct error message to new semantics

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

commit 506cde73451740bf0a15eff7d4abb158ee719ab0
Author: mflehmig <martin.flehmig@…>
Date: Fri Jun 17 10:14:26 2016 +0200

Fixed include of ADOL-C header.

ADOL-C header was included in old fashion (without adolc directory) for this example.

commit 2a023d3281d3d6d9824bad724a5768e3ee2fff94
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Jun 16 13:50:39 2016 +0200

Try to use boost::pool for allocating advals in traceless vector mode

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

commit 80f1e2019ac1faab96fe06f3e9da47efcc1bcd23
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon May 23 15:13:22 2016 +0200

correct a reference in doc and rebuild

commit d7ab5283afe58bacb2e8739d72ede4e17f4c8081
Author: Mladen Banovic <mladenbanovic2705@…>
Date: Fri May 20 16:42:13 2016 +0200

Update section 7 of adolc-manual related to the Traceless forward differentiation.

commit bedb8e36f959c5272e4610fe504acc83208e5e9d
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue May 17 16:09:36 2016 +0200

macro name correction

commit 92ff596a0331776901df7f172ca347572e3daafd
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue May 17 15:56:17 2016 +0200

Add a warning about using static build of ADOL-C

static build of ADOL-C does not call constructors
for internal global objects, thereby causing
segmentation faults.

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

Location:
trunk/ADOL-C/src
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/ADOL-C/src/Makefile.in

    r640 r708  
    365365STRIP = @STRIP@
    366366UINT_TYPE = @UINT_TYPE@
     367USE_BOOST_POOL = @USE_BOOST_POOL@
    367368VERSION = @VERSION@
    368369_lib = @_lib@
  • trunk/ADOL-C/src/adouble_tl.cpp

    r630 r708  
    3939
    4040size_t refcounter::refcnt = 0;
    41 
     41#if USE_BOOST_POOL
     42boost::pool<boost::default_user_allocator_new_delete>* adouble::advalpool = new
     43boost::pool<boost::default_user_allocator_new_delete>(adouble::numDir * sizeof(double));
     44#endif
    4245
    4346/*******************  i/o operations  ***************************************/
  • trunk/ADOL-C/src/advector.cpp

    r676 r708  
    464464        put_op(subscript);
    465465        ADOLC_PUT_LOCINT(index.loc());
    466         ADOLC_PUT_LOCINT(locat);
    467466        ADOLC_PUT_VAL(n);
    468467        ADOLC_PUT_LOCINT(data[0].loc());
     468        ADOLC_PUT_LOCINT(locat);
    469469
    470470        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    489489        put_op(subscript_ref);
    490490        ADOLC_PUT_LOCINT(index.loc());
    491         ADOLC_PUT_LOCINT(locat);
    492491        ADOLC_PUT_VAL(n);
    493492        ADOLC_PUT_LOCINT(data[0].loc());
     493        ADOLC_PUT_LOCINT(locat);
    494494
    495495        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    527527  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    528528      put_op(vec_copy);
    529       ADOLC_PUT_LOCINT(dest[0].loc());
    530529      ADOLC_PUT_LOCINT(src[0].loc());
    531530      ADOLC_PUT_LOCINT(n);
     531      ADOLC_PUT_LOCINT(dest[0].loc());
    532532      for (locint i=0; i<n; i++) {
    533533          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    548548  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    549549      put_op(vec_dot);
    550       ADOLC_PUT_LOCINT(res);
    551550      ADOLC_PUT_LOCINT(x[0].loc());
    552551      ADOLC_PUT_LOCINT(y[0].loc());
    553552      ADOLC_PUT_LOCINT(n);
     553      ADOLC_PUT_LOCINT(res);
    554554      ADOLC_CURRENT_TAPE_INFOS.num_eq_prod += 2*n;
    555555      ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    572572  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    573573      put_op(vec_axpy);
    574       ADOLC_PUT_LOCINT(res[0].loc());
    575574      ADOLC_PUT_LOCINT(a_loc);
    576575      ADOLC_PUT_LOCINT(x[0].loc());
    577576      ADOLC_PUT_LOCINT(y[0].loc());
    578577      ADOLC_PUT_LOCINT(n);
     578      ADOLC_PUT_LOCINT(res[0].loc());
    579579      ADOLC_CURRENT_TAPE_INFOS.num_eq_prod += 2*n -1;
    580580      for (locint i=0; i<n; i++) {
  • trunk/ADOL-C/src/drivers/Makefile.in

    r640 r708  
    252252STRIP = @STRIP@
    253253UINT_TYPE = @UINT_TYPE@
     254USE_BOOST_POOL = @USE_BOOST_POOL@
    254255VERSION = @VERSION@
    255256_lib = @_lib@
  • trunk/ADOL-C/src/fo_rev.c

    r676 r708  
    693693            case assign_p:            /* assign an adouble variable a    assign_d */
    694694                /* double value. (=) */
     695                res   = get_locint_r();
    695696                arg   = get_locint_r();
    696                 res   = get_locint_r();
    697697#if !defined(_NTIGHT_)
    698698                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    795795            case eq_plus_p:            /* Add a floating point to an    eq_plus_d */
    796796                /* adouble. (+=) */
     797                res   = get_locint_r();
    797798                arg   = get_locint_r();
    798                 res   = get_locint_r();
    799799#if !defined(_NTIGHT_)
    800800                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    839839            case eq_min_p:       /* Subtract a floating point from an    eq_min_d */
    840840                /* adouble. (-=) */
     841                res   = get_locint_r();
    841842                arg   = get_locint_r();
    842                 res   = get_locint_r();
    843843#if !defined(_NTIGHT_)
    844844                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    892892            case eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
    893893                /* flaoting point. (*=) */
     894                res   = get_locint_r();
    894895                arg   = get_locint_r();
    895                 res   = get_locint_r();
    896896#if !defined(_NTIGHT_)
    897897                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    10091009            case min_a_p:                /* Subtract an adouble from a    min_d_a */
    10101010                /* (+) */
     1011                res   = get_locint_r();
    10111012                arg1  = get_locint_r();
    1012                 res   = get_locint_r();
    10131013                arg   = get_locint_r();
    10141014#if !defined(_NTIGHT_)
     
    12091209            case mult_a_p:         /* Multiply an adouble by a double    mult_a_p */
    12101210                /* (*) */
     1211                res   = get_locint_r();
    12111212                arg1  = get_locint_r();
    1212                 res   = get_locint_r();
    12131213                arg   = get_locint_r();
    12141214#if !defined(_NTIGHT_)
     
    13091309                /****************************************************************************/
    13101310            case div_p_a:             /* Division double - adouble (/)    div_p_a */
     1311                res   = get_locint_r();
    13111312                arg1  = get_locint_r();
    1312                 res   = get_locint_r();
    13131313                arg   = get_locint_r();
    13141314
     
    15781578                /*--------------------------------------------------------------------------*/
    15791579            case pow_op_p:                                                /* pow_op_p */
     1580                res   = get_locint_r();
    15801581                arg1  = get_locint_r();
    1581                 res   = get_locint_r();
    15821582                arg   = get_locint_r();
    15831583#if !defined(_NTIGHT_)
     
    21622162#endif
    21632163                    get_val_r();
     2164                    res = get_locint_r();
    21642165#if !defined(_NTIGHT_)
    21652166                    size_t idx, numval = (size_t)trunc(fabs(val));
     
    21682169#endif
    21692170                    get_locint_r();
    2170                     res = get_locint_r();
    21712171                    arg = get_locint_r();
    21722172#if !defined(_NTIGHT_)
     
    22012201#endif
    22022202                    get_val_r();
     2203                    res = get_locint_r();
    22032204#if !defined(_NTIGHT_)
    22042205                    size_t idx, numval = (size_t)trunc(fabs(val));
     
    22072208#endif
    22082209                    get_locint_r();
    2209                     res = get_locint_r();
    22102210                    arg = get_locint_r();
    22112211#if !defined(_NTIGHT_)
     
    24032403            case ref_eq_plus_p:            /* Add a floating point to an    eq_plus_d */
    24042404                /* adouble. (+=) */
     2405                arg1   = get_locint_r();
    24052406                arg    = get_locint_r();
    2406                 arg1   = get_locint_r();
    24072407#if !defined(_NTIGHT_)
    24082408                res = (size_t)trunc(fabs(TARG1));
     
    24572457            case ref_eq_min_p:       /* Subtract a floating point from an    eq_min_p */
    24582458                /* adouble. (-=) */
     2459                arg1   = get_locint_r();
    24592460                arg    = get_locint_r();
    2460                 arg1   = get_locint_r();
    24612461#if !defined(_NTIGHT_)
    24622462                res = (size_t)trunc(fabs(TARG1));
     
    25172517            case ref_eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
    25182518                /* flaoting point. (*=) */
     2519                arg1   = get_locint_r();
    25192520                arg    = get_locint_r();
    2520                 arg1   = get_locint_r();
    25212521#if !defined(_NTIGHT_)
    25222522                res = (size_t)trunc(fabs(TARG1));
     
    25662566
    25672567        case vec_copy:
     2568                res = get_locint_r();
    25682569                size = get_locint_r();
    25692570                arg = get_locint_r();
    2570                 res = get_locint_r();
    25712571                for (qq=0;qq<size;qq++) {
    25722572
     
    25932593
    25942594        case vec_dot:
     2595                res = get_locint_r();
    25952596                size = get_locint_r();
    25962597                arg2 = get_locint_r();
    25972598                arg1 = get_locint_r();
    2598                 res = get_locint_r();
    25992599                for (qq=0;qq<size;qq++) {
    26002600                    ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
     
    26202620
    26212621        case vec_axpy:
     2622                res = get_locint_r();
    26222623                size = get_locint_r();
    26232624                arg2 = get_locint_r();
    26242625                arg1 = get_locint_r();
    26252626                arg = get_locint_r();
    2626                 res = get_locint_r();
    26272627                for (qq=0;qq<size;qq++) {
    26282628                    ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
  • trunk/ADOL-C/src/ho_rev.c

    r676 r708  
    699699            case assign_p:      /* assign an adouble variable a    assign_d */
    700700                /* double value. (=) */
     701                res   = get_locint_r();
    701702                arg   = get_locint_r();
    702                 res   = get_locint_r();
    703703                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    704704
     
    783783        case eq_plus_p:            /* Add a floating point to an    eq_plus_p */
    784784            /* adouble. (+=) */
     785           res   = get_locint_r();
    785786           arg   = get_locint_r();
    786            res   = get_locint_r();
    787787                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    788788
     
    826826            case eq_min_p:       /* Subtract a floating point from an    eq_min_p */
    827827                /* adouble. (-=) */
     828                res   = get_locint_r();
    828829                arg   = get_locint_r();
    829                 res   = get_locint_r();
    830830                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    831831
     
    878878            case eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
    879879                /* flaoting point. (*=) */
     880                res   = get_locint_r();
    880881                arg   = get_locint_r();
    881                 res   = get_locint_r();
    882882                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    883883
     
    982982            case min_a_p:                /* Subtract an adouble from a    min_a_p */
    983983                /* (+) */
     984                res   = get_locint_r();
    984985                arg1  = get_locint_r();
    985                 res   = get_locint_r();
    986986                arg   = get_locint_r();
    987987                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    12721272            case mult_a_p:         /* Multiply an adouble by a double    mult_a_p */
    12731273                /* (*) */
     1274                res   = get_locint_r();
    12741275                arg1  = get_locint_r();
    1275                 res   = get_locint_r();
    12761276                arg   = get_locint_r();
    12771277                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    14111411                /****************************************************************************/
    14121412            case div_p_a:             /* Division double - adouble (/)    div_p_a */
     1413                res   = get_locint_r();
    14131414                arg1  = get_locint_r();
    1414                 res   = get_locint_r();
    14151415                arg   = get_locint_r();
    14161416                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    17961796                /*--------------------------------------------------------------------------*/
    17971797            case pow_op_p:                                                /* pow_op_p */
     1798                res   = get_locint_r();
    17981799                arg1  = get_locint_r();
    1799                 res   = get_locint_r();
    18001800                arg   = get_locint_r();
    18011801                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    24762476                    size_t idx, numval = (size_t)trunc(fabs(coval));
    24772477                    locint vectorloc;
     2478                    res = get_locint_r();
    24782479                    vectorloc = get_locint_r();
    2479                     res = get_locint_r();
    24802480                    arg = get_locint_r();
    24812481                    ASSIGN_T(Targ, rpp_T[arg])
     
    25102510                    size_t idx, numval = (size_t)trunc(fabs(coval));
    25112511                    locint vectorloc;
     2512                    res = get_locint_r();
    25122513                    vectorloc = get_locint_r();
    2513                     res = get_locint_r();
    25142514                    arg = get_locint_r();
    25152515                    ASSIGN_T(Targ, rpp_T[arg])
     
    26672667        case ref_eq_plus_p:            /* Add a floating point to an    eq_plus_d */
    26682668            /* adouble. (+=) */
     2669                arg1   = get_locint_r();
    26692670                arg    = get_locint_r();
    2670                 arg1   = get_locint_r();
    26712671                ASSIGN_T(Targ1, rpp_T[arg1])
    26722672                res = (size_t)trunc(fabs(TARG1));
     
    27112711                break;
    27122712
     2713           case ref_eq_min_p:            /* Add a floating point to an    eq_min_d */
     2714            /* adouble. (-=) */
     2715                arg1   = get_locint_r();
     2716                arg    = get_locint_r();
     2717                ASSIGN_T(Targ1, rpp_T[arg1])
     2718                res = (size_t)trunc(fabs(TARG1));
     2719                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     2720
     2721                GET_TAYL(res,k,p)
     2722                break;
     2723
    27132724            case ref_eq_min_a:        /* Subtract an adouble from another    eq_min_a */
    27142725                /* adouble. (-=) */
     
    27422753                res = (size_t)trunc(fabs(TARG1));
    27432754                coval = get_val_r();
     2755
     2756                ASSIGN_A(Ares, rpp_A[res])
     2757
     2758                FOR_0_LE_l_LT_p
     2759                if ( 0 == ARES_INC )
     2760                    HOV_INC(Ares, k)
     2761                    else
     2762                        FOR_0_LE_i_LT_k
     2763                        ARES_INC *= coval;
     2764
     2765                GET_TAYL(res,k,p)
     2766                break;
     2767
     2768            case ref_eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
     2769                /* flaoting point. (*=) */
     2770                arg1   = get_locint_r();
     2771                arg    = get_locint_r();
     2772                ASSIGN_T(Targ1, rpp_T[arg1])
     2773                res = (size_t)trunc(fabs(TARG1));
     2774                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    27442775
    27452776                ASSIGN_A(Ares, rpp_A[res])
     
    27972828            case vec_copy:
    27982829
     2830                res = get_locint_r();
    27992831                size = get_locint_r();
    28002832                arg = get_locint_r();
    2801                 res = get_locint_r();
    28022833
    28032834                for(qq=0;qq<size;qq++) {
     
    28282859
    28292860        case vec_dot:
     2861                res = get_locint_r();
    28302862                size = get_locint_r();
    28312863                arg2 = get_locint_r();
    28322864                arg1 = get_locint_r();
    2833                 res = get_locint_r();
    28342865                for (qq=0;qq<size;qq++) {
    28352866                ASSIGN_A(Ares,  rpp_A[res])
     
    28672898
    28682899        case vec_axpy:
     2900                res = get_locint_r();
    28692901                size = get_locint_r();
    28702902                arg2 = get_locint_r();
    28712903                arg1 = get_locint_r();
    28722904                arg = get_locint_r();
    2873                 res = get_locint_r();
    28742905                for (qq=0;qq<size;qq++) {
    28752906                ASSIGN_A(Ares,  rpp_A[res+qq])
  • trunk/ADOL-C/src/lie/Makefile.in

    r611 r708  
    269269STRIP = @STRIP@
    270270UINT_TYPE = @UINT_TYPE@
     271USE_BOOST_POOL = @USE_BOOST_POOL@
    271272VERSION = @VERSION@
    272273_lib = @_lib@
  • trunk/ADOL-C/src/lie/adolc_lie.cpp

    r609 r708  
    66 
    77
    8  Copyright (c) Siquian Wang, Klaus Röbenack, Jan Winkler, Mirko Franke
     8 Copyright (c) Siquian Wang, Klaus Röbenack, Jan Winkler, Mirko Franke
    99
    1010 This file is part of ADOL-C. This software is provided as open source.
  • trunk/ADOL-C/src/lie/adolc_lie_c.c

    r643 r708  
    66 
    77
    8  Copyright (c) Siquian Wang, Klaus Röbenack, Jan Winkler, Mirko Franke
     8 Copyright (c) Siquian Wang, Klaus Röbenack, Jan Winkler, Mirko Franke
    99
    1010 This file is part of ADOL-C. This software is provided as open source.
  • trunk/ADOL-C/src/param.cpp

    r605 r708  
    9090    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    9191        put_op(assign_p);
    92         ADOLC_PUT_LOCINT(location);
    9392        ADOLC_PUT_LOCINT(_idx);
     93        ADOLC_PUT_LOCINT(location);
    9494
    9595        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    150150    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    151151        put_op(eq_plus_p);
     152        ADOLC_PUT_LOCINT(p._idx);
    152153        ADOLC_PUT_LOCINT(loc);
    153         ADOLC_PUT_LOCINT(p._idx);
    154154       
    155155        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    168168    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    169169        put_op(ref_eq_plus_p);
    170         ADOLC_PUT_LOCINT(location);
    171         ADOLC_PUT_LOCINT(p._idx);
     170        ADOLC_PUT_LOCINT(p._idx);
     171        ADOLC_PUT_LOCINT(location);
    172172
    173173        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    185185    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_min_d,loc(),coval);
    186186        put_op(eq_min_p);
     187        ADOLC_PUT_LOCINT(p._idx);
    187188        ADOLC_PUT_LOCINT(loc());
    188         ADOLC_PUT_LOCINT(p._idx);
    189189
    190190        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    202202    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_min_d,location,coval);
    203203        put_op(ref_eq_min_p);
    204         ADOLC_PUT_LOCINT(location);
    205         ADOLC_PUT_LOCINT(p._idx);
     204        ADOLC_PUT_LOCINT(p._idx);
     205        ADOLC_PUT_LOCINT(location);
    206206
    207207        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    219219    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_mult_d,loc(),coval);
    220220        put_op(eq_mult_p);
     221        ADOLC_PUT_LOCINT(p._idx);       // = coval
    221222        ADOLC_PUT_LOCINT(loc()); // = res
    222         ADOLC_PUT_LOCINT(p._idx);       // = coval
    223223
    224224        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    236236    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_mult_d,location,coval);
    237237        put_op(ref_eq_mult_p);
    238         ADOLC_PUT_LOCINT(location);
    239         ADOLC_PUT_LOCINT(p._idx);
     238        ADOLC_PUT_LOCINT(p._idx);
     239        ADOLC_PUT_LOCINT(location);
    240240
    241241        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    278278        put_op(min_a_p);
    279279        ADOLC_PUT_LOCINT(a.loc());
     280        ADOLC_PUT_LOCINT(p._idx);
    280281        ADOLC_PUT_LOCINT(locat);
    281         ADOLC_PUT_LOCINT(p._idx);
    282282
    283283        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    299299        put_op(mult_a_p);
    300300        ADOLC_PUT_LOCINT(a.loc());
     301        ADOLC_PUT_LOCINT(p._idx);
    301302        ADOLC_PUT_LOCINT(locat);
    302         ADOLC_PUT_LOCINT(p._idx);
    303303
    304304        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    320320        put_op(div_p_a);
    321321        ADOLC_PUT_LOCINT(a.loc());
     322        ADOLC_PUT_LOCINT(p._idx);
    322323        ADOLC_PUT_LOCINT(locat);
    323         ADOLC_PUT_LOCINT(p._idx);
    324324
    325325        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    340340        put_op(pow_op_p);
    341341        ADOLC_PUT_LOCINT(x.loc()); // = arg
     342        ADOLC_PUT_LOCINT(p._idx);         // = coval
    342343        ADOLC_PUT_LOCINT(locat);      // = res
    343         ADOLC_PUT_LOCINT(p._idx);         // = coval
    344344
    345345        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
  • trunk/ADOL-C/src/sparse/Makefile.in

    r678 r708  
    251251STRIP = @STRIP@
    252252UINT_TYPE = @UINT_TYPE@
     253USE_BOOST_POOL = @USE_BOOST_POOL@
    253254VERSION = @VERSION@
    254255_lib = @_lib@
  • trunk/ADOL-C/src/storemanager.h

    r671 r708  
    7070#    endif
    7171#endif
     72#include <adolc/internal/adolc_settings.h>
    7273#include <forward_list>
    73 #if defined(HAVE_BOOST_POOL_POOL_ALLOC_HPP) && defined(HAVE_BOOST_SYSTEM)
     74
     75#if USE_BOOST_POOL
    7476#include <boost/pool/pool_alloc.hpp>
    75 #define USE_BOOST_POOL 1
    76 #else
    77 #define USE_BOOST_POOL 0
    7877#endif
     78
    7979#include <adolc/internal/common.h>
    8080
  • trunk/ADOL-C/src/tapedoc/Makefile.in

    r611 r708  
    251251STRIP = @STRIP@
    252252UINT_TYPE = @UINT_TYPE@
     253USE_BOOST_POOL = @USE_BOOST_POOL@
    253254VERSION = @VERSION@
    254255_lib = @_lib@
  • trunk/ADOL-C/src/uni5_for.c

    r707 r708  
    15781578            case assign_p:            /* assign an adouble variable a    assign_d */
    15791579                /* double value. (=) */
     1580                arg   = get_locint_f();
    15801581                res   = get_locint_f();
    1581                 arg   = get_locint_f();
    15821582#if !defined(_NTIGHT_)
    15831583                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    17841784            case eq_plus_p:            /* Add a floating point to an    eq_plus_p */
    17851785                /* adouble. (+=) */
     1786                arg   = get_locint_f();
    17861787                res   = get_locint_f();
    1787                 arg   = get_locint_f();
    17881788#if !defined(_NTIGHT_)
    17891789                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    18531853            case eq_min_p:       /* Subtract a floating point from an    eq_min_p */
    18541854                /* adouble. (-=) */
     1855                arg = get_locint_f();
    18551856                res = get_locint_f();
    1856                 arg = get_locint_f();
    18571857#if !defined(_NTIGHT_)
    18581858                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    19361936            case eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
    19371937                /* flaoting point. (*=) */
     1938                arg   = get_locint_f();
    19381939                res   = get_locint_f();
    1939                 arg   = get_locint_f();
    19401940#if !defined(_NTIGHT_)
    19411941                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    21242124                /* (+) */
    21252125                arg   = get_locint_f();
     2126                arg1  = get_locint_f();
    21262127                res   = get_locint_f();
    2127                 arg1  = get_locint_f();
    21282128#if !defined(_NTIGHT_)
    21292129                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    24842484                /* (*) */
    24852485                arg   = get_locint_f();
     2486                arg1  = get_locint_f();
    24862487                res   = get_locint_f();
    2487                 arg1  = get_locint_f();
    24882488#if !defined(_NTIGHT_)
    24892489                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    26632663        case div_p_a:             /* Division double - adouble (/)    div_p_a */
    26642664                arg   = get_locint_f();
     2665                arg1  = get_locint_f();
    26652666                res   = get_locint_f();
    2666                 arg1  = get_locint_f();
    26672667#if !defined(_NTIGHT_)
    26682668                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    38353835            case pow_op_p:                                                /* pow_op_p */
    38363836                arg   = get_locint_f();
     3837                arg1  = get_locint_f();
    38373838                res   = get_locint_f();
    3838                 arg1  = get_locint_f();
    38393839#if !defined(_NTIGHT_)
    38403840                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    49964996                get_val_f();
    49974997                arg = get_locint_f();
    4998                 res = get_locint_f();
    49994998                {
    50004999#if !defined(_NTIGHT_)
     
    50045003#endif
    50055004                    get_locint_f();
     5005                    res = get_locint_f();
    50065006#if !defined(_NTIGHT_)
    50075007                    idx = (size_t)trunc(fabs(dp_T0[arg]));
     
    50405040                get_val_f();
    50415041                arg = get_locint_f();
    5042                 res = get_locint_f();
    50435042                {
    50445043#if !defined(_NTIGHT_)
     
    50485047#endif
    50495048                    get_locint_f();
     5049                    res = get_locint_f();
    50505050#if !defined(_NTIGHT_)
    50515051                    idx = (size_t)trunc(fabs(dp_T0[arg]));
     
    53415341            case ref_eq_plus_p:            /* Add a floating point to an    eq_plus_p */
    53425342                /* adouble. (+=) */
     5343                arg1  = get_locint_f();
    53435344                arg  = get_locint_f();
    5344                 arg1  = get_locint_f();
    53455345#if !defined(_NTIGHT_)
    53465346                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    54175417            case ref_eq_min_p:       /* Subtract a floating point from an    eq_min_p */
    54185418                /* adouble. (-=) */
     5419                arg1 = get_locint_f();
    54195420                arg = get_locint_f();
    5420                 arg1 = get_locint_f();
    54215421#if !defined(_NTIGHT_)
    54225422                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    55055505            case ref_eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
    55065506                /* flaoting point. (*=) */
     5507                arg1 = get_locint_f();
    55075508                arg = get_locint_f();
    5508                 arg1 = get_locint_f();
    55095509#if !defined(_NTIGHT_)
    55105510                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    55935593
    55945594            case vec_copy:
    5595                 res = get_locint_f();
    55965595                arg = get_locint_f();
    55975596                size = get_locint_f();
     5597                res = get_locint_f();
    55985598
    55995599                for(qq=0;qq<size;qq++) {
     
    56245624
    56255625            case vec_dot:
    5626                 res = get_locint_f();
    56275626                arg1 = get_locint_f();
    56285627                arg2 = get_locint_f();
    56295628                size = get_locint_f();
     5629                res = get_locint_f();
    56305630                IF_KEEP_WRITE_TAYLOR(res,keep,k,p);
    56315631#if !defined(_NTIGHT_)
     
    57145714
    57155715            case vec_axpy:
    5716                 res = get_locint_f();
    57175716                arg = get_locint_f();
    57185717                arg1 = get_locint_f();
    57195718                arg2 = get_locint_f();
    57205719                size = get_locint_f();
     5720                res = get_locint_f();
    57215721               
    57225722                for(qq=0;qq<size;qq++) {
Note: See TracChangeset for help on using the changeset viewer.