Changeset 2794


Ignore:
Timestamp:
May 2, 2013 4:20:30 AM (7 years ago)
Author:
bradbell
Message:
  1. Use CPPAD_NULL, intead of 0, for null pointer.

check_if_0.sh: Ignore subdirectories of new directories.
jenkins.sh: output logs when an error occurs.
acos_op.hpp: avoid use of q (will use it for an order index).
asin_op.hpp: avoid use of q (will use it for an order index).
forward_sweep.hpp: chnage d to p, use const in prototype.
div_op.hpp: minor edit of white space.
atom_usead_2.cpp: use ADFUN to compute variable/parameter information.

Location:
trunk
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • trunk/bin/check_if_0.sh

    r2778 r2794  
    2424for ext in .cpp .hpp
    2525do
    26         dir_list=`find . -name "*$ext" | sed -e '/junk\.[^.]*$/d' \
    27                 -e 's|^\./||' -e '/^build/d' -e 's|/[^/]*$||' | sort -u` 
     26        dir_list=`find . -name "*$ext" | sed \
     27                -e '/junk\.[^.]*$/d' \
     28                -e '/\/build\//d' \
     29                -e '/\/new\//d' \
     30                -e 's|^\./||' \
     31                -e 's|/[^/]*$||' | sort -u` 
    2832        for dir in $dir_list
    2933        do
  • trunk/bin/jenkins.sh

    r2793 r2794  
    2626        echo $*  >> ../jenkins.err
    2727        echo $* "1>> ../jenkins.log 2>> ../jenkins.err"
    28         eval $*  1>> ../jenkins.log 2>> ../jenkins.err
     28        if ! eval $*  1>> ../jenkins.log 2>> ../jenkins.err
     29        then
     30                echo_eval cat jenkins.log
     31                echo_eval cat jenkins.err
     32                exit 1
     33        fi
    2934}
    3035for ext in log err
  • trunk/cppad/local/acos_op.hpp

    r2625 r2794  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    6060
    6161        size_t k;
    62         Base qj;
     62        Base uj;
    6363        if( j == 0 )
    64         {       z[j] = acos( x[0] );
    65                 qj   = Base(1) - x[0] * x[0];
    66                 b[j] = sqrt( qj );
     64        {       z[0] = acos( x[0] );
     65                uj   = Base(1) - x[0] * x[0];
     66                b[0] = sqrt( uj );
    6767        }
    6868        else
    69         {       qj = 0.;
     69        {       uj = 0.;
    7070                for(k = 0; k <= j; k++)
    71                         qj -= x[k] * x[j-k];
     71                        uj -= x[k] * x[j-k];
    7272                b[j] = Base(0);
    7373                z[j] = Base(0);
     
    7979                z[j] /= Base(j);
    8080                //
    81                 b[j] += qj / Base(2);
     81                b[j] += uj / Base(2);
    8282                z[j] -= x[j];
    8383                //
  • trunk/cppad/local/asin_op.hpp

    r2625 r2794  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    6060
    6161        size_t k;
    62         Base qj;
     62        Base uj;
    6363        if( j == 0 )
    64         {       z[j] = asin( x[0] );
    65                 qj   = Base(1) - x[0] * x[0];
    66                 b[j] = sqrt( qj );
     64        {       z[0] = asin( x[0] );
     65                uj   = Base(1) - x[0] * x[0];
     66                b[0] = sqrt( uj );
    6767        }
    6868        else
    69         {       qj = 0.;
     69        {       uj = 0.;
    7070                for(k = 0; k <= j; k++)
    71                         qj -= x[k] * x[j-k];
     71                        uj -= x[k] * x[j-k];
    7272                b[j] = Base(0);
    7373                z[j] = Base(0);
     
    7979                z[j] /= Base(j);
    8080                //
    81                 b[j] += qj / Base(2);
     81                b[j] += uj / Base(2);
    8282                z[j] += x[j];
    8383                //
  • trunk/cppad/local/div_op.hpp

    r2625 r2794  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    5959
    6060
    61         // Using CondExp, it can make sense to divide by zero,
    62         // so do not make it an error.
     61        // Using CondExp, it can make sense to divide by zero,
     62        // so do not make it an error.
    6363        size_t k;
    6464        z[d] = x[d];
     
    203203        Base x = parameter[ arg[0] ];
    204204
    205         // Using CondExp, it can make sense to divide by zero,
    206         // so do not make it an error.
    207         size_t k;
     205        // Using CondExp, it can make sense to divide by zero,
     206        // so do not make it an error.
     207        size_t k;
    208208# if USE_CPPAD_FORWARD0SWEEP
    209209        z[d] = Base(0);
  • trunk/cppad/local/for_jac_sweep.hpp

    r2625 r2794  
    33# define CPPAD_FOR_JAC_SWEEP_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    9090        size_t        i_var;
    9191
    92         const addr_t*   arg = 0;
     92        const addr_t*   arg = CPPAD_NULL;
    9393
    9494        size_t            i, j, k;
  • trunk/cppad/local/forward0sweep.hpp

    r2625 r2794  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    122122        // constant and non-constant version of the operation argument indices
    123123        addr_t*         non_const_arg;
    124         const addr_t*   arg = 0;
     124        const addr_t*   arg = CPPAD_NULL;
    125125
    126126        // initialize the comparision operator (ComOp) counter
  • trunk/cppad/local/forward_sweep.hpp

    r2625 r2794  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    4747(must be false when \c d is nonzero).
    4848
    49 \param d
     49\param p
    5050is the order of the Taylor coefficients that are computed during this call.
    5151
     
    7474with in the tape and this changes during palyback.
    7575The second exception is the fact that the
    76 zero order ( \a d = 0 ) versions of the VecAD operators LdpOp and LdvOp
     76zero order ( \a p = 0 ) versions of the VecAD operators LdpOp and LdvOp
    7777modify the corresponding \a op_arg values returned by
    7878\ref player::next_forward and \ref player::next_reverse; see the
     
    8181\param J
    8282Is the number of columns in the coefficient matrix \a Taylor.
    83 This must be greater than or equal \a d + 1.
     83This must be greater than or equal \a p + 1.
    8484
    8585\param Taylor
    86 \b Input: For j = 1 , ... , \a n, and for k = 0 , ... , \a d,
     86\b Input: For j = 1 , ... , \a n, and for k = 0 , ... , \a p,
    8787\a Taylor [ j * J + k ]
    8888is the k-th order Taylor coefficient corresponding to
     
    9191\n
    9292\n
    93 \b Output: For i = \a n + 1, ... , \a numvar - 1, and for k = 0 , ... , \a d,
     93\b Output: For i = \a n + 1, ... , \a numvar - 1, and for k = 0 , ... , \a p,
    9494\a Taylor [ i * J + k ]
    9595is the k-th order Taylor coefficient for the variable with
     
    9797
    9898\a return
    99 If \a d is not zero, the return value is zero.
    100 If \a d is zero,
     99If \a p is not zero, the return value is zero.
     100If \a p is zero,
    101101the return value is equal to the number of ComOp operations
    102102that have a different result from when the information in
     
    109109size_t forward_sweep(
    110110        std::ostream&         s_out,
    111         bool                  print,
    112         size_t                d,
    113         size_t                n,
    114         size_t                numvar,
     111        const bool            print,
     112        const size_t          p,
     113        const size_t          n,
     114        const size_t          numvar,
    115115        player<Base>         *Rec,
    116         size_t                J,
     116        const size_t          J,
    117117        Base                 *Taylor
    118118)
    119 {       CPPAD_ASSERT_UNKNOWN( J >= d + 1 );
     119{       CPPAD_ASSERT_UNKNOWN( J >= p + 1 );
    120120
    121121        // op code for current instruction
     
    128128        size_t        i_var;
    129129
    130         CPPAD_ASSERT_UNKNOWN( d == 0 || ! print );
     130        CPPAD_ASSERT_UNKNOWN( p == 0 || ! print );
    131131# if CPPAD_USE_FORWARD0SWEEP
    132         CPPAD_ASSERT_UNKNOWN( d > 0 );
     132        CPPAD_ASSERT_UNKNOWN( p > 0 );
    133133# else
    134134        addr_t*         non_const_arg;
    135135# endif
    136         const addr_t*   arg = 0;
     136        const addr_t*   arg = CPPAD_NULL;
    137137
    138138        // temporary indices
     
    156156
    157157        // work space used by UserOp.
    158         const size_t user_k  = d;    // order of this forward mode calculation
    159         const size_t user_k1 = d+1;  // number of orders for this calculation
     158        const size_t user_k  = p;    // order of this forward mode calculation
     159        const size_t user_k1 = p+1;  // number of orders for this calculation
    160160        vector<Base> user_tx;        // argument vector Taylor coefficients
    161161        vector<Base> user_ty;        // result vector Taylor coefficients
     
    177177
    178178        // pointer to the beginning of the parameter vector
    179         const Base* parameter = 0;
     179        const Base* parameter = CPPAD_NULL;
    180180        if( num_par > 0 )
    181181                parameter = Rec->GetPar();
     
    186186
    187187        // pointer to the beginning of the text vector
    188         const char* text = 0;
     188        const char* text = CPPAD_NULL;
    189189        if( num_text > 0 )
    190190                text = Rec->GetTxt(0);
     
    208208                {
    209209                        case AbsOp:
    210                         forward_abs_op(d, i_var, arg[0], J, Taylor);
     210                        forward_abs_op(p, i_var, arg[0], J, Taylor);
    211211                        break;
    212212                        // -------------------------------------------------
    213213
    214214                        case AddvvOp:
    215                         forward_addvv_op(d, i_var, arg, parameter, J, Taylor);
     215                        forward_addvv_op(p, i_var, arg, parameter, J, Taylor);
    216216                        break;
    217217                        // -------------------------------------------------
     
    219219                        case AddpvOp:
    220220                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    221                         forward_addpv_op(d, i_var, arg, parameter, J, Taylor);
     221                        forward_addpv_op(p, i_var, arg, parameter, J, Taylor);
    222222                        break;
    223223                        // -------------------------------------------------
     
    226226                        // sqrt(1 - x * x), acos(x)
    227227                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    228                         forward_acos_op(d, i_var, arg[0], J, Taylor);
     228                        forward_acos_op(p, i_var, arg[0], J, Taylor);
    229229                        break;
    230230                        // -------------------------------------------------
     
    233233                        // sqrt(1 - x * x), asin(x)
    234234                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    235                         forward_asin_op(d, i_var, arg[0], J, Taylor);
     235                        forward_asin_op(p, i_var, arg[0], J, Taylor);
    236236                        break;
    237237                        // -------------------------------------------------
     
    240240                        // 1 + x * x, atan(x)
    241241                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    242                         forward_atan_op(d, i_var, arg[0], J, Taylor);
     242                        forward_atan_op(p, i_var, arg[0], J, Taylor);
    243243                        break;
    244244                        // -------------------------------------------------
     
    250250                        Rec->forward_csum(op, arg, i_op, i_var);
    251251                        forward_csum_op(
    252                                 d, i_var, arg, num_par, parameter, J, Taylor
     252                                p, i_var, arg, num_par, parameter, J, Taylor
    253253                        );
    254254                        break;
     
    257257                        case CExpOp:
    258258                        forward_cond_op(
    259                                 d, i_var, arg, num_par, parameter, J, Taylor
     259                                p, i_var, arg, num_par, parameter, J, Taylor
    260260                        );
    261261                        break;
     
    264264                        case ComOp:
    265265# if ! USE_FORWARD0SWEEP
    266                         if( d == 0 ) forward_comp_op_0(
     266                        if( p == 0 ) forward_comp_op_0(
    267267                        compareCount, arg, num_par, parameter, J, Taylor
    268268                        );
     
    274274                        // sin(x), cos(x)
    275275                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    276                         forward_cos_op(d, i_var, arg[0], J, Taylor);
     276                        forward_cos_op(p, i_var, arg[0], J, Taylor);
    277277                        break;
    278278                        // ---------------------------------------------------
     
    281281                        // sinh(x), cosh(x)
    282282                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    283                         forward_cosh_op(d, i_var, arg[0], J, Taylor);
     283                        forward_cosh_op(p, i_var, arg[0], J, Taylor);
    284284                        break;
    285285                        // -------------------------------------------------
     
    287287                        case DisOp:
    288288# if ! CPPAD_USE_FORWARD0SWEEP
    289                         if( d == 0 )
     289                        if( p == 0 )
    290290                                forward_dis_op_0(i_var, arg, J, Taylor);
    291291                        else
    292292# endif
    293                         {       Taylor[ i_var * J + d] = Base(0);
     293                        {       Taylor[ i_var * J + p] = Base(0);
    294294                        }
    295295                        break;
     
    297297
    298298                        case DivvvOp:
    299                         forward_divvv_op(d, i_var, arg, parameter, J, Taylor);
     299                        forward_divvv_op(p, i_var, arg, parameter, J, Taylor);
    300300                        break;
    301301                        // -------------------------------------------------
     
    303303                        case DivpvOp:
    304304                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    305                         forward_divpv_op(d, i_var, arg, parameter, J, Taylor);
     305                        forward_divpv_op(p, i_var, arg, parameter, J, Taylor);
    306306                        break;
    307307                        // -------------------------------------------------
     
    309309                        case DivvpOp:
    310310                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
    311                         forward_divvp_op(d, i_var, arg, parameter, J, Taylor);
     311                        forward_divvp_op(p, i_var, arg, parameter, J, Taylor);
    312312                        break;
    313313                        // -------------------------------------------------
     
    319319
    320320                        case ExpOp:
    321                         forward_exp_op(d, i_var, arg[0], J, Taylor);
     321                        forward_exp_op(p, i_var, arg[0], J, Taylor);
    322322                        break;
    323323                        // -------------------------------------------------
     
    330330                        case LdpOp:
    331331# if ! CPPAD_USE_FORWARD0SWEEP
    332                         if( d == 0 )
     332                        if( p == 0 )
    333333                        {       non_const_arg = Rec->forward_non_const_arg();
    334334                                forward_load_p_op_0(
     
    346346                        else
    347347# endif
    348                         {       forward_load_op( op, d, i_var, arg, J, Taylor);
     348                        {       forward_load_op( op, p, i_var, arg, J, Taylor);
    349349                        }
    350350                        break;
     
    353353                        case LdvOp:
    354354# if ! CPPAD_USE_FORWARD0SWEEP
    355                         if( d == 0 )
     355                        if( p == 0 )
    356356                        {       non_const_arg = Rec->forward_non_const_arg();
    357357                                forward_load_v_op_0(
     
    369369                        else
    370370# endif
    371                         {       forward_load_op( op, d, i_var, arg, J, Taylor);
     371                        {       forward_load_op( op, p, i_var, arg, J, Taylor);
    372372                        }
    373373                        break;
     
    375375
    376376                        case LogOp:
    377                         forward_log_op(d, i_var, arg[0], J, Taylor);
     377                        forward_log_op(p, i_var, arg[0], J, Taylor);
    378378                        break;
    379379                        // -------------------------------------------------
    380380
    381381                        case MulvvOp:
    382                         forward_mulvv_op(d, i_var, arg, parameter, J, Taylor);
     382                        forward_mulvv_op(p, i_var, arg, parameter, J, Taylor);
    383383                        break;
    384384                        // -------------------------------------------------
     
    386386                        case MulpvOp:
    387387                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    388                         forward_mulpv_op(d, i_var, arg, parameter, J, Taylor);
     388                        forward_mulpv_op(p, i_var, arg, parameter, J, Taylor);
    389389                        break;
    390390                        // -------------------------------------------------
     
    392392                        case ParOp:
    393393# if ! CPPAD_USE_FORWARD0SWEEP
    394                         if( d == 0 ) forward_par_op_0(
     394                        if( p == 0 ) forward_par_op_0(
    395395                                i_var, arg, num_par, parameter, J, Taylor
    396396                        );
    397397                        else
    398398# endif
    399                         {       Taylor[ i_var * J + d] = Base(0);
     399                        {       Taylor[ i_var * J + p] = Base(0);
    400400                        }
    401401                        break;
     
    404404                        case PowvpOp:
    405405                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
    406                         forward_powvp_op(d, i_var, arg, parameter, J, Taylor);
     406                        forward_powvp_op(p, i_var, arg, parameter, J, Taylor);
    407407                        break;
    408408                        // -------------------------------------------------
     
    410410                        case PowpvOp:
    411411                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    412                         forward_powpv_op(d, i_var, arg, parameter, J, Taylor);
     412                        forward_powpv_op(p, i_var, arg, parameter, J, Taylor);
    413413                        break;
    414414                        // -------------------------------------------------
    415415
    416416                        case PowvvOp:
    417                         forward_powvv_op(d, i_var, arg, parameter, J, Taylor);
     417                        forward_powvv_op(p, i_var, arg, parameter, J, Taylor);
    418418                        break;
    419419                        // -------------------------------------------------
     
    431431                        // cos(x), sin(x)
    432432                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    433                         forward_sign_op(d, i_var, arg[0], J, Taylor);
     433                        forward_sign_op(p, i_var, arg[0], J, Taylor);
    434434                        break;
    435435
     
    437437                        // cos(x), sin(x)
    438438                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    439                         forward_sin_op(d, i_var, arg[0], J, Taylor);
     439                        forward_sin_op(p, i_var, arg[0], J, Taylor);
    440440                        break;
    441441                        // -------------------------------------------------
     
    444444                        // cosh(x), sinh(x)
    445445                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    446                         forward_sinh_op(d, i_var, arg[0], J, Taylor);
     446                        forward_sinh_op(p, i_var, arg[0], J, Taylor);
    447447                        break;
    448448                        // -------------------------------------------------
    449449
    450450                        case SqrtOp:
    451                         forward_sqrt_op(d, i_var, arg[0], J, Taylor);
     451                        forward_sqrt_op(p, i_var, arg[0], J, Taylor);
    452452                        break;
    453453                        // -------------------------------------------------
     
    455455                        case StppOp:
    456456# if ! CPPAD_USE_FORWARD0SWEEP
    457                         if( d == 0 )
     457                        if( p == 0 )
    458458                        {       forward_store_pp_op_0(
    459459                                        i_var,
     
    473473                        case StpvOp:
    474474# if ! CPPAD_USE_FORWARD0SWEEP
    475                         if( d == 0 )
     475                        if( p == 0 )
    476476                        {       forward_store_pv_op_0(
    477477                                        i_var,
     
    491491                        case StvpOp:
    492492# if ! CPPAD_USE_FORWARD0SWEEP
    493                         if( d == 0 )
     493                        if( p == 0 )
    494494                        {       forward_store_vp_op_0(
    495495                                        i_var,
     
    509509                        case StvvOp:
    510510# if ! CPPAD_USE_FORWARD0SWEEP
    511                         if( d == 0 )
     511                        if( p == 0 )
    512512                        {       forward_store_vv_op_0(
    513513                                        i_var,
     
    526526
    527527                        case SubvvOp:
    528                         forward_subvv_op(d, i_var, arg, parameter, J, Taylor);
     528                        forward_subvv_op(p, i_var, arg, parameter, J, Taylor);
    529529                        break;
    530530                        // -------------------------------------------------
     
    532532                        case SubpvOp:
    533533                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    534                         forward_subpv_op(d, i_var, arg, parameter, J, Taylor);
     534                        forward_subpv_op(p, i_var, arg, parameter, J, Taylor);
    535535                        break;
    536536                        // -------------------------------------------------
     
    538538                        case SubvpOp:
    539539                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
    540                         forward_subvp_op(d, i_var, arg, parameter, J, Taylor);
     540                        forward_subvp_op(p, i_var, arg, parameter, J, Taylor);
    541541                        break;
    542542                        // -------------------------------------------------
     
    545545                        // tan(x)^2, tan(x)
    546546                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    547                         forward_tan_op(d, i_var, arg[0], J, Taylor);
     547                        forward_tan_op(p, i_var, arg[0], J, Taylor);
    548548                        break;
    549549                        // -------------------------------------------------
     
    552552                        // tanh(x)^2, tanh(x)
    553553                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    554                         forward_tanh_op(d, i_var, arg[0], J, Taylor);
     554                        forward_tanh_op(p, i_var, arg[0], J, Taylor);
    555555                        break;
    556556                        // -------------------------------------------------
     
    656656                        op,
    657657                        arg,
    658                         d + 1,
     658                        p + 1,
    659659                        Z_tmp,
    660660                        0,
  • trunk/cppad/local/rev_hes_sweep.hpp

    r2625 r2794  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    115115        size_t        i_var;
    116116
    117         const addr_t*   arg = 0;
     117        const addr_t*   arg = CPPAD_NULL;
    118118
    119119        // length of the parameter vector (used by CppAD assert macros)
  • trunk/cppad/local/rev_jac_sweep.hpp

    r2625 r2794  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    9595        size_t        i_var;
    9696
    97         const addr_t*   arg = 0;
     97        const addr_t*   arg = CPPAD_NULL;
    9898
    9999        size_t            i, j, k;
  • trunk/cppad/local/reverse_sweep.hpp

    r2625 r2794  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    146146        size_t        i_var;
    147147
    148         const addr_t*   arg = 0;
     148        const addr_t*   arg = CPPAD_NULL;
    149149
    150150        // check numvar argument
     
    156156
    157157        // pointer to the beginning of the parameter vector
    158         const Base* parameter = 0;
     158        const Base* parameter = CPPAD_NULL;
    159159        if( num_par > 0 )
    160160                parameter = Rec->GetPar();
  • trunk/example/atom_usead_2.cpp

    r2790 r2794  
    114114                // check for special case
    115115                if( vx.size() > 0 )
    116                 {       vy[0] = vx[0] | vx[1] | vx[2];
    117                         vy[1] = vy[0];
    118                 }
    119 
     116                {       //Compute r, a Jacobian sparsity pattern.
     117                        // Use reverse mode because m < n.
     118                        vector< std::set<size_t> > s(m), r(m);
     119                        for(i = 0; i < m; i++)
     120                                s[i].insert(i);
     121                        r = r_ptr_->RevSparseJac(m, s);
     122                        std::set<size_t>::const_iterator itr;
     123                        for(i = 0; i < m; i++)
     124                        {       vy[i] = false;
     125                                for(itr = s[i].begin(); itr != s[i].end(); itr++)
     126                                {       j = *itr;
     127                                        assert( j < n );
     128                                        // y[i] depends on the value of x[j]
     129                                        vy[i] |= vx[j];
     130                                }
     131                        }
     132                }
    120133                // make sure r_ has proper lower order Taylor coefficients stored
    121134                // then compute ty[k]
  • trunk/example/mat_mul.hpp

    r2506 r2794  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    9595        size_t nc_result_ = 0;
    9696        // which components of x are variables
    97         vector<bool>* vx_ = 0;
     97        vector<bool>* vx_ = CPPAD_NULL;
    9898
    9999        // get the information corresponding to this call
  • trunk/multi_thread/pthread/a11c_pthread.cpp

    r2506 r2794  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    4141# include <cmath>
    4242# include <cassert>
     43//
     44# include <cppad/configure.hpp>
     45# if CPPAD_HAS_NULLPTR
     46# define CPPAD_NULL nullptr
     47# else
     48# define CPPAD_NULL 0
     49# endif
     50//
    4351# define NUMBER_THREADS 4
    4452
     
    6472                a1(arg->n, arg->a, arg->b);
    6573
    66                 void* no_status = 0;
     74                void* no_status = CPPAD_NULL;
    6775                pthread_exit(no_status);
    6876
     
    112120        }
    113121        for(j = 0; j < n_thread; j++)
    114         {       void* no_status = 0;
     122        {       void* no_status = CPPAD_NULL;
    115123                CHECK_ZERO( pthread_join(thread[j], &no_status) );
    116124        }
  • trunk/test_more/base_adolc.cpp

    r2506 r2794  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    6464
    6565        // arrays for Adolc zos_forward
    66         double *x = 0, *y = 0;
     66        double *x = CPPAD_NULL, *y = CPPAD_NULL;
    6767        x = CPPAD_TRACK_NEW_VEC(n, x);
    6868        y = CPPAD_TRACK_NEW_VEC(m, y);
  • trunk/test_more/mul_level.cpp

    r2506 r2794  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    201201        // compute the d/dx of f'(x) * v = f''(x) * v
    202202        size_t m      = n;                     // # dependent in f'(x)
    203         double *v = 0, *ddf_v = 0;
     203        double *v = CPPAD_NULL, *ddf_v = CPPAD_NULL;
    204204        v     = CPPAD_TRACK_NEW_VEC(m, v);     // track v = new double[m]
    205205        ddf_v = CPPAD_TRACK_NEW_VEC(n, ddf_v); // track ddf_v = new double[n]
  • trunk/test_more/track_new_del.cpp

    r2506 r2794  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    4141
    4242        // allocate an array of lenght 5
    43         double *ptr = 0;
     43        double *ptr = CPPAD_NULL;
    4444        size_t  newlen = 5;
    4545        ptr = CPPAD_TRACK_NEW_VEC(newlen, ptr);
Note: See TracChangeset for help on using the changeset viewer.