示例#1
0
size_t forward_sweep(
    std::ostream&         s_out,
    bool                  print,
    size_t                d,
    size_t                n,
    size_t                numvar,
    player<Base>         *Rec,
    size_t                J,
    Base                 *Taylor
)
{   CPPAD_ASSERT_UNKNOWN( J >= d + 1 );

    // op code for current instruction
    OpCode           op;

    // index for current instruction
    size_t         i_op;

    // next variables
    size_t        i_var;

    CPPAD_ASSERT_UNKNOWN( d == 0 || ! print );
# if CPPAD_USE_FORWARD0SWEEP
    CPPAD_ASSERT_UNKNOWN( d > 0 );
# else
    addr_t*         non_const_arg;
# endif
    const addr_t*   arg = 0;

    // temporary indices
    size_t i, ell;

    // initialize the comparision operator (ComOp) counter
    size_t compareCount = 0;

    // if this is an order zero calculation, initialize vector indices
    pod_vector<size_t> VectorInd;  // address for each element
    pod_vector<bool>   VectorVar;  // is element a variable
    i = Rec->num_rec_vecad_ind();
    if( i > 0 )
    {   VectorInd.extend(i);
        VectorVar.extend(i);
        while(i--)
        {   VectorInd[i] = Rec->GetVecInd(i);
            VectorVar[i] = false;
        }
    }

    // work space used by UserOp.
    const size_t user_k  = d;    // order of this forward mode calculation
    const size_t user_k1 = d+1;  // number of orders for this calculation
    vector<Base> user_tx;        // argument vector Taylor coefficients
    vector<Base> user_ty;        // result vector Taylor coefficients
    vector<size_t> user_iy;      // variable indices for results vector
    size_t user_index = 0;       // indentifier for this user_atomic operation
    size_t user_id    = 0;       // user identifier for this call to operator
    size_t user_i     = 0;       // index in result vector
    size_t user_j     = 0;       // index in argument vector
    size_t user_m     = 0;       // size of result vector
    size_t user_n     = 0;       // size of arugment vector
    // next expected operator in a UserOp sequence
    enum { user_start, user_arg, user_ret, user_end } user_state = user_start;

    // check numvar argument
    CPPAD_ASSERT_UNKNOWN( Rec->num_rec_var() == numvar );

    // length of the parameter vector (used by CppAD assert macros)
    const size_t num_par = Rec->num_rec_par();

    // pointer to the beginning of the parameter vector
    const Base* parameter = 0;
    if( num_par > 0 )
        parameter = Rec->GetPar();

# if ! CPPAD_USE_FORWARD0SWEEP
    // length of the text vector (used by CppAD assert macros)
    const size_t num_text = Rec->num_rec_text();

    // pointer to the beginning of the text vector
    const char* text = 0;
    if( num_text > 0 )
        text = Rec->GetTxt(0);
# endif

    // skip the BeginOp at the beginning of the recording
    Rec->start_forward(op, arg, i_op, i_var);
    CPPAD_ASSERT_UNKNOWN( op == BeginOp );
# if CPPAD_FORWARD_SWEEP_TRACE
    std::cout << std::endl;
# endif
    while(op != EndOp)
    {
        // this op
        Rec->next_forward(op, arg, i_op, i_var);
        CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) );
        CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );

        // action depends on the operator
        switch( op )
        {
        case AbsOp:
            forward_abs_op(d, i_var, arg[0], J, Taylor);
            break;
        // -------------------------------------------------

        case AddvvOp:
            forward_addvv_op(d, i_var, arg, parameter, J, Taylor);
            break;
        // -------------------------------------------------

        case AddpvOp:
            CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
            forward_addpv_op(d, i_var, arg, parameter, J, Taylor);
            break;
        // -------------------------------------------------

        case AcosOp:
            // sqrt(1 - x * x), acos(x)
            CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
            forward_acos_op(d, i_var, arg[0], J, Taylor);
            break;
        // -------------------------------------------------

        case AsinOp:
            // sqrt(1 - x * x), asin(x)
            CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
            forward_asin_op(d, i_var, arg[0], J, Taylor);
            break;
        // -------------------------------------------------

        case AtanOp:
            // 1 + x * x, atan(x)
            CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
            forward_atan_op(d, i_var, arg[0], J, Taylor);
            break;
        // -------------------------------------------------

        case CSumOp:
            // CSumOp has a variable number of arguments and
            // next_forward thinks it one has one argument.
            // we must inform next_forward of this special case.
            Rec->forward_csum(op, arg, i_op, i_var);
            forward_csum_op(
                d, i_var, arg, num_par, parameter, J, Taylor
            );
            break;
        // -------------------------------------------------

        case CExpOp:
            forward_cond_op(
                d, i_var, arg, num_par, parameter, J, Taylor
            );
            break;
        // ---------------------------------------------------

        case ComOp:
# if ! USE_FORWARD0SWEEP
            if( d == 0 ) forward_comp_op_0(
                    compareCount, arg, num_par, parameter, J, Taylor
                );
# endif
            break;
        // ---------------------------------------------------

        case CosOp:
            // sin(x), cos(x)
            CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
            forward_cos_op(d, i_var, arg[0], J, Taylor);
            break;
        // ---------------------------------------------------

        case CoshOp:
            // sinh(x), cosh(x)
            CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
            forward_cosh_op(d, i_var, arg[0], J, Taylor);
            break;
        // -------------------------------------------------

        case DisOp:
# if ! CPPAD_USE_FORWARD0SWEEP
            if( d == 0 )
                forward_dis_op_0(i_var, arg, J, Taylor);
            else
# endif
            {   Taylor[ i_var * J + d] = Base(0);
            }
            break;
        // -------------------------------------------------

        case DivvvOp:
            forward_divvv_op(d, i_var, arg, parameter, J, Taylor);
            break;
        // -------------------------------------------------

        case DivpvOp:
            CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
            forward_divpv_op(d, i_var, arg, parameter, J, Taylor);
            break;
        // -------------------------------------------------

        case DivvpOp:
            CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
            forward_divvp_op(d, i_var, arg, parameter, J, Taylor);
            break;
        // -------------------------------------------------

        case EndOp:
            CPPAD_ASSERT_NARG_NRES(op, 0, 0);
            break;
        // -------------------------------------------------

        case ExpOp:
            forward_exp_op(d, i_var, arg[0], J, Taylor);
            break;
        // -------------------------------------------------

        case InvOp:
            CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
            break;
        // -------------------------------------------------

        case LdpOp:
# if ! CPPAD_USE_FORWARD0SWEEP
            if( d == 0 )
            {   non_const_arg = Rec->forward_non_const_arg();
                forward_load_p_op_0(
                    i_var,
                    non_const_arg,
                    num_par,
                    parameter,
                    J,
                    Taylor,
                    Rec->num_rec_vecad_ind(),
                    VectorVar.data(),
                    VectorInd.data()
                );
            }
            else
# endif
            {   forward_load_op( op, d, i_var, arg, J, Taylor);
            }
            break;
        // -------------------------------------------------

        case LdvOp:
# if ! CPPAD_USE_FORWARD0SWEEP
            if( d == 0 )
            {   non_const_arg = Rec->forward_non_const_arg();
                forward_load_v_op_0(
                    i_var,
                    non_const_arg,
                    num_par,
                    parameter,
                    J,
                    Taylor,
                    Rec->num_rec_vecad_ind(),
                    VectorVar.data(),
                    VectorInd.data()
                );
            }
            else
# endif
            {   forward_load_op( op, d, i_var, arg, J, Taylor);
            }
            break;
        // -------------------------------------------------

        case LogOp:
            forward_log_op(d, i_var, arg[0], J, Taylor);
            break;
        // -------------------------------------------------

        case MulvvOp:
            forward_mulvv_op(d, i_var, arg, parameter, J, Taylor);
            break;
        // -------------------------------------------------

        case MulpvOp:
            CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
            forward_mulpv_op(d, i_var, arg, parameter, J, Taylor);
            break;
        // -------------------------------------------------

        case ParOp:
# if ! CPPAD_USE_FORWARD0SWEEP
            if( d == 0 ) forward_par_op_0(
                    i_var, arg, num_par, parameter, J, Taylor
                );
            else
# endif
            {   Taylor[ i_var * J + d] = Base(0);
            }
            break;
        // -------------------------------------------------

        case PowvpOp:
            CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
            forward_powvp_op(d, i_var, arg, parameter, J, Taylor);
            break;
        // -------------------------------------------------

        case PowpvOp:
            CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
            forward_powpv_op(d, i_var, arg, parameter, J, Taylor);
            break;
        // -------------------------------------------------

        case PowvvOp:
            forward_powvv_op(d, i_var, arg, parameter, J, Taylor);
            break;
        // -------------------------------------------------

        case PriOp:
# if ! CPPAD_USE_FORWARD0SWEEP
            if( print ) forward_pri_0(s_out,
                                          i_var, arg, num_text, text, num_par, parameter, J, Taylor
                                         );
# endif
            break;
        // -------------------------------------------------

        case SignOp:
            // cos(x), sin(x)
            CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
            forward_sign_op(d, i_var, arg[0], J, Taylor);
            break;

        case SinOp:
            // cos(x), sin(x)
            CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
            forward_sin_op(d, i_var, arg[0], J, Taylor);
            break;
        // -------------------------------------------------

        case SinhOp:
            // cosh(x), sinh(x)
            CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
            forward_sinh_op(d, i_var, arg[0], J, Taylor);
            break;
        // -------------------------------------------------

        case SqrtOp:
            forward_sqrt_op(d, i_var, arg[0], J, Taylor);
            break;
        // -------------------------------------------------

        case StppOp:
# if ! CPPAD_USE_FORWARD0SWEEP
            if( d == 0 )
            {   forward_store_pp_op_0(
                    i_var,
                    arg,
                    num_par,
                    J,
                    Taylor,
                    Rec->num_rec_vecad_ind(),
                    VectorVar.data(),
                    VectorInd.data()
                );
            }
# endif
            break;
        // -------------------------------------------------

        case StpvOp:
# if ! CPPAD_USE_FORWARD0SWEEP
            if( d == 0 )
            {   forward_store_pv_op_0(
                    i_var,
                    arg,
                    num_par,
                    J,
                    Taylor,
                    Rec->num_rec_vecad_ind(),
                    VectorVar.data(),
                    VectorInd.data()
                );
            }
# endif
            break;
        // -------------------------------------------------

        case StvpOp:
# if ! CPPAD_USE_FORWARD0SWEEP
            if( d == 0 )
            {   forward_store_vp_op_0(
                    i_var,
                    arg,
                    num_par,
                    J,
                    Taylor,
                    Rec->num_rec_vecad_ind(),
                    VectorVar.data(),
                    VectorInd.data()
                );
            }
# endif
            break;
        // -------------------------------------------------

        case StvvOp:
# if ! CPPAD_USE_FORWARD0SWEEP
            if( d == 0 )
            {   forward_store_vv_op_0(
                    i_var,
                    arg,
                    num_par,
                    J,
                    Taylor,
                    Rec->num_rec_vecad_ind(),
                    VectorVar.data(),
                    VectorInd.data()
                );
            }
# endif
            break;
        // -------------------------------------------------

        case SubvvOp:
            forward_subvv_op(d, i_var, arg, parameter, J, Taylor);
            break;
        // -------------------------------------------------

        case SubpvOp:
            CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
            forward_subpv_op(d, i_var, arg, parameter, J, Taylor);
            break;
        // -------------------------------------------------

        case SubvpOp:
            CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
            forward_subvp_op(d, i_var, arg, parameter, J, Taylor);
            break;
        // -------------------------------------------------

        case TanOp:
            // tan(x)^2, tan(x)
            CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
            forward_tan_op(d, i_var, arg[0], J, Taylor);
            break;
        // -------------------------------------------------

        case TanhOp:
            // tanh(x)^2, tanh(x)
            CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
            forward_tanh_op(d, i_var, arg[0], J, Taylor);
            break;
        // -------------------------------------------------

        case UserOp:
            // start or end an atomic operation sequence
            CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
            CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
            if( user_state == user_start )
            {   user_index = arg[0];
                user_id    = arg[1];
                user_n     = arg[2];
                user_m     = arg[3];
                if(user_tx.size() < user_n * user_k1)
                    user_tx.resize(user_n * user_k1);
                if(user_ty.size() < user_m * user_k1)
                    user_ty.resize(user_m * user_k1);
                if(user_iy.size() < user_m)
                    user_iy.resize(user_m);
                user_j     = 0;
                user_i     = 0;
                user_state = user_arg;
            }
            else
            {   CPPAD_ASSERT_UNKNOWN( user_state == user_end );
                CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
                CPPAD_ASSERT_UNKNOWN( user_id    == size_t(arg[1]) );
                CPPAD_ASSERT_UNKNOWN( user_n     == size_t(arg[2]) );
                CPPAD_ASSERT_UNKNOWN( user_m     == size_t(arg[3]) );
                user_state = user_start;

                // call users function for this operation
                user_atomic<Base>::forward(user_index, user_id,
                                           user_k, user_n, user_m, user_tx, user_ty
                                          );
                for(i = 0; i < user_m; i++) if( user_iy[i] > 0 )
                        Taylor[ user_iy[i] * J + user_k ] =
                            user_ty[ i * user_k1 + user_k ];
            }
            break;

        case UsrapOp:
            // parameter argument in an atomic operation sequence
            CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
            CPPAD_ASSERT_UNKNOWN( user_j < user_n );
            CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
            user_tx[user_j * user_k1 + 0] = parameter[ arg[0]];
            for(ell = 1; ell < user_k1; ell++)
                user_tx[user_j * user_k1 + ell] = Base(0);
            ++user_j;
            if( user_j == user_n )
                user_state = user_ret;
            break;

        case UsravOp:
            // variable argument in an atomic operation sequence
            CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
            CPPAD_ASSERT_UNKNOWN( user_j < user_n );
            CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
            for(ell = 0; ell < user_k1; ell++)
                user_tx[user_j * user_k1 + ell] = Taylor[ arg[0] * J + ell];
            ++user_j;
            if( user_j == user_n )
                user_state = user_ret;
            break;

        case UsrrpOp:
            // parameter result in an atomic operation sequence
            CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
            CPPAD_ASSERT_UNKNOWN( user_i < user_m );
            user_iy[user_i] = 0;
            user_ty[user_i * user_k1 + 0] = parameter[ arg[0]];
            for(ell = 1; ell < user_k; ell++)
                user_ty[user_i * user_k1 + ell] = Base(0);
            user_i++;
            if( user_i == user_m )
                user_state = user_end;
            break;

        case UsrrvOp:
            // variable result in an atomic operation sequence
            CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
            CPPAD_ASSERT_UNKNOWN( user_i < user_m );
            user_iy[user_i] = i_var;
            for(ell = 0; ell < user_k; ell++)
                user_ty[user_i * user_k1 + ell] = Taylor[ i_var * J + ell];
            user_i++;
            if( user_i == user_m )
                user_state = user_end;
            break;
        // -------------------------------------------------

        default:
            CPPAD_ASSERT_UNKNOWN(0);
        }
