Changeset 1585


Ignore:
Timestamp:
Nov 21, 2009 5:40:08 PM (11 years ago)
Author:
bradbell
Message:

branches/multiple_result: Convert sin, cos, sinh, cosh, to use last result for primary.

Need to change forward_unary2_op i_z documentation in prototype_op when
all unary operators with two results have been converted.

Change SinOp?, CosOp?,SinhOp?, CoshOp?, so address is last result.
player.hpp, for_jac_sweep.hpp, forward0sweep.hpp, forward_sweep.hpp,
rev_jac_sweep.hpp, cos_op.hpp, cosh_op.hpp, rev_hes_sweep.hpp, rev_sweep.hpp,
sin_op.hpp, sinh_op.hpp

Location:
branches/multiple_result/cppad/local
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • branches/multiple_result/cppad/local/cos_op.hpp

    r1447 r1585  
    4949        CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
    5050        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
    51         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     51        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5252        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    5353
     
    5555        Base* x = taylor + i_x * nc_taylor;
    5656        Base* c = taylor + i_z * nc_taylor;
    57         Base* s = c      +       nc_taylor;
     57        Base* s = c      -       nc_taylor;
    5858
    5959
     
    103103        CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
    104104        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
    105         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     105        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    106106        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
    107107
     
    109109        Base* x = taylor + i_x * nc_taylor;
    110110        Base* c = taylor + i_z * nc_taylor;  // called z in documentation
    111         Base* s = c      +       nc_taylor;  // called y in documentation
     111        Base* s = c      -       nc_taylor;  // called y in documentation
    112112
    113113        c[0] = cos( x[0] );
     
    143143        CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
    144144        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
    145         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     145        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    146146        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
    147147        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    156156
    157157        // Taylor coefficients and partials corresponding to auxillary result
    158         const Base* s  = c  + nc_taylor; // called y in documentation
    159         Base* ps       = pc + nc_partial;
     158        const Base* s  = c  - nc_taylor; // called y in documentation
     159        Base* ps       = pc - nc_partial;
    160160
    161161
  • branches/multiple_result/cppad/local/cosh_op.hpp

    r1447 r1585  
    4949        CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
    5050        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
    51         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     51        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5252        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    5353
     
    5555        Base* x = taylor + i_x * nc_taylor;
    5656        Base* c = taylor + i_z * nc_taylor;
    57         Base* s = c      +       nc_taylor;
     57        Base* s = c      -       nc_taylor;
    5858
    5959        // rest of this routine is identical for the following cases:
     
    102102        CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
    103103        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
    104         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     104        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    105105        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
    106106
     
    108108        Base* x = taylor + i_x * nc_taylor;
    109109        Base* c = taylor + i_z * nc_taylor;  // called z in documentation
    110         Base* s = c      +       nc_taylor;  // called y in documentation
     110        Base* s = c      -       nc_taylor;  // called y in documentation
    111111
    112112        c[0] = cosh( x[0] );
     
    142142        CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
    143143        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
    144         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     144        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    145145        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
    146146        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    155155
    156156        // Taylor coefficients and partials corresponding to auxillary result
    157         const Base* s  = c  + nc_taylor; // called y in documentation
    158         Base* ps       = pc + nc_partial;
     157        const Base* s  = c  - nc_taylor; // called y in documentation
     158        Base* ps       = pc - nc_partial;
    159159
    160160        // rest of this routine is identical for the following cases:
  • branches/multiple_result/cppad/local/for_jac_sweep.hpp

    r1584 r1585  
    224224                        case CosOp:
    225225                        // cosine and sine must come in pairs
    226                         // but ivar + 1 should only be used here
     226                        // but ivar should only be used here
    227227                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    228228                        forward_sparse_jacobian_unary_op(
     
    234234                        case CoshOp:
    235235                        // hyperbolic cosine and sine must come in pairs
    236                         // but ivar + 1 should only be used here
     236                        // but ivar should only be used here
    237237                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    238238                        forward_sparse_jacobian_unary_op(
     
    392392                        case SinOp:
    393393                        // sine and cosine must come in pairs
    394                         // but ivar + 1 should only be used here
     394                        // but ivar should only be used here
    395395                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    396396                        forward_sparse_jacobian_unary_op(
     
    402402                        case SinhOp:
    403403                        // hyperbolic sine and cosine must come in pairs
    404                         // but ivar + 1 should only be used here
     404                        // but ivar should only be used here
    405405                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    406406                        forward_sparse_jacobian_unary_op(
     
    515515                case PowvpOp:
    516516                case PowvvOp:
     517                case CosOp:
     518                case SinOp:
     519                case CoshOp:
     520                case SinhOp:
    517521                check = i_var + 1;
    518522                break;
  • branches/multiple_result/cppad/local/forward0sweep.hpp

    r1584 r1585  
    234234
    235235                        case CosOp:
    236                         // results: cos(x), sin(x)
    237                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     236                        // results: sin(x), cos(x)
     237                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    238238                        forward_cos_op_0(i_var, arg[0], J, Taylor);
    239239                        break;
     
    241241
    242242                        case CoshOp:
    243                         // variables: cosh(x), sinh(x)
    244                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     243                        // variables: sinh(x), cosh(x)
     244                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    245245                        forward_cosh_op_0(i_var, arg[0], J, Taylor);
    246246                        break;
     
    381381
    382382                        case SinOp:
    383                         // variables: sin(x), cos(x)
    384                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     383                        // variables: cos(x), sin(x)
     384                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    385385                        forward_sin_op_0(i_var, arg[0], J, Taylor);
    386386                        break;
     
    388388
    389389                        case SinhOp:
    390                         // variables: sinh(x), cosh(x)
    391                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     390                        // variables: cosh(x), sinh(x)
     391                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    392392                        forward_sinh_op_0(i_var, arg[0], J, Taylor);
    393393                        break;
     
    505505                case PowvpOp:
    506506                case PowvvOp:
     507                case CosOp:
     508                case SinOp:
     509                case CoshOp:
     510                case SinhOp:
    507511                check = i_var + 1;
    508512                break;
  • branches/multiple_result/cppad/local/forward_sweep.hpp

    r1584 r1585  
    245245
    246246                        case CosOp:
    247                         // variables: cos(x), sin(x)
    248                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     247                        // variables: sin(x), cos(x)
     248                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    249249                        forward_cos_op(d, i_var, arg[0], J, Taylor);
    250250                        break;
     
    252252
    253253                        case CoshOp:
    254                         // variables: cosh(x), sinh(x)
    255                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     254                        // variables: sinh(x), cosh(x)
     255                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    256256                        forward_cosh_op(d, i_var, arg[0], J, Taylor);
    257257                        break;
     
    418418
    419419                        case SinOp:
    420                         // variables: sin(x), cos(x)
    421                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     420                        // variables: cos(x), sin(x)
     421                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    422422                        forward_sin_op(d, i_var, arg[0], J, Taylor);
    423423                        break;
     
    425425
    426426                        case SinhOp:
    427                         // variables: sinh(x), cosh(x)
    428                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     427                        // variables: cosh(x), sinh(x)
     428                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    429429                        forward_sinh_op(d, i_var, arg[0], J, Taylor);
    430430                        break;
     
    555555                case PowvpOp:
    556556                case PowvvOp:
     557                case CosOp:
     558                case SinOp:
     559                case CoshOp:
     560                case SinhOp:
    557561                check = i_var + 1;
    558562                break;
  • branches/multiple_result/cppad/local/player.hpp

    r1584 r1585  
    536536                        case PowvpOp:
    537537                        case PowvvOp:
     538                        case SinOp:
     539                        case CosOp:
     540                        case SinhOp:
     541                        case CoshOp:
    538542                        var_index += NumRes(op) - 1;
    539543                        break;
     
    624628                        case PowvpOp:
    625629                        case PowvvOp:
     630                        case SinOp:
     631                        case CosOp:
     632                        case SinhOp:
     633                        case CoshOp:
    626634                        var_index += NumRes(op) - 1;
    627635                        break;
  • branches/multiple_result/cppad/local/recorder.hpp

    r1584 r1585  
    245245                case PowvpOp:
    246246                case PowvvOp:
     247                case CosOp:
     248                case SinOp:
     249                case CoshOp:
     250                case SinhOp:
    247251                return num_rec_var_ - 1;
    248252                break;
  • branches/multiple_result/cppad/local/rev_hes_sweep.hpp

    r1584 r1585  
    260260                        case CosOp:
    261261                        // cosine and sine must come in pairs
    262                         // but i_var + 1 should only be used here
     262                        // but i_var should only be used here
    263263                        CPPAD_ASSERT_NARG_NRES(op, 1, 2)
    264264                        reverse_sparse_hessian_nonlinear_unary_op(
     
    270270                        case CoshOp:
    271271                        // hyperbolic cosine and sine must come in pairs
    272                         // but i_var + 1 should only be used here
     272                        // but i_var should only be used here
    273273                        CPPAD_ASSERT_NARG_NRES(op, 1, 2)
    274274                        reverse_sparse_hessian_nonlinear_unary_op(
     
    432432                        case SinOp:
    433433                        // sine and cosine must come in pairs
    434                         // but i_var + 1 should only be used here
     434                        // but i_var should only be used here
    435435                        CPPAD_ASSERT_NARG_NRES(op, 1, 2)
    436436                        reverse_sparse_hessian_nonlinear_unary_op(
     
    442442                        case SinhOp:
    443443                        // sine and cosine must come in pairs
    444                         // but i_var + 1 should only be used here
     444                        // but i_var should only be used here
    445445                        CPPAD_ASSERT_NARG_NRES(op, 1, 2)
    446446                        reverse_sparse_hessian_nonlinear_unary_op(
  • branches/multiple_result/cppad/local/rev_jac_sweep.hpp

    r1584 r1585  
    228228                        case CosOp:
    229229                        // cosine and sine must come in pairs
    230                         // but i_var + 1 should only be used here
     230                        // but i_var should only be used here
    231231                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    232232                        reverse_sparse_jacobian_unary_op(
     
    238238                        case CoshOp:
    239239                        // hyperbolic cosine and sine must come in pairs
    240                         // but i_var + 1 should only be used here
     240                        // but i_var should only be used here
    241241                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    242242                        reverse_sparse_jacobian_unary_op(
     
    395395                        case SinOp:
    396396                        // sine and cosine must come in pairs
    397                         // but i_var + 1 should only be used here
     397                        // but i_var should only be used here
    398398                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    399399                        reverse_sparse_jacobian_unary_op(
     
    405405                        case SinhOp:
    406406                        // hyperbolic sine and cosine must come in pairs
    407                         // but i_var + 1 should only be used here
     407                        // but i_var should only be used here
    408408                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    409409                        reverse_sparse_jacobian_unary_op(
  • branches/multiple_result/cppad/local/reverse_sweep.hpp

    r1584 r1585  
    269269
    270270                        case CosOp:
    271                         CPPAD_ASSERT_UNKNOWN( i_var < numvar - 1 );
     271                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    272272                        reverse_cos_op(
    273273                                d, i_var, arg[0], J, Taylor, K, Partial
     
    277277
    278278                        case CoshOp:
    279                         CPPAD_ASSERT_UNKNOWN( i_var < numvar - 1 );
     279                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    280280                        reverse_cosh_op(
    281281                                d, i_var, arg[0], J, Taylor, K, Partial
     
    410410
    411411                        case SinOp:
    412                         CPPAD_ASSERT_UNKNOWN( i_var < numvar - 1 );
     412                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    413413                        reverse_sin_op(
    414414                                d, i_var, arg[0], J, Taylor, K, Partial
     
    418418
    419419                        case SinhOp:
    420                         CPPAD_ASSERT_UNKNOWN( i_var < numvar - 1 );
     420                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    421421                        reverse_sinh_op(
    422422                                d, i_var, arg[0], J, Taylor, K, Partial
  • branches/multiple_result/cppad/local/sin_op.hpp

    r1447 r1585  
    4949        CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
    5050        CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
    51         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     51        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5252        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    5353
     
    5555        Base* x = taylor + i_x * nc_taylor;
    5656        Base* s = taylor + i_z * nc_taylor;
    57         Base* c = s      +       nc_taylor;
     57        Base* c = s      -       nc_taylor;
    5858
    5959        // rest of this routine is identical for the following cases:
     
    103103        CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
    104104        CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
    105         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     105        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    106106        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
    107107
     
    109109        Base* x = taylor + i_x * nc_taylor;
    110110        Base* s = taylor + i_z * nc_taylor;  // called z in documentation
    111         Base* c = s      +       nc_taylor;  // called y in documentation
     111        Base* c = s      -       nc_taylor;  // called y in documentation
    112112
    113113        s[0] = sin( x[0] );
     
    144144        CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
    145145        CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
    146         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     146        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    147147        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
    148148        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    157157
    158158        // Taylor coefficients and partials corresponding to auxillary result
    159         const Base* c  = s  + nc_taylor; // called y in documentation
    160         Base* pc       = ps + nc_partial;
     159        const Base* c  = s  - nc_taylor; // called y in documentation
     160        Base* pc       = ps - nc_partial;
    161161
    162162        // rest of this routine is identical for the following cases:
  • branches/multiple_result/cppad/local/sinh_op.hpp

    r1460 r1585  
    4949        CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
    5050        CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
    51         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     51        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5252        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    5353
     
    5555        Base* x = taylor + i_x * nc_taylor;
    5656        Base* s = taylor + i_z * nc_taylor;
    57         Base* c = s      +       nc_taylor;
     57        Base* c = s      -       nc_taylor;
    5858
    5959
     
    103103        CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
    104104        CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
    105         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     105        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    106106        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
    107107
     
    109109        Base* x = taylor + i_x * nc_taylor;
    110110        Base* s = taylor + i_z * nc_taylor;  // called z in documentation
    111         Base* c = s      +       nc_taylor;  // called y in documentation
     111        Base* c = s      -       nc_taylor;  // called y in documentation
    112112
    113113        s[0] = sinh( x[0] );
     
    143143        CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
    144144        CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
    145         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     145        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    146146        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
    147147        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    156156
    157157        // Taylor coefficients and partials corresponding to auxillary result
    158         const Base* c  = s  + nc_taylor; // called y in documentation
    159         Base* pc       = ps + nc_partial;
     158        const Base* c  = s  - nc_taylor; // called y in documentation
     159        Base* pc       = ps - nc_partial;
    160160
    161161        // rest of this routine is identical for the following cases:
Note: See TracChangeset for help on using the changeset viewer.