/*
* Generates a random directed weighted graph with N nodes and K edges. Weights
* are chosen uniformly between wmin and wmax. No edges are placed on the main
* diagonal.
*/
MATRIX_T* BCT_NAMESPACE::makerandCIJ_wd(int N, int K, FP_T wmin, FP_T wmax) {
gsl_rng* rng = get_rng();
VECTOR_T* w = VECTOR_ID(alloc)(K);
for (int i = 0; i < K; i++) {
VECTOR_ID(set)(w, i, gsl_rng_uniform(rng) * (wmax - wmin) + wmin);
}
// ind = ~eye(N);
MATRIX_T* eye_N = eye(N);
MATRIX_T* ind = logical_not(eye_N);
MATRIX_ID(free)(eye_N);
// i = find(ind);
VECTOR_T* i = find(ind);
MATRIX_ID(free)(ind);
// rp = randperm(length(i));
gsl_permutation* rp = randperm(length(i));
// irp = i(rp);
VECTOR_T* irp = permute(rp, i);
gsl_permutation_free(rp);
VECTOR_ID(free)(i);
// CIJ = zeros(N);
MATRIX_T* CIJ = zeros(N);
// CIJ(irp(1:K)) = w;
VECTOR_ID(view) irp_subv = VECTOR_ID(subvector)(irp, 0, K);
ordinal_index_assign(CIJ, &irp_subv.vector, w);
VECTOR_ID(free)(w);
VECTOR_ID(free)(irp);
return CIJ;
}
/*
* Generates a random directed binary graph with N nodes and K edges. No edges
* are placed on the main diagonal.
*/
MATRIX_T* BCT_NAMESPACE::makerandCIJ_bd(int N, int K) {
// ind = ~eye(N);
MATRIX_T* eye_N = eye(N);
MATRIX_T* ind = logical_not(eye_N);
MATRIX_ID(free)(eye_N);
// i = find(ind);
VECTOR_T* i = find(ind);
MATRIX_ID(free)(ind);
// rp = randperm(length(i));
gsl_permutation* rp = randperm(length(i));
// irp = i(rp);
VECTOR_T* irp = permute(rp, i);
gsl_permutation_free(rp);
VECTOR_ID(free)(i);
// CIJ = zeros(N);
MATRIX_T* CIJ = zeros(N);
// CIJ(irp(1:K)) = 1;
VECTOR_ID(view) irp_subv = VECTOR_ID(subvector)(irp, 0, K);
ordinal_index_assign(CIJ, &irp_subv.vector, 1.0);
VECTOR_ID(free)(irp);
return CIJ;
}
Container keep_if(internal::reuse_container_t, Pred pred, Container&& xs)
{
internal::check_unary_predicate_for_container<Pred, Container>();
xs.erase(std::remove_if(
std::begin(xs), std::end(xs), logical_not(pred)), std::end(xs));
return std::forward<Container>(xs);
}
void Parser::executeAction(int production) try {
if (d_token__ != _UNDETERMINED_)
pushToken__(d_token__); // save an already available token
// $insert defaultactionreturn
// save default non-nested block $$
if (int size = s_productionInfo[production].d_size)
d_val__ = d_vsp__[1 - size];
switch (production) {
// $insert actioncases
case 1:
#line 43 "parser.yy"
{
d_val__.get<Tag__::basic>() = d_vsp__[0].data<Tag__::basic>();
res = d_val__.get<Tag__::basic>();
} break;
case 2:
#line 51 "parser.yy"
{
d_val__.get<Tag__::basic>() = add(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>());
} break;
case 3:
#line 54 "parser.yy"
{
d_val__.get<Tag__::basic>() = sub(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>());
} break;
case 4:
#line 57 "parser.yy"
{
d_val__.get<Tag__::basic>() = mul(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>());
} break;
case 5:
#line 60 "parser.yy"
{
d_val__.get<Tag__::basic>() = div(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>());
} break;
case 6:
#line 63 "parser.yy"
{
auto tup = parse_implicit_mul(d_vsp__[-2].data<Tag__::string>());
if (neq(*std::get<1>(tup), *one)) {
d_val__.get<Tag__::basic>() = mul(
std::get<0>(tup),
pow(std::get<1>(tup), d_vsp__[0].data<Tag__::basic>()));
} else {
d_val__.get<Tag__::basic>()
= pow(std::get<0>(tup), d_vsp__[0].data<Tag__::basic>());
}
} break;
case 7:
#line 73 "parser.yy"
{
d_val__.get<Tag__::basic>() = pow(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>());
} break;
case 8:
#line 76 "parser.yy"
{
d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(
Lt(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>()));
} break;
case 9:
#line 79 "parser.yy"
{
d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(
Gt(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>()));
} break;
case 10:
#line 82 "parser.yy"
{
d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(
Le(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>()));
} break;
case 11:
#line 85 "parser.yy"
{
d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(
Ge(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>()));
} break;
case 12:
#line 88 "parser.yy"
{
d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(
Eq(d_vsp__[-2].data<Tag__::basic>(),
d_vsp__[0].data<Tag__::basic>()));
} break;
case 13:
#line 91 "parser.yy"
{
set_boolean s;
s.insert(rcp_static_cast<const Boolean>(
d_vsp__[-2].data<Tag__::basic>()));
s.insert(rcp_static_cast<const Boolean>(
d_vsp__[0].data<Tag__::basic>()));
d_val__.get<Tag__::basic>()
= rcp_static_cast<const Basic>(logical_or(s));
} break;
case 14:
#line 99 "parser.yy"
{
set_boolean s;
s.insert(rcp_static_cast<const Boolean>(
d_vsp__[-2].data<Tag__::basic>()));
s.insert(rcp_static_cast<const Boolean>(
d_vsp__[0].data<Tag__::basic>()));
d_val__.get<Tag__::basic>()
= rcp_static_cast<const Basic>(logical_and(s));
} break;
case 15:
#line 107 "parser.yy"
{
vec_boolean s;
s.push_back(rcp_static_cast<const Boolean>(
d_vsp__[-2].data<Tag__::basic>()));
s.push_back(rcp_static_cast<const Boolean>(
d_vsp__[0].data<Tag__::basic>()));
d_val__.get<Tag__::basic>()
= rcp_static_cast<const Basic>(logical_xor(s));
} break;
case 16:
#line 115 "parser.yy"
{
d_val__.get<Tag__::basic>() = d_vsp__[-1].data<Tag__::basic>();
} break;
case 17:
#line 118 "parser.yy"
{
d_val__.get<Tag__::basic>() = neg(d_vsp__[0].data<Tag__::basic>());
} break;
case 18:
#line 121 "parser.yy"
{
d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(
logical_not(rcp_static_cast<const Boolean>(
d_vsp__[0].data<Tag__::basic>())));
} break;
case 19:
#line 124 "parser.yy"
{
d_val__.get<Tag__::basic>()
= rcp_static_cast<const Basic>(d_vsp__[0].data<Tag__::basic>());
} break;
case 20:
#line 129 "parser.yy"
{
d_val__.get<Tag__::basic>()
= parse_identifier(d_vsp__[0].data<Tag__::string>());
} break;
case 21:
#line 134 "parser.yy"
{
auto tup = parse_implicit_mul(d_vsp__[0].data<Tag__::string>());
d_val__.get<Tag__::basic>()
= mul(std::get<0>(tup), std::get<1>(tup));
} break;
case 22:
#line 140 "parser.yy"
{
d_val__.get<Tag__::basic>()
= parse_numeric(d_vsp__[0].data<Tag__::string>());
} break;
case 23:
#line 145 "parser.yy"
{
d_val__.get<Tag__::basic>() = d_vsp__[0].data<Tag__::basic>();
} break;
case 24:
#line 152 "parser.yy"
{
d_val__.get<Tag__::basic>()
= functionify(d_vsp__[-3].data<Tag__::string>(),
d_vsp__[-1].data<Tag__::basic_vec>());
} break;
case 25:
#line 160 "parser.yy"
{
d_val__.get<Tag__::basic_vec>()
= d_vsp__[-2].data<Tag__::basic_vec>();
d_val__.get<Tag__::basic_vec>().push_back(
d_vsp__[0].data<Tag__::basic>());
} break;
case 26:
#line 166 "parser.yy"
{
d_val__.get<Tag__::basic_vec>()
= vec_basic(1, d_vsp__[0].data<Tag__::basic>());
} break;
}
} catch (std::exception const &exc) {
exceptionHandler__(exc);
}
auto ord_eq_to_not_eq(Compare comp)
{
return logical_not(ord_eq_to_eq(comp));
}
ContainerOut split_words(const bool allowEmpty, const String& str)
{
return split_by(logical_not(is_letter_or_digit<String>), allowEmpty, str);
}
//! Assign cluster number
uvec labeltree(const mat& X, uvec conn)
{
uword n = X.n_rows;
uword nleaves = n + 1;
uvec T = ones<uvec>(n + 1);
// Each cut potentially yeild as additional cluster
uvec todo = ones<uvec>(n);
// Define cluster numbers for each side of each non-leaf node
umat clustlist = reshape(arma_ext::colon<uvec>(1, 2 * n), n, 2);
// Propagate cluster numbers down the tree
while (any(todo)) {
// Work on rows that are now split but not yet processed
// rows = find(todo & ~conn);
uvec rows = find(todo % logical_not(conn));
if (rows.empty()) break;
for (uword j = 0 ; j < 2 ; j++) { // 0: left, 1: right
uvec children = conv_to<uvec>::from(X.col(j)).elem(rows);
// Assign cluster number to child leaf node
uvec leaf = (children <= nleaves);
if (any(leaf)) {
uvec leafi = find(leaf);
#ifdef ARMA_EXT_USE_CPP11
std::for_each(leafi.begin(), leafi.end(), [&](uword index) {
#else
for (size_type i = 0 ; i < leafi.size() ; i++) {
uword index = leafi[i];
#endif
T[children[index] - 1] = clustlist.at(rows[index], j);
#ifdef ARMA_EXT_USE_CPP11
});
#else
}
#endif
}
// Also assign it to both children of any joined child non-leaf nodes
uvec joint = logical_not(leaf); // ~leaf
uvec jointi = find(joint);
joint(jointi) = conn(children(jointi) - nleaves - 1);
if (any(joint)) {
#ifdef ARMA_EXT_USE_CPP11
std::for_each(jointi.begin(), jointi.end(), [&](uword index) {
#else
for (size_type i = 0 ; i < jointi.size() ; i++) {
uword index = jointi[i];
#endif
uword clustnum = clustlist(rows(index), j);
uword childnum = children(index) - nleaves - 1;
clustlist.row(childnum).fill(clustnum);
conn(childnum) = 0;
#ifdef ARMA_EXT_USE_CPP11
});
#else
}
#endif
}
}
ContainerOut drop_if(Pred pred, Container&& xs)
{
return keep_if(logical_not(pred), std::forward<Container>(xs));
}
ContainerOut drop_by_idx(UnaryPredicate pred, Container&& xs)
{
internal::check_unary_predicate_for_type<UnaryPredicate, std::size_t>();
return keep_by_idx(logical_not(pred), std::forward<Container>(xs));
}
