source: trunk/cppad/local/forward0sweep.hpp @ 3680

Last change on this file since 3680 was 3680, checked in by bradbell, 5 years ago

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 071875a4beba3363e5fa9752426aec4762cd1caa
end hash code: 0bef506513a519e1073c6279d5c4cba9e5c3b180

commit 0bef506513a519e1073c6279d5c4cba9e5c3b180
Author: Brad Bell <bradbell@…>
Date: Thu May 7 12:14:32 2015 -0700

Add the acosh function (as an atomic operation when defined by compiler).

commit b3264fa17b2f65b65800423a0e243c9c3ccfe06a
Author: Brad Bell <bradbell@…>
Date: Wed May 6 20:25:38 2015 -0700

CMakeLists.txt: Change so test only check for compliation.

commit dcbac4d4f20cc383f2bd9edb02036659df40b791
Author: Brad Bell <bradbell@…>
Date: Wed May 6 15:06:28 2015 -0700

asinh.cpp: check higher orders, relax accuracy on test.

commit 5f8881993fedd18cccc3c74831133a8f8a9d17b0
Author: Brad Bell <bradbell@…>
Date: Wed May 6 14:36:18 2015 -0700

Change Acos to acos.
acos.cpp: remove trailing white space.

commit e828fa1f7c4c3848c727f14b1b7a8030071ee705
Author: Brad Bell <bradbell@…>
Date: Wed May 6 12:07:35 2015 -0700

Change Acos to acos.
acos.cpp: remove redundant index commands, remove trailing with space.

commit 3d16e5b9fe1bdafa4ad01d1d466bb72b792650fa
Author: Brad Bell <bradbell@…>
Date: Wed May 6 11:30:49 2015 -0700

op_code.hpp: Minor edits to AcosOp? commnets.

commit 58beaaad149b4ac29fae44589d7f8900bf8f4c40
Author: Brad Bell <bradbell@…>
Date: Wed May 6 10:51:43 2015 -0700

for_jac_sweep.hpp: Add missing AsinhOp? case.

commit 623c134870c522ae5e80bcf0f89d230902594c80
Author: Brad Bell <bradbell@…>
Date: Wed May 6 10:27:39 2015 -0700

Fix comment about AsinhOp? operator.

commit 226b14f6f4810f5abf1ca247aae541963efaf4d6
Author: Brad Bell <bradbell@…>
Date: Wed May 6 10:14:08 2015 -0700

Add derivative of F to make order zero case clearer.
acos_reverse.omh: Fix some sign errors.
asin_reverse.omh: Fix typo.
acos_forward.omh: Simplify by distributing minus sign.

commit 4682f4ee73e33b600b180086576e986f636a24dc
Author: Brad Bell <bradbell@…>
Date: Wed May 6 08:15:50 2015 -0700

acos_forward.omh: fix sign that depends on acos versus acosh.

commit 906ae10adf019ddda7f57dd165aab08fc55289c4
Author: Brad Bell <bradbell@…>
Date: Wed May 6 07:09:47 2015 -0700

  1. Fix inclusion of some temporary files in package (e.g., git_commit.sh).
  2. Simplify and improve using git ls-files and ls bin/check_*.
  3. Remove trailing white space.

commit 5096f4706a547bd76caa3766aa2c62802ef7f0bf
Author: Brad Bell <bradbell@…>
Date: Wed May 6 06:41:20 2015 -0700

Combine base type documentation for erf, asinh
(will add more functions to this list list).

commit b3535db5ad95bee90672abcaa686032d23bce2fc
Author: Brad Bell <bradbell@…>
Date: Tue May 5 18:01:11 2015 -0700

  1. Change Arc Cosine/Sine? to Inverse Cosine/Sine?.
  2. Change arcsin-> asin and arccos->acos.
  3. Remove index commands that are duplicates of words in titles.


acos_reverse.omh: Add acosh case to this page.

  • Property svn:keywords set to Id