# if CPPAD_FORWARD_SWEEP_TRACE
        size_t       i_tmp  = i_var;
        Base*        Z_tmp  = Taylor + J * i_var;
        printOp(
            std::cout,
            Rec,
            i_tmp,
            op,
            arg,
            d + 1,
            Z_tmp,
            0,
            (Base *) CPPAD_NULL
        );
    }
    std::cout << std::endl;
# else
    }
示例#2
0
void forward1sweep(
	std::ostream&         s_out,
	const bool            print,
	const size_t          p,
	const size_t          q,
	const size_t          n,
	const size_t          numvar,
	player<Base>*         play,
	const size_t          J,
	Base*                 taylor,
	bool*                 cskip_op,
	pod_vector<addr_t>&   var_by_load_op,
	size_t                compare_change_count,
	size_t&               compare_change_number,
	size_t&               compare_change_op_index
)
{
	// number of directions
	const size_t r = 1;

	CPPAD_ASSERT_UNKNOWN( p <= q );
	CPPAD_ASSERT_UNKNOWN( J >= q + 1 );
	CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );

	/*
	<!-- replace forward0sweep_code_define -->
	*/
	// op code for current instruction
	OpCode op;

	// index for current instruction
	size_t i_op;

	// next variables 
	size_t i_var;

	// operation argument indices
	const addr_t*   arg = CPPAD_NULL;

	// initialize the comparision operator counter
	if( p == 0 )
	{	compare_change_number   = 0;
		compare_change_op_index = 0;
	}

	// If this includes a zero calculation, initialize this information
	pod_vector<bool>   isvar_by_ind;
	pod_vector<size_t> index_by_ind;
	if( p == 0 )
	{	size_t i;

		// this includes order zero calculation, initialize vector indices
		size_t num = play->num_vec_ind_rec();
		if( num > 0 )
		{	isvar_by_ind.extend(num);
			index_by_ind.extend(num);
			for(i = 0; i < num; i++)
			{	index_by_ind[i] = play->GetVecInd(i);
				isvar_by_ind[i] = false;
			}
		}
		// includes zero order, so initialize conditional skip flags
		num = play->num_op_rec();
		for(i = 0; i < num; i++)
			cskip_op[i] = false;
	}

	// work space used by UserOp.
	vector<bool> user_vx;        // empty vecotor
	vector<bool> user_vy;        // empty vecotor
	vector<Base> user_tx;        // argument vector Taylor coefficients 
	vector<Base> user_ty;        // result vector Taylor coefficients 
	size_t user_index = 0;       // indentifier for this atomic operation
	size_t user_id    = 0;       // user identifier for this call to operator
	size_t user_i     = 0;       // index in result vector
	size_t user_j     = 0;       // index in argument vector
	size_t user_m     = 0;       // size of result vector
	size_t user_n     = 0;       // size of arugment vector
	//
	atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
