/home/coin/SVN-release/CoinAll-1.1.0/cppad/cppad/local/for_jac_sweep.hpp

Go to the documentation of this file.
00001 # ifndef CPPAD_FOR_JAC_SWEEP_INCLUDED
00002 # define CPPAD_FOR_JAC_SWEEP_INCLUDED
00003 
00004 /* --------------------------------------------------------------------------
00005 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
00006 
00007 CppAD is distributed under multiple licenses. This distribution is under
00008 the terms of the 
00009                     Common Public License Version 1.0.
00010 
00011 A copy of this license is included in the COPYING file of this distribution.
00012 Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
00013 -------------------------------------------------------------------------- */
00014 
00015 /*
00016 $begin ForJacSweep$$ $comment CppAD Developer Documentation$$
00017 $spell
00018         const
00019         Jacobian
00020         ForJacSweep
00021         npv
00022         numvar
00023         Num
00024         Var
00025         Op
00026         Taylor
00027         Inv
00028 $$
00029 
00030 $section Forward Computation of Sparsity Pattern$$
00031 $index ForJacSweep$$
00032 $index sparsity, forward Jacobian$$
00033 $index forward, Jacobian sparsity$$
00034 $index pattern, forward Jacobian$$
00035 $index bit pattern, Jacobian$$
00036 
00037 $head Syntax$$
00038 $syntax%void ForJacSweep(
00039         size_t %npv%,
00040         size_t %numvar%,
00041         const TapeRec<%Base%> *%Rec%,
00042         size_t %TaylorColDim%,
00043         const %Base% *%Taylor%,
00044         %Pack% *%ForJac%
00045 )%$$
00046 
00047 
00048 $head Rec$$
00049 The information stored in $italic Rec$$
00050 is a recording of the operations corresponding to a function
00051 $latex \[
00052         F : B^n \rightarrow B^m
00053 \] $$
00054 
00055 $head Description$$
00056 Given the sparsity pattern for the independent variables,
00057 $code ForJacSweep$$ computes the sparsity pattern
00058 for all the other variables.
00059 
00060 
00061 $head numvar$$
00062 is the number of rows in the entire sparsity pattern $italic ForJac$$.
00063 It must also be equal to $syntax%%Rec%->TotNumVar()%$$.
00064 
00065 $head npv$$
00066 Is the number of elements of type $italic Pack$$
00067 (per variable) in the sparsity pattern $italic ForJac$$.
00068 
00069 $head TaylorColDim$$
00070 Is the number of columns currently stored in the matrix $italic Taylor$$.
00071 
00072 $head Taylor$$
00073 For $latex i = 1 , \ldots , numvar$$,
00074 $syntax%%Taylor%[%i% * %TaylorColDim%]%$$
00075 is the value of the variable with index $italic i$$.
00076 
00077 
00078 $head On Input$$
00079 
00080 $subhead Independent Variables and Operators$$
00081 The independent variable records come first.
00082 For $latex i = 1, \ldots , n$$ and $latex j = 0 , \ldots , npv$$,
00083 $table
00084         $bold field$$ $cnext 
00085         $bold Value$$          
00086 $rnext
00087         $syntax%%ForJac%[%0% * %npv% + %j%]%$$      $cnext 
00088         the variable with index zero is not used
00089 $rnext
00090         $syntax%%Rec%->GetOp(0)%$$                $cnext 
00091         the operator with index zero must be a $code NonOp$$
00092 $rnext
00093         $syntax%%ForJac%[%i% * %npv% + %j%]%$$      $cnext 
00094         $th j$$ subset of sparsity pattern for variable with index $italic i$$
00095 $rnext
00096         $syntax%%Rec%->GetOp(%i%)%$$              $cnext 
00097         the operator with index $italic i$$ must be a $code InvOp$$
00098 $tend
00099 
00100 $subhead Other Variables and Operators$$
00101 The other variables follow the independent variables.
00102 For $latex i = n+1, \ldots , numvar-1$$,
00103 $latex j = 0 , \ldots , npv-1$$,
00104 and $latex k = n+1, \ldots ,$$ $syntax%%Rec%->NumOp() - 1%$$,
00105 $table
00106         $bold field$$ $cnext 
00107         $bold Value$$          
00108 $rnext
00109         $syntax%%ForJac%[%i% * %npv% + %j%]%$$      $cnext 
00110         $th j$$ set of sparsity pattern for variable with index $italic i$$     
00111 $rnext
00112         $syntax%%Rec%->GetOp(%i%)%$$              $cnext 
00113         any operator except for $code InvOp$$ 
00114 $tend
00115 
00116 $head On Output$$
00117 
00118 $subhead Independent Variables$$
00119 For $latex i = 1, \ldots , n$$ and $latex j = 0 , \ldots , npv-1$$,
00120 $syntax%%Taylor%[%i% * %npv% + %j%]%$$ is not modified.
00121 
00122 
00123 $subhead Other Variables$$
00124 For $latex i = m+1, \ldots , numvar-1$$ and $latex j = 0 , \ldots , npv-1$$,
00125 $syntax%%ForJac%[%i% * %npv% + %j%]%$$ is set equal to the
00126 $th j$$ set of sparsity pattern for the variable with index $italic i$$.
00127 
00128 
00129 $end
00130 ------------------------------------------------------------------------------
00131 */
00132 # define CPPAD_FOR_JAC_SWEEP_TRACE 0
00133 
00134 
00135 // BEGIN CppAD namespace
00136 namespace CppAD {
00137 
00138 template <class Base, class Pack>
00139 void ForJacSweep(
00140         size_t                npv,
00141         size_t                numvar,
00142         const TapeRec<Base>  *Rec,
00143         size_t                TaylorColDim,
00144         const Base           *Taylor,
00145         Pack                 *ForJac
00146 )
00147 {
00148         size_t        numop;
00149         OpCode           op;
00150         size_t         i_op;
00151         size_t        i_var;
00152         size_t        i_ind;
00153         size_t        n_var;
00154         size_t        n_ind;
00155 
00156         const size_t   *ind;
00157         const Pack       *X;
00158         const Pack       *Y;
00159 
00160         Pack             *Z;
00161         Pack           *Tmp;
00162 
00163         size_t            j;
00164 
00165         // used by CExp operator 
00166         bool use_VecAD = Rec->NumVecInd() > 0;
00167         const Base  *left, *right;
00168         const Pack  *trueCase, *falseCase;
00169         Pack  *zero = CPPAD_NULL;
00170         zero        = CPPAD_TRACK_NEW_VEC(npv, zero);
00171         for(j = 0; j < npv; j++)
00172                 zero[j] = 0;
00173         
00174         // check numvar argument
00175         CPPAD_ASSERT_UNKNOWN( Rec->TotNumVar() == numvar );
00176 
00177         // set the number of operators
00178         numop = Rec->NumOp();
00179 
00180         // skip the NonOp at the beginning of the recording
00181         i_op  = 0;
00182         i_var = 0;
00183         i_ind = 0;
00184         op    = Rec->GetOp(i_op);
00185         n_var = NumVar(op);
00186         n_ind = NumInd(op);
00187         CPPAD_ASSERT_UNKNOWN( op == NonOp );
00188         CPPAD_ASSERT_UNKNOWN( n_var == 1 );
00189         CPPAD_ASSERT_UNKNOWN( n_ind == 0 );
00190 
00191         while(++i_op < numop)
00192         {
00193                 // increment for previous op
00194                 i_var += n_var;
00195                 i_ind += n_ind;
00196 
00197                 // this op
00198                 op     = Rec->GetOp(i_op);
00199 
00200                 // number of variables
00201                 n_var  = NumVar(op);
00202 
00203                 // index field values for this op
00204                 n_ind  = NumInd(op);
00205                 ind    = Rec->GetInd(n_ind, i_ind);
00206 
00207                 // value of z for this op
00208                 Z      = ForJac + i_var * npv;
00209 
00210                 // rest of information depends on the case
00211                 switch( op )
00212                 {
00213                         case AbsOp:
00214                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00215                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
00216                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00217                         X   = ForJac + ind[0] * npv;
00218                         for(j = 0; j < npv; j++)
00219                                 Z[j] = X[j];
00220                         break;
00221                         // -------------------------------------------------
00222 
00223                         case AddvvOp:
00224                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00225                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00226                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00227                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
00228 
00229                         X = ForJac + ind[0] * npv;
00230                         Y = ForJac + ind[1] * npv;
00231                         for(j = 0; j < npv; j++)
00232                                 Z[j] = X[j] | Y[j];
00233                         break;
00234                         // -------------------------------------------------
00235 
00236                         case AddpvOp:
00237                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00238                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00239                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
00240 
00241                         Y = ForJac + ind[1] * npv;
00242                         for(j = 0; j < npv; j++)
00243                                 Z[j] = Y[j];
00244                         break;
00245                         // -------------------------------------------------
00246 
00247                         case AddvpOp:
00248                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00249                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00250                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00251 
00252                         X = ForJac + ind[0] * npv;
00253                         for(j = 0; j < npv; j++)
00254                                 Z[j] = X[j];
00255                         break;
00256                         // -------------------------------------------------
00257 
00258                         case AcosOp:
00259                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
00260                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00261 
00262                         // acos(x) and sqrt(1 - x * x) are computed in pairs
00263                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
00264                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
00265 
00266                         // use Tmp for data stored in variable record
00267                         Tmp = ForJac + (i_var+1) * npv;
00268                         X   = ForJac + ind[0] * npv;
00269                         for(j = 0; j < npv; j++)
00270                                 Tmp[j] = Z[j] = X[j];
00271                         break;
00272                         // -------------------------------------------------
00273 
00274                         case AsinOp:
00275                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
00276                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00277 
00278                         // asin(x) and sqrt(1 - x * x) are computed in pairs
00279                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
00280                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
00281 
00282                         // use Tmp for data stored in variable record
00283                         Tmp = ForJac + (i_var+1) * npv;
00284                         X   = ForJac + ind[0] * npv;
00285                         for(j = 0; j < npv; j++)
00286                                 Tmp[j] = Z[j] = X[j];
00287                         break;
00288                         // -------------------------------------------------
00289 
00290                         case AtanOp:
00291                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
00292                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00293 
00294                         // atan(x) and 1 + x * x must be computed in pairs
00295                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
00296                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
00297 
00298                         // use Tmp for data stored in variable record
00299                         Tmp = ForJac + (i_var+1) * npv;
00300                         X   = ForJac + ind[0] * npv;
00301                         for(j = 0; j < npv; j++)
00302                                 Tmp[j] = Z[j] = X[j];
00303                         break;
00304                         // -------------------------------------------------
00305 
00306                         case CExpOp:
00307                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00308                         CPPAD_ASSERT_UNKNOWN( n_ind == 6);
00309                         CPPAD_ASSERT_UNKNOWN( ind[1] != 0 );
00310 
00311                         if( ind[1] & 4 )
00312                                 trueCase = ForJac + ind[4] * npv;
00313                         else    trueCase = zero;
00314                         if( ind[1] & 8 )
00315                                 falseCase = ForJac + ind[5] * npv;
00316                         else    falseCase = zero;
00317                         if( ! use_VecAD )
00318                         {       // result valid for all independent var values
00319                                 for(j = 0; j < npv; j++)
00320                                         Z[j] = trueCase[j] | falseCase[j];
00321                         }
00322                         else
00323                         {       // result only valid for current values
00324                                 if( ind[1] & 1 )
00325                                         left = Taylor + ind[2] * TaylorColDim;
00326                                 else    left = Rec->GetPar(ind[2]);
00327                                 if( ind[1] & 2 )
00328                                         right = Taylor + ind[3] * TaylorColDim;
00329                                 else    right = Rec->GetPar(ind[3]);
00330                                 for(j = 0; j < npv; j++)
00331                                 {       Z[j] = CondExpTemplate(
00332                                                 CompareOp( ind[0] ),
00333                                                 *left,
00334                                                 *right,
00335                                                 trueCase[j],
00336                                                 falseCase[j]
00337                                         );
00338                                 }
00339                         }
00340                         break;
00341                         break;
00342                         // ---------------------------------------------------
00343 
00344                         case ComOp:
00345                         CPPAD_ASSERT_UNKNOWN( n_var == 0 );
00346                         CPPAD_ASSERT_UNKNOWN( n_ind == 4 );
00347                         CPPAD_ASSERT_UNKNOWN( ind[1] > 1 );
00348                         break;
00349                         // --------------------------------------------------
00350 
00351                         case CosOp:
00352                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
00353                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00354 
00355                         // cosine and sine must come in pairs
00356                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
00357                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
00358 
00359                         // use Tmp for data stored in variable record
00360                         Tmp = ForJac + (i_var+1) * npv;
00361                         X   = ForJac + ind[0] * npv;
00362                         for(j = 0; j < npv; j++)
00363                                 Tmp[j] = Z[j] = X[j];
00364                         break;
00365                         // ---------------------------------------------------
00366 
00367                         case CoshOp:
00368                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
00369                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00370 
00371                         // hyperbolic cosine and sine must come in pairs
00372                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
00373                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
00374 
00375                         // use Tmp for data stored in variable record
00376                         Tmp = ForJac + (i_var+1) * npv;
00377                         X   = ForJac + ind[0] * npv;
00378                         for(j = 0; j < npv; j++)
00379                                 Tmp[j] = Z[j] = X[j];
00380                         break;
00381                         // -------------------------------------------------
00382 
00383                         case DisOp:
00384                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00385                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00386 
00387                         for(j = 0; j < npv; j++)
00388                                 Z[j] = 0;
00389                         break;
00390                         // -------------------------------------------------
00391 
00392                         case DivvvOp:
00393                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00394                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00395                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00396                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
00397 
00398                         X = ForJac + ind[0] * npv;
00399                         Y = ForJac + ind[1] * npv;
00400                         for(j = 0; j < npv; j++)
00401                                 Z[j] = X[j] | Y[j];
00402                         break;
00403                         // -------------------------------------------------
00404 
00405                         case DivpvOp:
00406                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00407                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00408                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
00409 
00410                         Y = ForJac + ind[1] * npv;
00411                         for(j = 0; j < npv; j++)
00412                                 Z[j] = Y[j];
00413                         break;
00414                         // -------------------------------------------------
00415 
00416                         case DivvpOp:
00417                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00418                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00419                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00420 
00421                         X = ForJac + ind[0] * npv;
00422                         for(j = 0; j < npv; j++)
00423                                 Z[j] = X[j];
00424                         break;
00425                         // -------------------------------------------------
00426 
00427                         case ExpOp:
00428                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00429                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
00430                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00431 
00432                         X = ForJac + ind[0] * npv;
00433                         for(j = 0; j < npv; j++)
00434                                 Z[j] = X[j];
00435                         break;
00436                         // -------------------------------------------------
00437 
00438                         case InvOp:
00439                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00440                         CPPAD_ASSERT_UNKNOWN( n_ind == 0 );
00441                         // Z is already defined
00442                         break;
00443                         // -------------------------------------------------
00444 
00445                         case LdpOp:
00446                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00447                         CPPAD_ASSERT_UNKNOWN( n_ind == 3 );
00448                         
00449                         CPPAD_ASSERT_UNKNOWN( ind[0] > 0 );
00450                         CPPAD_ASSERT_UNKNOWN( ind[0] < Rec->NumVecInd() );
00451 
00452                         // ind[2] is variable corresponding to this load
00453                         if( ind[2] > 0 )
00454                         {       X = ForJac + ind[2] * npv;
00455                                 for(j = 0; j < npv; j++)
00456                                         Z[j] = X[j];
00457                         }
00458                         else
00459                         {       for(j = 0; j < npv; j++)
00460                                         Z[j] = 0;
00461                         }
00462                         break;
00463                         // -------------------------------------------------
00464 
00465                         case LdvOp:
00466                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00467                         CPPAD_ASSERT_UNKNOWN( n_ind == 3 );
00468                         
00469                         CPPAD_ASSERT_UNKNOWN( ind[0] > 0 );
00470                         CPPAD_ASSERT_UNKNOWN( ind[0] < Rec->NumVecInd() );
00471 
00472 
00473                         // ind[2] is variable corresponding to this load
00474                         if( ind[2] > 0 )
00475                         {       X = ForJac + ind[2] * npv;
00476                                 for(j = 0; j < npv; j++)
00477                                         Z[j] = X[j];
00478                         }
00479                         else
00480                         {       for(j = 0; j < npv; j++)
00481                                         Z[j] = 0;
00482                         }
00483                         break;
00484                         // -------------------------------------------------
00485 
00486                         case LogOp:
00487                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00488                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
00489                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00490 
00491                         X = ForJac + ind[0] * npv;
00492                         for(j = 0; j < npv; j++)
00493                                 Z[j] = X[j];
00494                         break;
00495                         // -------------------------------------------------
00496 
00497                         case MulvvOp:
00498                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00499                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00500                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00501                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
00502 
00503                         X = ForJac + ind[0] * npv;
00504                         Y = ForJac + ind[1] * npv;
00505                         for(j = 0; j < npv; j++)
00506                                 Z[j] = X[j] | Y[j];
00507                         break;
00508                         // -------------------------------------------------
00509 
00510                         case MulpvOp:
00511                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00512                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00513                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
00514 
00515                         Y = ForJac + ind[1] * npv;
00516                         for(j = 0; j < npv; j++)
00517                                 Z[j] = Y[j];
00518                         break;
00519                         // -------------------------------------------------
00520 
00521                         case MulvpOp:
00522                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00523                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00524                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00525 
00526                         X = ForJac + ind[0] * npv;
00527                         for(j = 0; j < npv; j++)
00528                                 Z[j] = X[j];
00529                         break;
00530                         // -------------------------------------------------
00531 
00532                         case NonOp:
00533                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00534                         CPPAD_ASSERT_UNKNOWN( n_ind == 0 );
00535                         for(j = 0; j < npv; j++)
00536                                 Z[j] = 0;
00537                         break;
00538 
00539                         case ParOp:
00540                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00541                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
00542                         for(j = 0; j < npv; j++)
00543                                 Z[j] = 0;
00544                         break;
00545                         // -------------------------------------------------
00546 
00547                         case PowvpOp:
00548                         CPPAD_ASSERT_UNKNOWN( n_var == 3 );
00549                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00550                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00551 
00552                         X = ForJac + ind[0] * npv;
00553                         for(j = 0; j < npv; j++)
00554                                 Z[j] = X[j];
00555                         break;
00556                         // -------------------------------------------------
00557 
00558                         case PowpvOp:
00559                         CPPAD_ASSERT_UNKNOWN( n_var == 3 );
00560                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00561                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
00562 
00563                         Y = ForJac + ind[1] * npv;
00564                         for(j = 0; j < npv; j++)
00565                                 Z[j] = Y[j];
00566                         break;
00567                         // -------------------------------------------------
00568 
00569                         case PowvvOp:
00570                         CPPAD_ASSERT_UNKNOWN( n_var == 3 );
00571                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00572                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00573                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
00574 
00575                         X = ForJac + ind[0] * npv;
00576                         Y = ForJac + ind[1] * npv;
00577                         for(j = 0; j < npv; j++)
00578                                 Z[j] = X[j] | Y[j];
00579                         break;
00580                         // -------------------------------------------------
00581 
00582                         case PripOp:
00583                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00584                         for(j = 0; j < npv; j++)
00585                                 Z[j] = 0;
00586                         break;
00587                         // -------------------------------------------------
00588 
00589                         case PrivOp:
00590                         // nvar should be zero for this case
00591                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00592                         break;
00593                         // -------------------------------------------------
00594 
00595                         case SinOp:
00596                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
00597                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00598 
00599                         // sine and cosine must come in pairs
00600                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
00601                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
00602 
00603                         // use Tmp for data stored in second variable
00604                         Tmp = ForJac + (i_var+1) * npv;
00605                         X   = ForJac + ind[0] * npv;
00606                         for(j = 0; j < npv; j++)
00607                                 Z[j] = Tmp[j] = X[j];
00608                         break;
00609                         // -------------------------------------------------
00610 
00611                         case SinhOp:
00612                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
00613                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00614 
00615                         // sine and cosine must come in pairs
00616                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
00617                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
00618 
00619                         // use Tmp for data stored in second variable
00620                         Tmp = ForJac + (i_var+1) * npv;
00621                         X   = ForJac + ind[0] * npv;
00622                         for(j = 0; j < npv; j++)
00623                                 Z[j] = Tmp[j] = X[j];
00624                         break;
00625                         // -------------------------------------------------
00626 
00627                         case SqrtOp:
00628                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00629                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
00630                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00631 
00632                         X = ForJac + ind[0] * npv;
00633                         for(j = 0; j < npv; j++)
00634                                 Z[j] = X[j];
00635                         break;
00636                         // -------------------------------------------------
00637 
00638                         case StppOp:
00639                         CPPAD_ASSERT_UNKNOWN( n_var == 0);
00640                         CPPAD_ASSERT_UNKNOWN( n_ind == 3 );
00641                         break;
00642                         // -------------------------------------------------
00643 
00644                         case StpvOp:
00645                         CPPAD_ASSERT_UNKNOWN( n_var == 0);
00646                         CPPAD_ASSERT_UNKNOWN( n_ind == 3 );
00647                         break;
00648                         // -------------------------------------------------
00649 
00650                         case StvpOp:
00651                         CPPAD_ASSERT_UNKNOWN( n_var == 0);
00652                         CPPAD_ASSERT_UNKNOWN( n_ind == 3 );
00653                         break;
00654                         // -------------------------------------------------
00655 
00656                         case StvvOp:
00657                         CPPAD_ASSERT_UNKNOWN( n_var == 0);
00658                         CPPAD_ASSERT_UNKNOWN( n_ind == 3 );
00659                         break;
00660                         // -------------------------------------------------
00661 
00662                         case SubvvOp:
00663                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00664                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00665                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00666                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
00667 
00668                         X = ForJac + ind[0] * npv;
00669                         Y = ForJac + ind[1] * npv;
00670                         for(j = 0; j < npv; j++)
00671                                 Z[j] = X[j] | Y[j];
00672                         break;
00673                         // -------------------------------------------------
00674 
00675                         case SubpvOp:
00676                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00677                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00678                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
00679 
00680                         Y = ForJac + ind[1] * npv;
00681                         for(j = 0; j < npv; j++)
00682                                 Z[j] = Y[j];
00683                         break;
00684                         // -------------------------------------------------
00685 
00686                         case SubvpOp:
00687                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
00688                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
00689                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
00690 
00691                         X = ForJac + ind[0] * npv;
00692                         for(j = 0; j < npv; j++)
00693                                 Z[j] = X[j];
00694                         break;
00695                         // -------------------------------------------------
00696 
00697                         default:
00698                         CPPAD_ASSERT_UNKNOWN(0);
00699                 }
00700 # if CPPAD_FOR_JAC_SWEEP_TRACE
00701                 printOp(
00702                         std::cout, 
00703                         Rec,
00704                         i_var,
00705                         op, 
00706                         ind,
00707                         npv, 
00708                         Z, 
00709                         0, 
00710                         (Pack *) CPPAD_NULL
00711                 );
00712         }
00713         std::cout << std::endl;
00714 # else
00715         }
00716 # endif
00717         CPPAD_ASSERT_UNKNOWN( (i_var + n_var) == Rec->TotNumVar() );
00718 
00719         // free vector of zeros
00720         CPPAD_TRACK_DEL_VEC(zero);
00721 
00722         return;
00723 }
00724 
00725 } // END CppAD namespace
00726 
00727 # undef CPPAD_FOR_JAC_SWEEP_TRACE
00728 
00729 # endif
Generated on Sun Nov 14 14:06:33 2010 for Coin-All by  doxygen 1.4.7