本文整理汇总了C++中Vector_set类的典型用法代码示例。如果您正苦于以下问题：C++ Vector_set类的具体用法？C++ Vector_set怎么用？C++ Vector_set使用的例子？那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了Vector_set类的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: forward_sparse_jacobian_cond_op
inline void forward_sparse_jacobian_cond_op(
bool dependency ,
size_t i_z ,
const addr_t* arg ,
size_t num_par ,
Vector_set& sparsity )
{
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 );
# ifndef NDEBUG
size_t k = 1;
for( size_t j = 0; j < 4; j++)
{ if( ! ( arg[1] & k ) )
CPPAD_ASSERT_UNKNOWN( size_t(arg[2+j]) < num_par );
k *= 2;
}
# endif
sparsity.clear(i_z);
if( dependency )
{ if( arg[1] & 1 )
sparsity.binary_union(i_z, i_z, arg[2], sparsity);
if( arg[1] & 2 )
sparsity.binary_union(i_z, i_z, arg[3], sparsity);
}
if( arg[1] & 4 )
sparsity.binary_union(i_z, i_z, arg[4], sparsity);
if( arg[1] & 8 )
sparsity.binary_union(i_z, i_z, arg[5], sparsity);
return;
}示例2: reverse_sparse_hessian_div_op
inline void reverse_sparse_hessian_div_op(
size_t i_z ,
const addr_t* arg ,
bool* jac_reverse ,
Vector_set& for_jac_sparsity ,
Vector_set& rev_hes_sparsity )
{
// check assumptions
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
rev_hes_sparsity.binary_union(arg[0], arg[0], i_z, rev_hes_sparsity);
rev_hes_sparsity.binary_union(arg[1], arg[1], i_z, rev_hes_sparsity);
if( jac_reverse[i_z] )
{ rev_hes_sparsity.binary_union(
arg[0], arg[0], arg[1], for_jac_sparsity);
rev_hes_sparsity.binary_union(
arg[1], arg[1], arg[0], for_jac_sparsity);
rev_hes_sparsity.binary_union(
arg[1], arg[1], arg[1], for_jac_sparsity);
}
jac_reverse[arg[0]] |= jac_reverse[i_z];
jac_reverse[arg[1]] |= jac_reverse[i_z];
return;
} 示例3: reverse_sparse_hessian_cond_op
inline void reverse_sparse_hessian_cond_op(
size_t i_z ,
const addr_t* arg ,
size_t num_par ,
bool* jac_reverse ,
Vector_set& hes_sparsity )
{
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 );
# ifndef NDEBUG
size_t k = 1;
for( size_t j = 0; j < 4; j++)
{ if( ! ( arg[1] & k ) )
CPPAD_ASSERT_UNKNOWN( size_t(arg[2+j]) < num_par );
k *= 2;
}
# endif
if( arg[1] & 4 )
{
hes_sparsity.binary_union(arg[4], arg[4], i_z, hes_sparsity);
jac_reverse[ arg[4] ] |= jac_reverse[i_z];
}
if( arg[1] & 8 )
{
hes_sparsity.binary_union(arg[5], arg[5], i_z, hes_sparsity);
jac_reverse[ arg[5] ] |= jac_reverse[i_z];
}
return;
}示例4: forward_sparse_hessian_mul_op
inline void forward_sparse_hessian_mul_op(
const addr_t* arg ,
Vector_set& for_jac_sparsity ,
Vector_set& for_hes_sparsity )
{ // --------------------------------------------------
// set of independent variables that v0 depends on
for_jac_sparsity.begin(arg[0]);
// loop over dependent variables with non-zero partial
size_t i_x = for_jac_sparsity.next_element();
while( i_x < for_jac_sparsity.end() )
{ // N(i_x) = N(i_x) union L(v1)
for_hes_sparsity.binary_union(i_x, i_x, arg[1], for_jac_sparsity);
i_x = for_jac_sparsity.next_element();
}
// --------------------------------------------------
// set of independent variables that v1 depends on
for_jac_sparsity.begin(arg[1]);
// loop over dependent variables with non-zero partial
i_x = for_jac_sparsity.next_element();
while( i_x < for_jac_sparsity.end() )
{ // N(i_x) = N(i_x) union L(v0)
for_hes_sparsity.binary_union(i_x, i_x, arg[0], for_jac_sparsity);
i_x = for_jac_sparsity.next_element();
}
return;
}示例5: reverse_sparse_hessian_pow_op
inline void reverse_sparse_hessian_pow_op(
size_t i_z ,
const addr_t* arg ,
bool* jac_reverse ,
Vector_set& for_jac_sparsity ,
Vector_set& rev_hes_sparsity )
{
// check assumptions
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
rev_hes_sparsity.binary_union(arg[0], arg[0], i_z, rev_hes_sparsity);
rev_hes_sparsity.binary_union(arg[1], arg[1], i_z, rev_hes_sparsity);
if( jac_reverse[i_z] )
{
rev_hes_sparsity.binary_union(
arg[0], arg[0], arg[0], for_jac_sparsity);
rev_hes_sparsity.binary_union(
arg[0], arg[0], arg[1], for_jac_sparsity);
rev_hes_sparsity.binary_union(
arg[1], arg[1], arg[0], for_jac_sparsity);
rev_hes_sparsity.binary_union(
arg[1], arg[1], arg[1], for_jac_sparsity);
}
// I cannot think of a case where this is necessary, but it including
// it makes it like the other cases.
jac_reverse[arg[0]] |= jac_reverse[i_z];
jac_reverse[arg[1]] |= jac_reverse[i_z];
return;
} 示例6: reverse_sparse_jacobian_cond_op
inline void reverse_sparse_jacobian_cond_op(
bool nz_compare ,
size_t i_z ,
const addr_t* arg ,
size_t num_par ,
Vector_set& sparsity )
{
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 );
# ifndef NDEBUG
if( arg[1] & 1 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
}
if( arg[1] & 2 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
}
if( ! ( arg[1] & 4 ) )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
}
if( ! ( arg[1] & 8 ) )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < num_par );
}
# endif
if( nz_compare )
{ if( arg[1] & 1 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
sparsity.binary_union(arg[2], arg[2], i_z, sparsity);
}
if( arg[1] & 2 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
sparsity.binary_union(arg[3], arg[3], i_z, sparsity);
}
}
// --------------------------------------------------------------------
if( arg[1] & 4 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
sparsity.binary_union(arg[4], arg[4], i_z, sparsity);
}
if( arg[1] & 8 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
sparsity.binary_union(arg[5], arg[5], i_z, sparsity);
}
return;
}示例7: forward_sparse_jacobian_cond_op
inline void forward_sparse_jacobian_cond_op(
size_t i_z ,
const addr_t* arg ,
size_t num_par ,
Vector_set& sparsity )
{
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 );
# ifndef NDEBUG
if( arg[1] & 1 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
}
if( arg[1] & 2 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
}
# endif
if( arg[1] & 4 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
if( arg[1] & 8 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
sparsity.binary_union(i_z, arg[4], arg[5], sparsity);
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < num_par );
sparsity.assignment(i_z, arg[4], sparsity);
}
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
if( arg[1] & 8 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
sparsity.assignment(i_z, arg[5], sparsity);
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < num_par );
sparsity.clear(i_z);
}
}
return;
}示例8: reverse_sparse_hessian_cond_op
inline void reverse_sparse_hessian_cond_op(
size_t i_z ,
const addr_t* arg ,
size_t num_par ,
bool* jac_reverse ,
Vector_set& hes_sparsity )
{
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 );
# ifndef NDEBUG
if( arg[1] & 1 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
}
if( arg[1] & 2 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
}
else
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
}
if( ! ( arg[1] & 4 ) )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
}
if( ! ( arg[1] & 8 ) )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < num_par );
}
# endif
if( arg[1] & 4 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
hes_sparsity.binary_union(arg[4], arg[4], i_z, hes_sparsity);
jac_reverse[ arg[4] ] |= jac_reverse[i_z];
}
if( arg[1] & 8 )
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
hes_sparsity.binary_union(arg[5], arg[5], i_z, hes_sparsity);
jac_reverse[ arg[5] ] |= jac_reverse[i_z];
}
return;
}示例9: reverse_sparse_hessian_nonlinear_unary_op
inline void reverse_sparse_hessian_nonlinear_unary_op(
size_t i_z ,
size_t i_x ,
bool* rev_jacobian ,
const Vector_set& for_jac_sparsity ,
Vector_set& rev_hes_sparsity )
{
// check assumptions
CPPAD_ASSERT_UNKNOWN( i_x < i_z );
rev_hes_sparsity.binary_union(i_x, i_x, i_z, rev_hes_sparsity);
if( rev_jacobian[i_z] )
rev_hes_sparsity.binary_union(i_x, i_x, i_x, for_jac_sparsity);
rev_jacobian[i_x] |= rev_jacobian[i_z];
return;
}示例10: forward_sparse_jacobian_unary_op
inline void forward_sparse_jacobian_unary_op(
size_t i_z ,
size_t i_x ,
Vector_set& sparsity )
{
// check assumptions
CPPAD_ASSERT_UNKNOWN( i_x < i_z );
sparsity.assignment(i_z, i_x, sparsity);
}示例11: forward_sparse_jacobian_csum_op
inline void forward_sparse_jacobian_csum_op(
size_t i_z ,
const addr_t* arg ,
Vector_set& sparsity )
{ sparsity.clear(i_z);
size_t i, j;
i = arg[0] + arg[1];
j = 2;
while(i--)
{ CPPAD_ASSERT_UNKNOWN( size_t(arg[j+1]) < i_z );
sparsity.binary_union(
i_z , // index in sparsity for result
i_z , // index in sparsity for left operand
arg[++j] , // index for right operand
sparsity // sparsity vector for right operand
);
}
}示例12: forward_sparse_hessian_nonlinear_unary_op
inline void forward_sparse_hessian_nonlinear_unary_op(
size_t i_v ,
const Vector_set& for_jac_sparsity ,
Vector_set& for_hes_sparsity )
{
// set of independent variables that v depends on
typename Vector_set::const_iterator itr(for_jac_sparsity, i_v);
// next independent variables that v depends on
size_t i_x = *itr;
// loop over dependent variables with non-zero partial
while( i_x < for_jac_sparsity.end() )
{ // N(i_x) = N(i_x) union L(i_v)
for_hes_sparsity.binary_union(i_x, i_x, i_v, for_jac_sparsity);
i_x = *(++itr);
}
return;
}示例13: reverse_sparse_jacobian_load_op
inline void reverse_sparse_jacobian_load_op(
OpCode op ,
size_t i_z ,
const addr_t* arg ,
size_t num_combined ,
const size_t* combined ,
Vector_set& var_sparsity ,
Vector_set& vecad_sparsity )
{
CPPAD_ASSERT_UNKNOWN( NumArg(op) == 3 );
CPPAD_ASSERT_UNKNOWN( NumRes(op) == 1 );
CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_combined );
size_t i_v = combined[ arg[0] - 1 ];
CPPAD_ASSERT_UNKNOWN( i_v < vecad_sparsity.n_set() );
vecad_sparsity.binary_union(i_v, i_v, i_z, var_sparsity);
return;
}示例14: forward_sparse_store_op
inline void forward_sparse_store_op(
OpCode op ,
const addr_t* arg ,
size_t num_combined ,
const size_t* combined ,
Vector_set& var_sparsity ,
Vector_set& vecad_sparsity )
{
CPPAD_ASSERT_UNKNOWN( NumArg(op) == 3 );
CPPAD_ASSERT_UNKNOWN( NumRes(op) == 0 );
CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_combined );
size_t i_v = combined[ arg[0] - 1 ];
CPPAD_ASSERT_UNKNOWN( i_v < vecad_sparsity.n_set() );
CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < var_sparsity.n_set() );
vecad_sparsity.binary_union(i_v, i_v, arg[2], var_sparsity);
return;
}示例15: forward_sparse_load_op
inline void forward_sparse_load_op(
OpCode op ,
size_t i_z ,
const addr_t* arg ,
size_t num_combined ,
const size_t* combined ,
Vector_set& var_sparsity ,
Vector_set& vecad_sparsity )
{
CPPAD_ASSERT_UNKNOWN( NumArg(op) == 3 );
CPPAD_ASSERT_UNKNOWN( NumRes(op) == 1 );
CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_combined );
size_t i_v = combined[ arg[0] - 1 ];
CPPAD_ASSERT_UNKNOWN( i_v < vecad_sparsity.n_set() );
var_sparsity.assignment(i_z, i_v, vecad_sparsity);
return;
}