# ifndef NDEBUG
	bool               user_ok   = false;      // atomic op return value
# endif
	//
	// next expected operator in a UserOp sequence
	enum { user_start, user_arg, user_ret, user_end, user_trace }
	user_state = user_start;

	// length of the parameter vector (used by CppAD assert macros)
	const size_t num_par = play->num_par_rec();

	// pointer to the beginning of the parameter vector
	const Base* parameter = CPPAD_NULL;
	if( num_par > 0 )
		parameter = play->GetPar();

	// length of the text vector (used by CppAD assert macros)
	const size_t num_text = play->num_text_rec();

	// pointer to the beginning of the text vector
	const char* text = CPPAD_NULL;
	if( num_text > 0 )
		text = play->GetTxt(0);
	/*
	<!-- end forward0sweep_code_define -->
	*/
	// temporary indices
	size_t i, k;

	// number of orders for this user calculation
	// (not needed for order zero)
	const size_t user_q1 = q+1;

	// variable indices for results vector 
	// (done differently for order zero).
	vector<size_t> user_iy;      

	// skip the BeginOp at the beginning of the recording
	play->forward_start(op, arg, i_op, i_var);
	CPPAD_ASSERT_UNKNOWN( op == BeginOp );
# if CPPAD_FORWARD1SWEEP_TRACE
	std::cout << std::endl;
