Changeset 3333


Ignore:
Timestamp:
Sep 15, 2014 8:02:08 AM (6 years ago)
Author:
bradbell
Message:

Move arg_is_variable to op_code.hpp so can be used by printOp.

Location:
branches/cache/cppad/local
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/cache/cppad/local/cache.hpp

    r3332 r3333  
    99
    1010namespace CppAD { // BEGIN_CPPAD_NAMESPACE
    11 
    12 inline bool arg_is_variable(OpCode op, const addr_t* arg, size_t i_arg)
    13 {       bool ret = false;
    14         switch(op)
    15         {
    16                 // --------------------------------------------------------------
    17                 // no argument variables for this operation
    18                 case BeginOp:
    19                 case CSkipOp:
    20                 case CSumOp:
    21                 case EndOp:
    22                 case InvOp:
    23                 case LdpOp:
    24                 case StppOp:
    25                 break;
    26 
    27                 // --------------------------------------------------------------
    28                 // first argument is only variable for this operation
    29                 case AbsOp:
    30                 case AcosOp:
    31                 case AsinOp:
    32                 case AtanOp:
    33                 case CosOp:
    34                 case CoshOp:
    35                 case DivvpOp:
    36                 case ExpOp:
    37                 case LogOp:
    38                 case ParOp:
    39                 case PowvpOp:
    40                 case SignOp:
    41                 case SinOp:
    42                 case SinhOp:
    43                 case SqrtOp:
    44                 case SubvpOp:
    45                 case TanOp:
    46                 case TanhOp:
    47                 ret |= i_arg == 0;
    48                 break;
    49 
    50                 // --------------------------------------------------------------
    51                 // second argument is only variable for this operation
    52                 case AddpvOp:
    53                 case DisOp:
    54                 case DivpvOp:
    55                 case LdvOp:
    56                 case MulpvOp:
    57                 case PowpvOp:
    58                 case StvpOp:
    59                 case SubpvOp:
    60                 ret |= i_arg == 1;
    61                 break;
    62 
    63                 // --------------------------------------------------------------
    64                 // first and second arguments are only variables for this operation
    65                 case AddvvOp:
    66                 case DivvvOp:
    67                 case MulvvOp:
    68                 case PowvvOp:
    69                 case SubvvOp:
    70                 CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
    71                 ret |= true;
    72                 break;
    73 
    74                 // --------------------------------------------------------------
    75                 // third argument is only variables for this operation
    76                 case StpvOp:
    77                 ret |= i_arg == 2;
    78                 break;
    79 
    80                 // --------------------------------------------------------------
    81                 // second and third arguments are only variables for this operation
    82                 case StvvOp:
    83                 ret |= (i_arg == 1) | (i_arg == 2);
    84                 break;
    85 
    86                 // --------------------------------------------------------------
    87                 // Comparison operator
    88                 case ComOp:
    89                 ret = false;
    90                 ret |= (i_arg == 2) & (arg[1] & 2);
    91                 ret |= (i_arg == 3) & (arg[1] & 4);
    92                 break;
    93 
    94                 // --------------------------------------------------------------
    95                 // Print operator
    96                 case PriOp:
    97                 ret |= (i_arg == 1) & (arg[0] & 1);
    98                 ret |= (i_arg == 3) & (arg[0] & 2);
    99                 break;
    100 
    101                 // --------------------------------------------------------------
    102                 // Conditional expression
    103                 case CExpOp:
    104                 ret |= (i_arg == 2) & (arg[1] & 1);
    105                 ret |= (i_arg == 3) & (arg[1] & 2);
    106                 ret |= (i_arg == 4) & (arg[1] & 4);
    107                 ret |= (i_arg == 5) & (arg[1] & 8);
    108                 break;
    109 
    110                 // --------------------------------------------------------------
    111                 // user atomic operations
    112                 case UserOp:
    113                 case UsrapOp:
    114                 case UsrrpOp:
    115                 case UsrrvOp:
    116                 break;
    117 
    118                 case UsravOp:
    119                 ret |= true;
    120                 break;
    121 
    122                 default:
    123                 CPPAD_ASSERT_UNKNOWN(false);
    124                 break;
    125         }
    126         return ret;
    127 }
    128 
    12911
    13012template <class Base>
  • branches/cache/cppad/local/op_code.hpp

    r3324 r3333  
    380380
    381381/*!
     382Determine if an operation argument is a variable
     383
     384\param op
     385The operator code for this operation.
     386
     387\param arg
     388Is a vector of lenght NumArg(op) containing the arguments for this operation.
     389
     390\param i_arg
     391Is an index between 0 and NumArg(op)-1 indicating which argument to check.
     392It must hold that i_arg < NumArg(op).
     393*/
     394inline bool arg_is_variable(OpCode op, const addr_t* arg, size_t i_arg)
     395{       CPPAD_ASSERT_UNKNOWN( i_arg < NumArg(op) );
     396        bool ret = false;
     397        switch(op)
     398        {
     399                // --------------------------------------------------------------
     400                // no argument variables for this operation
     401                case BeginOp:
     402                case CSkipOp:
     403                case CSumOp:
     404                case EndOp:
     405                case InvOp:
     406                case LdpOp:
     407                case StppOp:
     408                break;
     409
     410                // --------------------------------------------------------------
     411                // first argument is only variable for this operation
     412                case AbsOp:
     413                case AcosOp:
     414                case AsinOp:
     415                case AtanOp:
     416                case CosOp:
     417                case CoshOp:
     418                case DivvpOp:
     419                case ExpOp:
     420                case LogOp:
     421                case ParOp:
     422                case PowvpOp:
     423                case SignOp:
     424                case SinOp:
     425                case SinhOp:
     426                case SqrtOp:
     427                case SubvpOp:
     428                case TanOp:
     429                case TanhOp:
     430                ret |= i_arg == 0;
     431                break;
     432
     433                // --------------------------------------------------------------
     434                // second argument is only variable for this operation
     435                case AddpvOp:
     436                case DisOp:
     437                case DivpvOp:
     438                case LdvOp:
     439                case MulpvOp:
     440                case PowpvOp:
     441                case StvpOp:
     442                case SubpvOp:
     443                ret |= i_arg == 1;
     444                break;
     445
     446                // --------------------------------------------------------------
     447                // first and second arguments are only variables for this operation
     448                case AddvvOp:
     449                case DivvvOp:
     450                case MulvvOp:
     451                case PowvvOp:
     452                case SubvvOp:
     453                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
     454                ret |= true;
     455                break;
     456
     457                // --------------------------------------------------------------
     458                // third argument is only variables for this operation
     459                case StpvOp:
     460                ret |= i_arg == 2;
     461                break;
     462
     463                // --------------------------------------------------------------
     464                // second and third arguments are only variables for this operation
     465                case StvvOp:
     466                ret |= (i_arg == 1) | (i_arg == 2);
     467                break;
     468
     469                // --------------------------------------------------------------
     470                // Comparison operator
     471                case ComOp:
     472                ret = false;
     473                ret |= (i_arg == 2) & (arg[1] & 2);
     474                ret |= (i_arg == 3) & (arg[1] & 4);
     475                break;
     476
     477                // --------------------------------------------------------------
     478                // Print operator
     479                case PriOp:
     480                ret |= (i_arg == 1) & (arg[0] & 1);
     481                ret |= (i_arg == 3) & (arg[0] & 2);
     482                break;
     483
     484                // --------------------------------------------------------------
     485                // Conditional expression
     486                case CExpOp:
     487                ret |= (i_arg == 2) & (arg[1] & 1);
     488                ret |= (i_arg == 3) & (arg[1] & 2);
     489                ret |= (i_arg == 4) & (arg[1] & 4);
     490                ret |= (i_arg == 5) & (arg[1] & 8);
     491                break;
     492
     493                // --------------------------------------------------------------
     494                // user atomic operations
     495                case UserOp:
     496                case UsrapOp:
     497                case UsrrpOp:
     498                case UsrrvOp:
     499                break;
     500
     501                case UsravOp:
     502                ret |= true;
     503                break;
     504
     505                default:
     506                CPPAD_ASSERT_UNKNOWN(false);
     507                break;
     508        }
     509        return ret;
     510}
     511
     512/*!
    382513Prints a single field corresponding to an operator.
    383514
Note: See TracChangeset for help on using the changeset viewer.