/* * 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)); }