File size: 24.4 KB
Line 
1/* $Id: forward0sweep.hpp 3680 2015-05-07 19:17:37Z bradbell $ */
2# ifndef CPPAD_FORWARD0SWEEP_INCLUDED
3# define CPPAD_FORWARD0SWEEP_INCLUDED
4
5/* --------------------------------------------------------------------------
6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
7
8CppAD is distributed under multiple licenses. This distribution is under
9the terms of the
10                    Eclipse Public License Version 1.0.
11
12A copy of this license is included in the COPYING file of this distribution.
13Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
14-------------------------------------------------------------------------- */
15
16namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17/*!
18\file forward0sweep.hpp
19Compute zero order forward mode Taylor coefficients.
20*/
21
22/*
23\def CPPAD_ATOMIC_CALL
24This avoids warnings when NDEBUG is defined and user_ok is not used.
25If NDEBUG is defined, this resolves to
26\code
27        user_atom->forward
28\endcode
29otherwise, it respolves to
30\code
31        user_ok = user_atom->forward
32\endcode
33This maco is undefined at the end of this file to facillitate is
34use with a different definition in other files.
35*/
36# ifdef NDEBUG
37# define CPPAD_ATOMIC_CALL user_atom->forward
38# else
39# define CPPAD_ATOMIC_CALL user_ok = user_atom->forward
40# endif
41
42/*!
43\def CPPAD_FORWARD0SWEEP_TRACE
44This value is either zero or one.
45Zero is the normal operational value.
46If it is one, a trace of every forward0sweep computation is printed.
47(Note that forward0sweep is not used if CPPAD_USE_FORWARD0SWEEP is zero).
48*/
49# define CPPAD_FORWARD0SWEEP_TRACE 0
50
51/*!
52Compute zero order forward mode Taylor coefficients.
53
54<!-- define forward0sweep_doc_define -->
55\tparam Base
56The type used during the forward mode computations; i.e., the corresponding
57recording of operations used the type AD<Base>.
58
59\param s_out
60Is the stream where output corresponding to PriOp operations will
61be written.
62
63\param print
64If print is false,
65suppress the output that is otherwise generated by the c PriOp instructions.
66
67\param n
68is the number of independent variables on the tape.
69
70\param numvar
71is the total number of variables on the tape.
72This is also equal to the number of rows in the matrix taylor; i.e.,
73play->num_var_rec().
74
75\param play
76The information stored in play
77is a recording of the operations corresponding to the function
78\f[
79        F : {\bf R}^n \rightarrow {\bf R}^m
80\f]
81where \f$ n \f$ is the number of independent variables and
82\f$ m \f$ is the number of dependent variables.
83\n
84\n
85The object play is effectly constant.
86The exception to this is that while palying back the tape
87the object play holds information about the current location
88with in the tape and this changes during palyback.
89
90\param J
91Is the number of columns in the coefficient matrix taylor.
92This must be greater than or equal one.
93
94<!-- end forward0sweep_doc_define -->
95
96\param taylor
97\n
98\b Input:
99For i = 1 , ... , n,
100<code>taylor [i * J + 0]</code>
101variable with index j on the tape
102(these are the independent variables).
103\n
104\n
105\b Output:
106For i = n + 1, ... , numvar - 1,
107<code>taylor [i * J + 0]</code>
108is the zero order Taylor coefficient for the variable with
109index i on the tape.
110
111\param cskip_op
112Is a vector with size play->num_op_rec().
113The input value of the elements does not matter.
114Upon return, if cskip_op[i] is true, the operator index i
115does not affect any of the dependent variable
116(given the value of the independent variables).
117
118\param var_by_load_op
119Is a vector with size play->num_load_op_rec().
120The input value of the elements does not matter.
121Upon return,
122it is the variable index corresponding the result for each load operator.
123In the case where the index is zero,
124the load operator results in a parameter (not a variable).
125Note that the is no variable with index zero on the tape.
126
127\param compare_change_count
128Is the count value for changing number and op_index during
129zero order foward mode.
130
131\param compare_change_number
132If compare_change_count is zero, this value is set to zero.
133Otherwise, the return value is the number of comparision operations
134that have a different result from when the information in
135play was recorded.
136
137\param compare_change_op_index
138If compare_change_count is zero, this value is set to zero.
139Otherwise it is the operator index (see forward_next) for the count-th
140comparision operation that has a different result from when the information in
141play was recorded.
142*/
143
144template <class Base>
145void forward0sweep(
146        std::ostream&         s_out,
147        bool                  print,
148        size_t                n,
149        size_t                numvar,
150        player<Base>*         play,
151        size_t                J,
152        Base*                 taylor,
153        bool*                 cskip_op,
154        pod_vector<addr_t>&   var_by_load_op,
155        size_t                compare_change_count,
156        size_t&               compare_change_number,
157        size_t&               compare_change_op_index
158)
159{       CPPAD_ASSERT_UNKNOWN( J >= 1 );
160        CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
161
162        // use p, q, r so other forward sweeps can use code defined here
163        size_t p = 0;
164        size_t q = 0;
165        size_t r = 1;
166        /*
167        <!-- define forward0sweep_code_define -->
168        */
169        // op code for current instruction
170        OpCode op;
171
172        // index for current instruction
173        size_t i_op;
174
175        // next variables
176        size_t i_var;
177
178        // operation argument indices
179        const addr_t*   arg = CPPAD_NULL;
180
181        // initialize the comparision operator counter
182        if( p == 0 )
183        {       compare_change_number   = 0;
184                compare_change_op_index = 0;
185        }
186
187        // If this includes a zero calculation, initialize this information
188        pod_vector<bool>   isvar_by_ind;
189        pod_vector<size_t> index_by_ind;
190        if( p == 0 )
191        {       size_t i;
192
193                // this includes order zero calculation, initialize vector indices
194                size_t num = play->num_vec_ind_rec();
195                if( num > 0 )
196                {       isvar_by_ind.extend(num);
197                        index_by_ind.extend(num);
198                        for(i = 0; i < num; i++)
199                        {       index_by_ind[i] = play->GetVecInd(i);
200                                isvar_by_ind[i] = false;
201                        }
202                }
203                // includes zero order, so initialize conditional skip flags
204                num = play->num_op_rec();
205                for(i = 0; i < num; i++)
206                        cskip_op[i] = false;
207        }
208
209        // work space used by UserOp.
210        vector<bool> user_vx;        // empty vecotor
211        vector<bool> user_vy;        // empty vecotor
212        vector<Base> user_tx;        // argument vector Taylor coefficients
213        vector<Base> user_ty;        // result vector Taylor coefficients
214        size_t user_index = 0;       // indentifier for this atomic operation
215        size_t user_id    = 0;       // user identifier for this call to operator
216        size_t user_i     = 0;       // index in result vector
217        size_t user_j     = 0;       // index in argument vector
218        size_t user_m     = 0;       // size of result vector
219        size_t user_n     = 0;       // size of arugment vector
220        //
221        atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
222# ifndef NDEBUG
223        bool               user_ok   = false;      // atomic op return value
224# endif
225        //
226        // next expected operator in a UserOp sequence
227        enum { user_start, user_arg, user_ret, user_end, user_trace }
228        user_state = user_start;
229
230        // length of the parameter vector (used by CppAD assert macros)
231        const size_t num_par = play->num_par_rec();
232
233        // pointer to the beginning of the parameter vector
234        const Base* parameter = CPPAD_NULL;
235        if( num_par > 0 )
236                parameter = play->GetPar();
237
238        // length of the text vector (used by CppAD assert macros)
239        const size_t num_text = play->num_text_rec();
240
241        // pointer to the beginning of the text vector
242        const char* text = CPPAD_NULL;
243        if( num_text > 0 )
244                text = play->GetTxt(0);
245        /*
246        <!-- end forward0sweep_code_define -->
247        */
248
249# if CPPAD_FORWARD0SWEEP_TRACE
250        // variable indices for results vector
251        // (done differently for order zero).
252        vector<size_t> user_iy;
253# endif
254
255        // skip the BeginOp at the beginning of the recording
256        play->forward_start(op, arg, i_op, i_var);
257        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
258# if CPPAD_FORWARD0SWEEP_TRACE
259        std::cout << std::endl;
260# endif
261        bool more_operators = true;
262        while(more_operators)
263        {
264                // this op
265                play->forward_next(op, arg, i_op, i_var);
266                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) );
267                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
268                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
269                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
270
271                // check if we are skipping this operation
272                while( cskip_op[i_op] )
273                {       if( op == CSumOp )
274                        {       // CSumOp has a variable number of arguments
275                                play->forward_csum(op, arg, i_op, i_var);
276                        }
277                        CPPAD_ASSERT_UNKNOWN( op != CSkipOp );
278                        // if( op == CSkipOp )
279                        // {    // CSkip has a variable number of arguments
280                        //      play->forward_cskip(op, arg, i_op, i_var);
281                        // }
282                        play->forward_next(op, arg, i_op, i_var);
283                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
284                }
285
286                // action to take depends on the case
287                switch( op )
288                {
289                        case AbsOp:
290                        forward_abs_op_0(i_var, arg[0], J, taylor);
291                        break;
292                        // -------------------------------------------------
293
294                        case AddvvOp:
295                        forward_addvv_op_0(i_var, arg, parameter, J, taylor);
296                        break;
297                        // -------------------------------------------------
298
299                        case AddpvOp:
300                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
301                        forward_addpv_op_0(i_var, arg, parameter, J, taylor);
302                        break;
303                        // -------------------------------------------------
304
305                        case AcosOp:
306                        // sqrt(1 - x * x), acos(x)
307                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
308                        forward_acos_op_0(i_var, arg[0], J, taylor);
309                        break;
310                        // -------------------------------------------------
311
312# if CPPAD_COMPILER_HAS_ACOSH
313                        case AcoshOp:
314                        // sqrt(x * x - 1), acosh(x)
315                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
316                        forward_acosh_op_0(i_var, arg[0], J, taylor);
317                        break;
318# endif
319                        // -------------------------------------------------
320
321                        case AsinOp:
322                        // sqrt(1 - x * x), asin(x)
323                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
324                        forward_asin_op_0(i_var, arg[0], J, taylor);
325                        break;
326                        // -------------------------------------------------
327
328# if CPPAD_COMPILER_HAS_ASINH
329                        case AsinhOp:
330                        // sqrt(1 + x * x), asinh(x)
331                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
332                        forward_asinh_op_0(i_var, arg[0], J, taylor);
333                        break;
334# endif
335                        // -------------------------------------------------
336
337                        case AtanOp:
338                        // 1 + x * x, atan(x)
339                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
340                        forward_atan_op_0(i_var, arg[0], J, taylor);
341                        break;
342                        // -------------------------------------------------
343
344                        case CExpOp:
345                        // Use the general case with d == 0
346                        // (could create an optimzied verison for this case)
347                        forward_cond_op_0(
348                                i_var, arg, num_par, parameter, J, taylor
349                        );
350                        break;
351                        // ---------------------------------------------------
352
353                        case CosOp:
354                        // sin(x), cos(x)
355                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
356                        forward_cos_op_0(i_var, arg[0], J, taylor);
357                        break;
358                        // ---------------------------------------------------
359
360                        case CoshOp:
361                        // sinh(x), cosh(x)
362                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
363                        forward_cosh_op_0(i_var, arg[0], J, taylor);
364                        break;
365                        // -------------------------------------------------
366
367                        case CSkipOp:
368                        // CSkipOp has a variable number of arguments and
369                        // forward_next thinks it has no arguments.
370                        // we must inform forward_next of this special case.
371                        forward_cskip_op_0(
372                                i_var, arg, num_par, parameter, J, taylor, cskip_op
373                        );
374                        play->forward_cskip(op, arg, i_op, i_var);
375                        break;
376                        // -------------------------------------------------
377
378                        case CSumOp:
379                        // CSumOp has a variable number of arguments and
380                        // forward_next thinks it has no arguments.
381                        // we must inform forward_next of this special case.
382                        forward_csum_op(
383                                0, 0, i_var, arg, num_par, parameter, J, taylor
384                        );
385                        play->forward_csum(op, arg, i_op, i_var);
386                        break;
387                        // -------------------------------------------------
388
389                        case DisOp:
390                        forward_dis_op(p, q, r, i_var, arg, J, taylor);
391                        break;
392                        // -------------------------------------------------
393
394                        case DivvvOp:
395                        forward_divvv_op_0(i_var, arg, parameter, J, taylor);
396                        break;
397                        // -------------------------------------------------
398
399                        case DivpvOp:
400                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
401                        forward_divpv_op_0(i_var, arg, parameter, J, taylor);
402                        break;
403                        // -------------------------------------------------
404
405                        case DivvpOp:
406                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
407                        forward_divvp_op_0(i_var, arg, parameter, J, taylor);
408                        break;
409                        // -------------------------------------------------
410
411                        case EndOp:
412                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
413                        more_operators = false;
414                        break;
415                        // -------------------------------------------------
416
417                        case EqpvOp:
418                        if( compare_change_count )
419                        {       forward_eqpv_op_0(
420                                        compare_change_number, arg, parameter, J, taylor
421                                );
422                                {       if( compare_change_count == compare_change_number )
423                                                compare_change_op_index = i_op;
424                                }
425                        }
426                        break;
427                        // -------------------------------------------------
428
429                        case EqvvOp:
430                        if( compare_change_count )
431                        {       forward_eqvv_op_0(
432                                        compare_change_number, arg, parameter, J, taylor
433                                );
434                                {       if( compare_change_count == compare_change_number )
435                                                compare_change_op_index = i_op;
436                                }
437                        }
438                        break;
439                        // -------------------------------------------------
440
441# if CPPAD_COMPILER_HAS_ERF
442                        case ErfOp:
443                        CPPAD_ASSERT_UNKNOWN( CPPAD_COMPILER_HAS_ERF );
444                        // 2DO: implement zero order version of this function
445                        forward_erf_op_0(i_var, arg, parameter, J, taylor);
446                        break;
447# endif
448                        // -------------------------------------------------
449
450                        case ExpOp:
451                        forward_exp_op_0(i_var, arg[0], J, taylor);
452                        break;
453                        // -------------------------------------------------
454
455                        case InvOp:
456                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
457                        break;
458                        // ---------------------------------------------------
459
460                        case LdpOp:
461                        forward_load_p_op_0(
462                                play,
463                                i_var,
464                                arg,
465                                parameter,
466                                J,
467                                taylor,
468                                isvar_by_ind.data(),
469                                index_by_ind.data(),
470                                var_by_load_op.data()
471                        );
472                        break;
473                        // -------------------------------------------------
474
475                        case LdvOp:
476                        forward_load_v_op_0(
477                                play,
478                                i_var,
479                                arg,
480                                parameter,
481                                J,
482                                taylor,
483                                isvar_by_ind.data(),
484                                index_by_ind.data(),
485                                var_by_load_op.data()
486                        );
487                        break;
488                        // -------------------------------------------------
489
490                        case LepvOp:
491                        if( compare_change_count )
492                        {       forward_lepv_op_0(
493                                        compare_change_number, arg, parameter, J, taylor
494                                );
495                                {       if( compare_change_count == compare_change_number )
496                                                compare_change_op_index = i_op;
497                                }
498                        }
499                        break;
500                        // -------------------------------------------------
501
502                        case LevpOp:
503                        if( compare_change_count )
504                        {       forward_levp_op_0(
505                                        compare_change_number, arg, parameter, J, taylor
506                                );
507                                {       if( compare_change_count == compare_change_number )
508                                                compare_change_op_index = i_op;
509                                }
510                        }
511                        break;
512                        // -------------------------------------------------
513
514                        case LevvOp:
515                        if( compare_change_count )
516                        {       forward_levv_op_0(
517                                        compare_change_number, arg, parameter, J, taylor
518                                );
519                                {       if( compare_change_count == compare_change_number )
520                                                compare_change_op_index = i_op;
521                                }
522                        }
523                        break;
524                        // -------------------------------------------------
525
526                        case LogOp:
527                        forward_log_op_0(i_var, arg[0], J, taylor);
528                        break;
529                        // -------------------------------------------------
530
531                        case LtpvOp:
532                        if( compare_change_count )
533                        {       forward_ltpv_op_0(
534                                        compare_change_number, arg, parameter, J, taylor
535                                );
536                                {       if( compare_change_count == compare_change_number )
537                                                compare_change_op_index = i_op;
538                                }
539                        }
540                        break;
541                        // -------------------------------------------------
542
543                        case LtvpOp:
544                        if( compare_change_count )
545                        {       forward_ltvp_op_0(
546                                        compare_change_number, arg, parameter, J, taylor
547                                );
548                                {       if( compare_change_count == compare_change_number )
549                                                compare_change_op_index = i_op;
550                                }
551                        }
552                        break;
553                        // -------------------------------------------------
554
555                        case LtvvOp:
556                        if( compare_change_count )
557                        {       forward_ltvv_op_0(
558                                        compare_change_number, arg, parameter, J, taylor
559                                );
560                                {       if( compare_change_count == compare_change_number )
561                                                compare_change_op_index = i_op;
562                                }
563                        }
564                        break;
565                        // -------------------------------------------------
566
567                        case MulvvOp:
568                        forward_mulvv_op_0(i_var, arg, parameter, J, taylor);
569                        break;
570                        // -------------------------------------------------
571
572                        case MulpvOp:
573                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
574                        forward_mulpv_op_0(i_var, arg, parameter, J, taylor);
575                        break;
576                        // -------------------------------------------------
577
578                        case NepvOp:
579                        if( compare_change_count )
580                        {       forward_nepv_op_0(
581                                        compare_change_number, arg, parameter, J, taylor
582                                );
583                                {       if( compare_change_count == compare_change_number )
584                                                compare_change_op_index = i_op;
585                                }
586                        }
587                        break;
588                        // -------------------------------------------------
589
590                        case NevvOp:
591                        if( compare_change_count )
592                        {       forward_nevv_op_0(
593                                        compare_change_number, arg, parameter, J, taylor
594                                );
595                                {       if( compare_change_count == compare_change_number )
596                                                compare_change_op_index = i_op;
597                                }
598                        }
599                        break;
600                        // -------------------------------------------------
601
602                        case ParOp:
603                        forward_par_op_0(
604                                i_var, arg, num_par, parameter, J, taylor
605                        );
606                        break;
607                        // -------------------------------------------------
608
609                        case PowvpOp:
610                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
611                        forward_powvp_op_0(i_var, arg, parameter, J, taylor);
612                        break;
613                        // -------------------------------------------------
614
615                        case PowpvOp:
616                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
617                        forward_powpv_op_0(i_var, arg, parameter, J, taylor);
618                        break;
619                        // -------------------------------------------------
620
621                        case PowvvOp:
622                        forward_powvv_op_0(i_var, arg, parameter, J, taylor);
623                        break;
624                        // -------------------------------------------------
625
626                        case PriOp:
627                        if( print ) forward_pri_0(s_out,
628                                arg, num_text, text, num_par, parameter, J, taylor
629                        );
630                        break;
631                        // -------------------------------------------------
632
633                        case SignOp:
634                        // cos(x), sin(x)
635                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
636                        forward_sign_op_0(i_var, arg[0], J, taylor);
637                        break;
638                        // -------------------------------------------------
639
640                        case SinOp:
641                        // cos(x), sin(x)
642                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
643                        forward_sin_op_0(i_var, arg[0], J, taylor);
644                        break;
645                        // -------------------------------------------------
646
647                        case SinhOp:
648                        // cosh(x), sinh(x)
649                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
650                        forward_sinh_op_0(i_var, arg[0], J, taylor);
651                        break;
652                        // -------------------------------------------------
653
654                        case SqrtOp:
655                        forward_sqrt_op_0(i_var, arg[0], J, taylor);
656                        break;
657                        // -------------------------------------------------
658
659                        case StppOp:
660                        forward_store_pp_op_0(
661                                i_var,
662                                arg,
663                                num_par,
664                                J,
665                                taylor,
666                                isvar_by_ind.data(),
667                                index_by_ind.data()
668                        );
669                        break;
670                        // -------------------------------------------------
671
672                        case StpvOp:
673                        forward_store_pv_op_0(
674                                i_var,
675                                arg,
676                                num_par,
677                                J,
678                                taylor,
679                                isvar_by_ind.data(),
680                                index_by_ind.data()
681                        );
682                        break;
683                        // -------------------------------------------------
684
685                        case StvpOp:
686                        forward_store_vp_op_0(
687                                i_var,
688                                arg,
689                                num_par,
690                                J,
691                                taylor,
692                                isvar_by_ind.data(),
693                                index_by_ind.data()
694                        );
695                        break;
696                        // -------------------------------------------------
697
698                        case StvvOp:
699                        forward_store_vv_op_0(
700                                i_var,
701                                arg,
702                                num_par,
703                                J,
704                                taylor,
705                                isvar_by_ind.data(),
706                                index_by_ind.data()
707                        );
708                        break;
709                        // -------------------------------------------------
710
711                        case SubvvOp:
712                        forward_subvv_op_0(i_var, arg, parameter, J, taylor);
713                        break;
714                        // -------------------------------------------------
715
716                        case SubpvOp:
717                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
718                        forward_subpv_op_0(i_var, arg, parameter, J, taylor);
719                        break;
720                        // -------------------------------------------------
721
722                        case SubvpOp:
723                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
724                        forward_subvp_op_0(i_var, arg, parameter, J, taylor);
725                        break;
726                        // -------------------------------------------------
727
728                        case TanOp:
729                        // tan(x)^2, tan(x)
730                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
731                        forward_tan_op_0(i_var, arg[0], J, taylor);
732                        break;
733                        // -------------------------------------------------
734
735                        case TanhOp:
736                        // tanh(x)^2, tanh(x)
737                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
738                        forward_tanh_op_0(i_var, arg[0], J, taylor);
739                        break;
740                        // -------------------------------------------------
741
742                        case UserOp:
743                        // start or end an atomic operation sequence
744                        CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
745                        CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
746                        if( user_state == user_start )
747                        {       user_index = arg[0];
748                                user_id    = arg[1];
749                                user_n     = arg[2];
750                                user_m     = arg[3];
751                                user_atom  = atomic_base<Base>::class_object(user_index);
752# ifndef NDEBUG
753                                if( user_atom == CPPAD_NULL )
754                                {       std::string msg =
755                                                atomic_base<Base>::class_name(user_index)
756                                                + ": atomic_base function has been deleted";
757                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
758                                }
759# endif
760                                if(user_tx.size() != user_n)
761                                        user_tx.resize(user_n);
762                                if(user_ty.size() != user_m)
763                                        user_ty.resize(user_m);
764# if CPPAD_FORWARD0SWEEP_TRACE
765                                if( user_iy.size() != user_m )
766                                        user_iy.resize(user_m);
767# endif
768                                user_j     = 0;
769                                user_i     = 0;
770                                user_state = user_arg;
771                        }
772                        else
773                        {       CPPAD_ASSERT_UNKNOWN( user_state == user_end );
774                                CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
775                                CPPAD_ASSERT_UNKNOWN( user_id    == size_t(arg[1]) );
776                                CPPAD_ASSERT_UNKNOWN( user_n     == size_t(arg[2]) );
777                                CPPAD_ASSERT_UNKNOWN( user_m     == size_t(arg[3]) );
778# ifndef NDEBUG
779                                if( ! user_ok )
780                                {       std::string msg =
781                                                atomic_base<Base>::class_name(user_index)
782                                                + ": atomic_base.forward: returned false";
783                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
784                                }
785# endif
786# if CPPAD_FORWARD0SWEEP_TRACE
787                                user_state = user_trace;
788# else
789                                user_state = user_start;
790# endif
791                        }
792                        break;
793
794                        case UsrapOp:
795                        // parameter argument in an atomic operation sequence
796                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
797                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
798                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
799                        user_tx[user_j++] = parameter[ arg[0] ];
800                        if( user_j == user_n )
801                        {       // call users function for this operation
802                                user_atom->set_id(user_id);
803                                CPPAD_ATOMIC_CALL(p, q,
804                                        user_vx, user_vy, user_tx, user_ty
805                                );
806                                user_state = user_ret;
807                        }
808                        break;
809
810                        case UsravOp:
811                        // variable argument in an atomic operation sequence
812                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
813                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
814                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
815                        user_tx[user_j++] = taylor[ arg[0] * J + 0 ];
816                        if( user_j == user_n )
817                        {       // call users function for this operation
818                                user_atom->set_id(user_id);
819                                CPPAD_ATOMIC_CALL(p, q,
820                                        user_vx, user_vy, user_tx, user_ty
821                                );
822                                user_state = user_ret;
823                        }
824                        break;
825
826                        case UsrrpOp:
827                        // parameter result in an atomic operation sequence
828                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
829                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
830# if CPPAD_FORWARD0SWEEP_TRACE
831                        user_iy[user_i] = 0;
832# endif
833                        user_i++;
834                        if( user_i == user_m )
835                                user_state = user_end;
836                        break;
837
838                        case UsrrvOp:
839                        // variable result in an atomic operation sequence
840                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
841                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
842# if CPPAD_FORWARD0SWEEP_TRACE
843                        user_iy[user_i] = i_var;
844# endif
845                        taylor[ i_var * J + 0 ] = user_ty[user_i++];
846                        if( user_i == user_m )
847                                user_state = user_end;
848                        break;
849                        // -------------------------------------------------
850
851                        default:
852                        CPPAD_ASSERT_UNKNOWN(false);
853                }
854# if CPPAD_FORWARD0SWEEP_TRACE
855                size_t  d  = 0;
856                if( user_state == user_trace )
857                {       user_state = user_start;
858
859                        CPPAD_ASSERT_UNKNOWN( op == UserOp );
860                        CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
861                        for(size_t i = 0; i < user_m; i++) if( user_iy[i] > 0 )
862                        {       size_t i_tmp   = (i_op + i) - user_m;
863                                printOp(
864                                        std::cout,
865                                        play,
866                                        i_tmp,
867                                        user_iy[i],
868                                        UsrrvOp,
869                                        CPPAD_NULL
870                                );
871                                Base* Z_tmp = taylor + user_iy[i] * J;
872                                printOpResult(
873                                        std::cout,
874                                        d + 1,
875                                        Z_tmp,
876                                        0,
877                                        (Base *) CPPAD_NULL
878                                );
879                                std::cout << std::endl;
880                        }
881                }
882                Base*           Z_tmp   = taylor + i_var * J;
883                const addr_t*   arg_tmp = arg;
884                if( op == CSumOp )
885                        arg_tmp = arg - arg[-1] - 4;
886                if( op == CSkipOp )
887                        arg_tmp = arg - arg[-1] - 7;
888                if( op != UsrrvOp )
889                {
890                        printOp(
891                                std::cout,
892                                play,
893                                i_op,
894                                i_var,
895                                op,
896                                arg_tmp
897                        );
898                        if( NumRes(op) > 0 ) printOpResult(
899                                std::cout,
900                                d + 1,
901                                Z_tmp,
902                                0,
903                                (Base *) CPPAD_NULL
904                        );
905                        std::cout << std::endl;
906                }
907        }
908        std::cout << std::endl;
909# else
910        }
911# endif
912        CPPAD_ASSERT_UNKNOWN( user_state == user_start );
913        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
914
915        return;
916}
917
918} // END_CPPAD_NAMESPACE
919
920// preprocessor symbols that are local to this file
921# undef CPPAD_FORWARD0SWEEP_TRACE
922# undef CPPAD_ATOMIC_CALL
923
924# endif
Note: See TracBrowser for help on using the repository browser.