# endif
	bool more_operators = true;
	while(more_operators)
	{
		// this op
		play->forward_next(op, arg, i_op, i_var);
		CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) );  
		CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );  
		CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
		CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);

		// check if we are skipping this operation
		while( cskip_op[i_op] )
		{	if( op == CSumOp )
			{	// CSumOp has a variable number of arguments 
				play->forward_csum(op, arg, i_op, i_var);
			}
			CPPAD_ASSERT_UNKNOWN( op != CSkipOp );
			// if( op == CSkipOp )
			// {	// CSkip has a variable number of arguments
			// 	play->forward_cskip(op, arg, i_op, i_var);
			// }
			play->forward_next(op, arg, i_op, i_var);
			CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
		}

		// action depends on the operator
		switch( op )
		{
			case AbsOp:
			forward_abs_op(p, q, i_var, arg[0], J, taylor);
			break;
			// -------------------------------------------------

			case AddvvOp:
			forward_addvv_op(p, q, i_var, arg, parameter, J, taylor);
			break;
			// -------------------------------------------------

			case AddpvOp:
			CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
			forward_addpv_op(p, q, i_var, arg, parameter, J, taylor);
			break;
			// -------------------------------------------------

			case AcosOp:
			// sqrt(1 - x * x), acos(x)
			CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
			forward_acos_op(p, q, i_var, arg[0], J, taylor);
			break;
			// -------------------------------------------------

			case AsinOp:
			// sqrt(1 - x * x), asin(x)
			CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
			forward_asin_op(p, q, i_var, arg[0], J, taylor);
			break;
			// -------------------------------------------------

			case AtanOp:
			// 1 + x * x, atan(x)
			CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
			forward_atan_op(p, q, i_var, arg[0], J, taylor);
			break;
			// -------------------------------------------------

			case CExpOp:
			forward_cond_op(
				p, q, i_var, arg, num_par, parameter, J, taylor
			);
			break;
			// ---------------------------------------------------

			case CosOp:
			// sin(x), cos(x)
			CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
			forward_cos_op(p, q, i_var, arg[0], J, taylor);
			break;
			// ---------------------------------------------------

			case CoshOp:
			// sinh(x), cosh(x)
			CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
			forward_cosh_op(p, q, i_var, arg[0], J, taylor);
			break;
			// -------------------------------------------------

			case CSkipOp:
			// CSkipOp has a variable number of arguments and
			// forward_next thinks it has no arguments.
			// we must inform forward_next of this special case.
			if( p == 0 )
			{	forward_cskip_op_0(
					i_var, arg, num_par, parameter, J, taylor, cskip_op
				);
			}
			play->forward_cskip(op, arg, i_op, i_var);
			break;
			// -------------------------------------------------

			case CSumOp:
			// CSumOp has a variable number of arguments and
			// forward_next thinks it has no arguments.
			// we must inform forward_next of this special case.
			forward_csum_op(
				p, q, i_var, arg, num_par, parameter, J, taylor
			);
			play->forward_csum(op, arg, i_op, i_var);
			break;
			// -------------------------------------------------

			case DisOp:
			forward_dis_op(p, q, r, i_var, arg, J, taylor);
			break;
			// -------------------------------------------------

			case DivvvOp:
			forward_divvv_op(p, q, i_var, arg, parameter, J, taylor);
			break;
			// -------------------------------------------------

			case DivpvOp:
			CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
			forward_divpv_op(p, q, i_var, arg, parameter, J, taylor);
			break;
			// -------------------------------------------------

			case DivvpOp:
			CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
			forward_divvp_op(p, q, i_var, arg, parameter, J, taylor);
			break;
			// -------------------------------------------------

			case EndOp:
			CPPAD_ASSERT_NARG_NRES(op, 0, 0);
			more_operators = false;
			break;
			// -------------------------------------------------

			case EqpvOp:
			if( ( p == 0 ) & ( compare_change_count > 0 ) )
			{	forward_eqpv_op_0(
					compare_change_number, arg, parameter, J, taylor
				);
				if( compare_change_count == compare_change_number )
					compare_change_op_index = i_op;
			}
			break;
			// -------------------------------------------------

			case EqvvOp:
			if( ( p == 0 ) & ( compare_change_count > 0 ) )
			{	forward_eqvv_op_0(
					compare_change_number, arg, parameter, J, taylor
				);
				if( compare_change_count == compare_change_number )
					compare_change_op_index = i_op;
			}
			break;
			// -------------------------------------------------

# if CPPAD_COMPILER_HAS_ERF
			case ErfOp:
			CPPAD_ASSERT_UNKNOWN( CPPAD_COMPILER_HAS_ERF );
			// 2DO: implement zero order version of this function
			forward_erf_op(p, q, i_var, arg, parameter, J, taylor);
			break;
# endif
			// -------------------------------------------------

			case ExpOp:
			forward_exp_op(p, q, i_var, arg[0], J, taylor);
			break;
			// ---------------------------------------------------

			case InvOp:
			CPPAD_ASSERT_NARG_NRES(op, 0, 1);
			break;
			// -------------------------------------------------

			case LdpOp:
			if( p == 0 )
			{	forward_load_p_op_0(
					play,
					i_var, 
					arg, 
					parameter, 
					J, 
					taylor,
					isvar_by_ind.data(),
					index_by_ind.data(),
					var_by_load_op.data()
				);
				if( p < q ) forward_load_op( 
					play,
					op,
					p+1,
					q,
					r,
					J,
					i_var,
					arg,
					var_by_load_op.data(),
					taylor
				);
			}
			else	forward_load_op( 
				play,
				op,
				p,
				q,
				r,
				J,
				i_var,
				arg,
				var_by_load_op.data(),
				taylor
			);
			break;
			// -------------------------------------------------

			case LdvOp:
			if( p == 0 )
			{	forward_load_v_op_0(
					play,
					i_var, 
					arg, 
					parameter, 
					J, 
					taylor,
					isvar_by_ind.data(),
					index_by_ind.data(),
					var_by_load_op.data()
				);
				if( p < q ) forward_load_op( 
					play,
					op,
					p+1,
					q,
					r,
					J,
					i_var,
					arg,
					var_by_load_op.data(),
					taylor
				);
			}
			else	forward_load_op( 
				play,
				op,
				p,
				q,
				r,
				J,
				i_var,
				arg,
				var_by_load_op.data(),
				taylor
			);
			break;
			// -------------------------------------------------

			case LepvOp:
			if( ( p == 0 ) & ( compare_change_count > 0 ) )
			{	forward_lepv_op_0(
					compare_change_number, arg, parameter, J, taylor
				);
				if( compare_change_count == compare_change_number )
					compare_change_op_index = i_op;
			}
			break;

			case LevpOp:
			if( ( p == 0 ) & ( compare_change_count > 0 ) )
			{	forward_levp_op_0(
					compare_change_number, arg, parameter, J, taylor
				);
				if( compare_change_count == compare_change_number )
					compare_change_op_index = i_op;
			}
			break;
			// -------------------------------------------------

			case LevvOp:
			if( ( p == 0 ) & ( compare_change_count > 0 ) )
			{	forward_levv_op_0(
					compare_change_number, arg, parameter, J, taylor
				);
				if( compare_change_count == compare_change_number )
					compare_change_op_index = i_op;
			}
			break;
			// -------------------------------------------------

			case LogOp:
			forward_log_op(p, q, i_var, arg[0], J, taylor);
			break;
			// -------------------------------------------------

			case LtpvOp:
			if( ( p == 0 ) & ( compare_change_count > 0 ) )
			{	forward_ltpv_op_0(
					compare_change_number, arg, parameter, J, taylor
				);
				if( compare_change_count == compare_change_number )
					compare_change_op_index = i_op;
			}
			break;

			case LtvpOp:
			if( ( p == 0 ) & ( compare_change_count > 0 ) )
			{	forward_ltvp_op_0(
					compare_change_number, arg, parameter, J, taylor
				);
				if( compare_change_count == compare_change_number )
					compare_change_op_index = i_op;
			}
			break;
			// -------------------------------------------------

			case LtvvOp:
			if( ( p == 0 ) & ( compare_change_count > 0 ) )
			{	forward_ltvv_op_0(
					compare_change_number, arg, parameter, J, taylor
				);
				if( compare_change_count == compare_change_number )
					compare_change_op_index = i_op;
			}
			break;
			// -------------------------------------------------

			case MulvvOp:
			forward_mulvv_op(p, q, i_var, arg, parameter, J, taylor);
			break;
			// -------------------------------------------------

			case MulpvOp:
			CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
			forward_mulpv_op(p, q, i_var, arg, parameter, J, taylor);
			break;
			// -------------------------------------------------

			case NepvOp:
			if( ( p == 0 ) & ( compare_change_count > 0 ) )
			{	forward_nepv_op_0(
					compare_change_number, arg, parameter, J, taylor
				);
				if( compare_change_count == compare_change_number )
					compare_change_op_index = i_op;
			}
			break;
			// -------------------------------------------------

			case NevvOp:
			if( ( p == 0 ) & ( compare_change_count > 0 ) )
			{	forward_nevv_op_0(
					compare_change_number, arg, parameter, J, taylor
				);
				if( compare_change_count == compare_change_number )
					compare_change_op_index = i_op;
			}
			break;
			// -------------------------------------------------

			case ParOp:
			i = p;
			if( i == 0 )
			{	forward_par_op_0(
					i_var, arg, num_par, parameter, J, taylor
				);
				i++;
			}
			while(i <= q)
			{	taylor[ i_var * J + i] = Base(0); 
				i++;
			}
			break;
			// -------------------------------------------------

			case PowvpOp:
			CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
			forward_powvp_op(p, q, i_var, arg, parameter, J, taylor);
			break;
			// -------------------------------------------------

			case PowpvOp:
			CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
			forward_powpv_op(p, q, i_var, arg, parameter, J, taylor);
			break;
			// -------------------------------------------------

			case PowvvOp:
			forward_powvv_op(p, q, i_var, arg, parameter, J, taylor);
			break;
			// -------------------------------------------------

			case PriOp:
			if( (p == 0) & print ) forward_pri_0(s_out,
				arg, num_text, text, num_par, parameter, J, taylor
			);
			break;
			// -------------------------------------------------

			case SignOp:
			// sign(x)
			CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
			forward_sign_op(p, q, i_var, arg[0], J, taylor);
			break;
			// -------------------------------------------------

			case SinOp:
			// cos(x), sin(x)
			CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
			forward_sin_op(p, q, i_var, arg[0], J, taylor);
			break;
			// -------------------------------------------------

			case SinhOp:
			// cosh(x), sinh(x)
			CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
			forward_sinh_op(p, q, i_var, arg[0], J, taylor);
			break;
			// -------------------------------------------------

			case SqrtOp:
			forward_sqrt_op(p, q, i_var, arg[0], J, taylor);
			break;
			// -------------------------------------------------

			case StppOp:
			if( p == 0 )
			{	forward_store_pp_op_0(
					i_var, 
					arg, 
					num_par, 
					J, 
					taylor,
					isvar_by_ind.data(),
					index_by_ind.data()
				);
			}
			break;
			// -------------------------------------------------

			case StpvOp:
			if( p == 0 )
			{	forward_store_pv_op_0(
					i_var, 
					arg, 
					num_par, 
					J, 
					taylor,
					isvar_by_ind.data(),
					index_by_ind.data()
				);
			}
			break;
			// -------------------------------------------------

			case StvpOp:
			if( p == 0 )
			{	forward_store_vp_op_0(
					i_var, 
					arg, 
					num_par, 
					J, 
					taylor,
					isvar_by_ind.data(),
					index_by_ind.data()
				);
			}
			break;
			// -------------------------------------------------

			case StvvOp:
			if( p == 0 )
			{	forward_store_vv_op_0(
					i_var, 
					arg, 
					num_par, 
					J, 
					taylor,
					isvar_by_ind.data(),
					index_by_ind.data()
				);
			}
			break;
			// -------------------------------------------------

			case SubvvOp:
			forward_subvv_op(p, q, i_var, arg, parameter, J, taylor);
			break;
			// -------------------------------------------------

			case SubpvOp:
			CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
			forward_subpv_op(p, q, i_var, arg, parameter, J, taylor);
			break;
			// -------------------------------------------------

			case SubvpOp:
			CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
			forward_subvp_op(p, q, i_var, arg, parameter, J, taylor);
			break;
			// -------------------------------------------------

			case TanOp:
			// tan(x)^2, tan(x)
			CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
			forward_tan_op(p, q, i_var, arg[0], J, taylor);
			break;
			// -------------------------------------------------

			case TanhOp:
			// tanh(x)^2, tanh(x)
			CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
			forward_tanh_op(p, q, i_var, arg[0], J, taylor);
			break;
			// -------------------------------------------------

			case UserOp:
			// start or end an atomic operation sequence
			CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
			CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
			if( user_state == user_start )
			{	user_index = arg[0];
				user_id    = arg[1];
				user_n     = arg[2];
				user_m     = arg[3];
				user_atom  = atomic_base<Base>::class_object(user_index);
# ifndef NDEBUG
				if( user_atom == CPPAD_NULL )
				{	std::string msg = 
						atomic_base<Base>::class_name(user_index)
						+ ": atomic_base function has been deleted";
					CPPAD_ASSERT_KNOWN(false, msg.c_str() );
				}
# endif
				if(user_tx.size() != user_n * user_q1)
					user_tx.resize(user_n * user_q1);
				if(user_ty.size() != user_m * user_q1)
					user_ty.resize(user_m * user_q1);
				if(user_iy.size() != user_m)
					user_iy.resize(user_m);
				user_j     = 0;
				user_i     = 0;
				user_state = user_arg;
			}
			else
			{	CPPAD_ASSERT_UNKNOWN( user_state == user_end );
				CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
				CPPAD_ASSERT_UNKNOWN( user_id    == size_t(arg[1]) );
				CPPAD_ASSERT_UNKNOWN( user_n     == size_t(arg[2]) );
				CPPAD_ASSERT_UNKNOWN( user_m     == size_t(arg[3]) );

				// call users function for this operation
				user_atom->set_id(user_id);
				CPPAD_ATOMIC_CALL(
					p, q, user_vx, user_vy, user_tx, user_ty
				);
# ifndef NDEBUG
				if( ! user_ok )
				{	std::string msg = 
						atomic_base<Base>::class_name(user_index)
						+ ": atomic_base.forward: returned false";
					CPPAD_ASSERT_KNOWN(false, msg.c_str() );
				}
# endif
				for(i = 0; i < user_m; i++) 
					if( user_iy[i] > 0 )
						for(k = p; k <= q; k++)
							taylor[ user_iy[i] * J + k ] = 
								user_ty[ i * user_q1 + k ];
# if CPPAD_FORWARD1SWEEP_TRACE
				user_state = user_trace;
# else
				user_state = user_start;
# endif
			}
			break;

			case UsrapOp:
			// parameter argument in an atomic operation sequence
			CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
			CPPAD_ASSERT_UNKNOWN( user_j < user_n );
			CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
			user_tx[user_j * user_q1 + 0] = parameter[ arg[0]];
			for(k = 1; k < user_q1; k++)
				user_tx[user_j * user_q1 + k] = Base(0);
			++user_j;
			if( user_j == user_n )
				user_state = user_ret;
			break;

			case UsravOp:
			// variable argument in an atomic operation sequence
			CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
			CPPAD_ASSERT_UNKNOWN( user_j < user_n );
			CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
			for(k = 0; k < user_q1; k++)
				user_tx[user_j * user_q1 + k] = taylor[ arg[0] * J + k];
			++user_j;
			if( user_j == user_n )
				user_state = user_ret;
			break;

			case UsrrpOp:
			// parameter result in an atomic operation sequence
			CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
			CPPAD_ASSERT_UNKNOWN( user_i < user_m );
			user_iy[user_i] = 0;
			user_ty[user_i * user_q1 + 0] = parameter[ arg[0]];
			for(k = 1; k < p; k++)
				user_ty[user_i * user_q1 + k] = Base(0);
			user_i++;
			if( user_i == user_m )
				user_state = user_end;
			break;

			case UsrrvOp:
			// variable result in an atomic operation sequence
			CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
			CPPAD_ASSERT_UNKNOWN( user_i < user_m );
			user_iy[user_i] = i_var;
			for(k = 0; k < p; k++)
				user_ty[user_i * user_q1 + k] = taylor[ i_var * J + k];
			user_i++;
			if( user_i == user_m )
				user_state = user_end;
			break;
			// -------------------------------------------------

			default:
			CPPAD_ASSERT_UNKNOWN(0);
		}
