inline void forward_cond_op_dir(
size_t q ,
size_t r ,
size_t i_z ,
const addr_t* arg ,
size_t num_par ,
const Base* parameter ,
size_t cap_order ,
Base* taylor )
{ Base y_0, y_1, y_2, y_3;
Base zero(0);
size_t num_taylor_per_var = (cap_order-1) * r + 1;
Base* z = taylor + i_z * num_taylor_per_var;
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < static_cast<size_t> (CompareNe) );
CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );
CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 );
CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
CPPAD_ASSERT_UNKNOWN( 0 < q );
CPPAD_ASSERT_UNKNOWN( q < cap_order );
if( arg[1] & 1 )
{
y_0 = taylor[ arg[2] * num_taylor_per_var + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
y_0 = parameter[ arg[2] ];
}
if( arg[1] & 2 )
{
y_1 = taylor[ arg[3] * num_taylor_per_var + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
y_1 = parameter[ arg[3] ];
}
size_t m = (q-1) * r + 1;
for(size_t ell = 0; ell < r; ell++)
{ if( arg[1] & 4 )
{
y_2 = taylor[ arg[4] * num_taylor_per_var + m + ell];
}
else y_2 = zero;
if( arg[1] & 8 )
{
y_3 = taylor[ arg[5] * num_taylor_per_var + m + ell];
}
else y_3 = zero;
z[m+ell] = CondExpOp(
CompareOp( arg[0] ),
y_0,
y_1,
y_2,
y_3
);
}
return;
}
inline void forward_cond_op_0(
size_t i_z ,
const addr_t* arg ,
size_t num_par ,
const Base* parameter ,
size_t nc_taylor ,
Base* taylor )
{ Base y_0, y_1, y_2, y_3;
Base* z;
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < static_cast<size_t> (CompareNe) );
CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );
CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 );
CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
if( arg[1] & 1 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
y_0 = taylor[ arg[2] * nc_taylor + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
y_0 = parameter[ arg[2] ];
}
if( arg[1] & 2 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
y_1 = taylor[ arg[3] * nc_taylor + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
y_1 = parameter[ arg[3] ];
}
if( arg[1] & 4 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
y_2 = taylor[ arg[4] * nc_taylor + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
y_2 = parameter[ arg[4] ];
}
if( arg[1] & 8 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
y_3 = taylor[ arg[5] * nc_taylor + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < num_par );
y_3 = parameter[ arg[5] ];
}
z = taylor + i_z * nc_taylor;
z[0] = CondExpOp(
CompareOp( arg[0] ),
y_0,
y_1,
y_2,
y_3
);
return;
}
void forward_cskip_op_0(
size_t i_z ,
const addr_t* arg ,
size_t num_par ,
const Base* parameter ,
size_t cap_order ,
Base* taylor ,
bool* cskip_op )
{
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < size_t(CompareNe) );
CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
Base left, right;
if( arg[1] & 1 )
{ // If variable arg[2] <= i_z, it has already been computed,
// but it will be skipped for higher orders.
CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= i_z );
left = taylor[ size_t(arg[2]) * cap_order + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
left = parameter[ arg[2] ];
}
if( arg[1] & 2 )
{ // If variable arg[3] <= i_z, it has already been computed,
// but it will be skipped for higher orders.
CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) <= i_z );
right = taylor[ size_t(arg[3]) * cap_order + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
right = parameter[ arg[3] ];
}
bool ok_to_skip = IdenticalCon(left) & IdenticalCon(right);
if( ! ok_to_skip )
return;
// initialize to avoid compiler warning
bool true_case = false;
Base diff = left - right;
switch( CompareOp( arg[0] ) )
{
case CompareLt:
true_case = LessThanZero(diff);
break;
case CompareLe:
true_case = LessThanOrZero(diff);
break;
case CompareEq:
true_case = IdenticalZero(diff);
break;
case CompareGe:
true_case = GreaterThanOrZero(diff);
break;
case CompareGt:
true_case = GreaterThanZero(diff);
break;
case CompareNe:
true_case = ! IdenticalZero(diff);
break;
default:
CPPAD_ASSERT_UNKNOWN(false);
}
if( true_case )
{ for(addr_t i = 0; i < arg[4]; i++)
cskip_op[ arg[6+i] ] = true;
}
else
{ for(addr_t i = 0; i < arg[5]; i++)
cskip_op[ arg[6+arg[4]+i] ] = true;
}
return;
}
void Vessel::sort()
{
std::sort(WordData.begin(), WordData.end(), CompareOp());
}
inline void reverse_cond_op(
size_t d ,
size_t i_z ,
const addr_t* arg ,
size_t num_par ,
const Base* parameter ,
size_t nc_taylor ,
const Base* taylor ,
size_t nc_partial ,
Base* partial )
{ Base y_0, y_1;
Base zero(0);
Base* pz;
Base* py_2;
Base* py_3;
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < static_cast<size_t> (CompareNe) );
CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );
CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 );
CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
pz = partial + i_z * nc_partial + 0;
if( arg[1] & 1 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
y_0 = taylor[ arg[2] * nc_taylor + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
y_0 = parameter[ arg[2] ];
}
if( arg[1] & 2 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
y_1 = taylor[ arg[3] * nc_taylor + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
y_1 = parameter[ arg[3] ];
}
if( arg[1] & 4 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
py_2 = partial + arg[4] * nc_partial;
size_t j = d + 1;
while(j--)
{ py_2[j] += CondExpOp(
CompareOp( arg[0] ),
y_0,
y_1,
pz[j],
zero
);
}
}
if( arg[1] & 8 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
py_3 = partial + arg[5] * nc_partial;
size_t j = d + 1;
while(j--)
{ py_3[j] += CondExpOp(
CompareOp( arg[0] ),
y_0,
y_1,
zero,
pz[j]
);
}
}
return;
}
inline void forward_cond_op(
size_t p ,
size_t q ,
size_t i_z ,
const addr_t* arg ,
size_t num_par ,
const Base* parameter ,
size_t cap_order ,
Base* taylor )
{ Base y_0, y_1, y_2, y_3;
Base zero(0);
Base* z = taylor + i_z * cap_order;
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < static_cast<size_t> (CompareNe) );
CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );
CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 );
CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
if( arg[1] & 1 )
{
y_0 = taylor[ arg[2] * cap_order + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
y_0 = parameter[ arg[2] ];
}
if( arg[1] & 2 )
{
y_1 = taylor[ arg[3] * cap_order + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
y_1 = parameter[ arg[3] ];
}
if( p == 0 )
{ if( arg[1] & 4 )
{
y_2 = taylor[ arg[4] * cap_order + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
y_2 = parameter[ arg[4] ];
}
if( arg[1] & 8 )
{
y_3 = taylor[ arg[5] * cap_order + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < num_par );
y_3 = parameter[ arg[5] ];
}
z[0] = CondExpOp(
CompareOp( arg[0] ),
y_0,
y_1,
y_2,
y_3
);
p++;
}
for(size_t d = p; d <= q; d++)
{ if( arg[1] & 4 )
{
y_2 = taylor[ arg[4] * cap_order + d];
}
else y_2 = zero;
if( arg[1] & 8 )
{
y_3 = taylor[ arg[5] * cap_order + d];
}
else y_3 = zero;
z[d] = CondExpOp(
CompareOp( arg[0] ),
y_0,
y_1,
y_2,
y_3
);
}
return;
}
inline void forward_cond_op(
size_t d ,
size_t i_z ,
const addr_t* arg ,
size_t num_par ,
const Base* parameter ,
size_t nc_taylor ,
Base* taylor )
{ Base y_0, y_1, y_2, y_3;
Base zero(0);
Base* z;
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < static_cast<size_t> (CompareNe) );
CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );
CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 );
CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
if( arg[1] & 1 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
y_0 = taylor[ arg[2] * nc_taylor + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
y_0 = parameter[ arg[2] ];
}
if( arg[1] & 2 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
y_1 = taylor[ arg[3] * nc_taylor + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
y_1 = parameter[ arg[3] ];
}
# if CPPAD_USE_FORWARD0SWEEP
CPPAD_ASSERT_UNKNOWN( d > 0 );
# else
if( d == 0 )
{ if( arg[1] & 4 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
y_2 = taylor[ arg[4] * nc_taylor + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
y_2 = parameter[ arg[4] ];
}
if( arg[1] & 8 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
y_3 = taylor[ arg[5] * nc_taylor + 0 ];
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < num_par );
y_3 = parameter[ arg[5] ];
}
}
else
# endif
{ if( arg[1] & 4 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
y_2 = taylor[ arg[4] * nc_taylor + d];
}
else y_2 = zero;
if( arg[1] & 8 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
y_3 = taylor[ arg[5] * nc_taylor + d];
}
else y_3 = zero;
}
z = taylor + i_z * nc_taylor;
z[d] = CondExpOp(
CompareOp( arg[0] ),
y_0,
y_1,
y_2,
y_3
);
return;
}