# if CPPAD_FORWARD1SWEEP_TRACE
		if( user_state == user_trace )
		{	user_state = user_start;

			CPPAD_ASSERT_UNKNOWN( op == UserOp );
			CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
			for(i = 0; i < user_m; i++) if( user_iy[i] > 0 )
			{	size_t i_tmp   = (i_op + i) - user_m;
				printOp(
					std::cout, 
					play,
					i_tmp,
					user_iy[i],
					UsrrvOp, 
					CPPAD_NULL
				);
				Base* Z_tmp = taylor + user_iy[i] * J;
				printOpResult(
					std::cout, 
					q + 1, 
					Z_tmp,
					0, 
					(Base *) CPPAD_NULL
				);
				std::cout << std::endl;
			}
		}
		Base*           Z_tmp   = taylor + J * i_var;
		const addr_t*   arg_tmp = arg;
		if( op == CSumOp )
			arg_tmp = arg - arg[-1] - 4;
		if( op == CSkipOp )
			arg_tmp = arg - arg[-1] - 7;
		if( op != UsrrvOp )
		{
			printOp(
				std::cout, 
				play,
				i_op,
				i_var,
				op, 
				arg_tmp
			);
			if( NumRes(op) > 0 ) printOpResult(
				std::cout, 
				q + 1, 
				Z_tmp, 
				0, 
				(Base *) CPPAD_NULL
			);
			std::cout << std::endl;
		}
	}
	std::cout << std::endl;
# else
	}