std::vector<int> demoAccessingMemberFromLambda() {
std::vector<int> v;
generate_n(back_inserter(v),10,[=] {
return ++x, x*x; // member x can be changed
});
return v;
}
int main(int argc, char** argv)
{
//Generator obj(4);
std::deque<int> mydeque(5);
std::generate(mydeque.begin(), mydeque.end(), Generator(4));
std::ostream_iterator<int> out_it (std::cout, "; ");
copy (mydeque.begin(), mydeque.end(), out_it);
std::cout << std::endl;
std::vector<int> s1(5);
copy(mydeque.begin(), mydeque.end(), s1.begin());
copy (s1.begin(), s1.end(), out_it);
std::cout << std::endl;
mydeque.clear();
std::vector<int> s2(10);
std::generate(s2.begin(), s2.end(), Generator(2));
copy (s2.begin(), s2.end(), out_it);
std::cout << std::endl;
std::vector<int> s3;
//generate_n
std::back_insert_iterator<std::vector<int> > it (s3);
generate_n(it, 6, Generator(3));
copy (s3.begin(), s3.end(), out_it);
std::cout << std::endl;
std::cout << "s1 contenu dans s2 : " << (includes(s1.begin(), s1.end(), s2.begin(), s2.end()) ? "true" : "false") << std::endl;
return 0;
}
std::string
rand_alnum_str (std::string::size_type sz)
{
std::string s;
s.reserve (sz);
generate_n (std::back_inserter(s), sz, rand_alnum);
return s;
}
/*Generate multifactorials to 9
Nigel_Galloway
November 14th., 2012.
*/
int main(void) {
for (int g = 1; g < 10; g++) {
int v[11], n=0;
generate_n(std::ostream_iterator<int>(std::cout, " "), 10, [&]{n++; return v[n]=(g<n)? v[n-g]*n : n;});
std::cout << std::endl;
}
return 0;
}
void genPrimes(){
generate_n (primes, LIMIT, stepUp);
for (int p = 2; p*p <= LIMIT; p++){
for (int i = 2; i <= LIMIT / p; i++){
primes[(i*p)-2] = 0;
}
}
}
std::vector<int> vectorwithsquares_lambda(){
std::vector<int> v;
int x{}; // memory for lambda below
generate_n(std::back_inserter(v),10,[&x]{
++x; return x*x;
});
return v;
}
std::vector<int> vectorwithsquares_mutable_lambda(){
std::vector<int> v;
int x{}; // memory for lambda below
generate_n(std::back_inserter(v),10,[x]() mutable {
return ++x , x*x; // mutable allows change
});
return v;
}
std::wstring wrandomstr(std::wstring::size_type sz) {
std::wstring s;
s.reserve(sz);
//need to have different seeds to avoid DDOS attack
unsigned int seed = static_cast<unsigned int>(
qi::SystemClock::now().time_since_epoch().count()/1000);
srand(seed);
generate_n(std::back_inserter(s), sz, rand_alnum);
return s;
}
std::string generate_random_string (size_t length) {
auto generate_random_char = [] () -> char {
static const char Charset[] = "0123456789"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";
const size_t max_index = (sizeof(Charset) - 1);
return Charset[rand() % max_index];
};
std::string str(length, 0);
generate_n(str.begin(), length, generate_random_char);
return str;
}
int main() {
std::mt19937 mt;
std::uniform_int_distribution<> dist;
std::vector<int> v;
generate_n(back_inserter(v), 10000, bind(dist,ref(mt)));
nth_element(begin(v), begin(v) + 10, end(v));
v.erase(begin(v) + 10, end(v));
std::cout << "The ten smallest values out of 10,000 values generated: ";
copy(begin(v), end(v), std::ostream_iterator<int>(std::cout, " "));
}
int main()
{
list< int, allocator > ilist( 10 );
void (*pfi)( int ) = print_elements;
generate_n( ilist.begin(), ilist.size(), even_by_twos() );
// generates:
// generate_n with even_by_twos():
// 2 4 6 8 10 12 14 16 18 20
cout << "generate_n with even_by_twos():\n";
for_each( ilist.begin(), ilist.end(), pfi ); cout << "\n";
generate_n( ilist.begin(), ilist.size(), even_by_twos( 100 ) );
// generates:
// generate_n with even_by_twos( 100 ):
// 102 104 106 108 110 112 114 116 118 120
cout << "generate_n with even_by_twos( 100 ):\n";
for_each( ilist.begin(), ilist.end(), pfi );
}
std::vector<std::vector<Word>> prepareLines(std::vector<std::vector<Word>> lines)
{
std::vector<std::vector<Word>> preparedLines {};
for_each(lines.begin(), lines.end(), [&preparedLines](std::vector<Word> line) {
generate_n(std::back_inserter(preparedLines), line.size(), [&line] {
std::rotate(line.begin(), line.begin() + 1, line.end());
return line;
});
});
std::sort(preparedLines.begin(), preparedLines.end());
return preparedLines;
}
vector<double> MBO_Object::LevyFlight(int StepSzie, int dim)
{
// Allocate matrix for solutions
vector<double> delataX(dim);
vector<double> fx(StepSzie);
// Loop over each dimension
for (int i = 0; i < dim; ++i)
{
generate_n(fx.begin(), fx.size(),
[=]()
{
return tan(pi*random(0.0, 1.0));
});
delataX[i] = sum(fx);
}
return delataX;
}
void generate_find_demo(){
std::vector<int> v{};
srand(time(0));
generate_n(back_inserter(v),100,[]{return rand()%100;});
auto zero_it=find(begin(v),end(v),0);
if (zero_it == end(v)){
std::cout << "\nno zero found \n";
} else {
std::cout << "\nfound zero at position:"
<< distance(begin(v),zero_it)<<'\n';
}
auto odd=find_if(begin(v),end(v),[](auto x){return x%2;});
if (odd == end(v)){
std::cout << "no odd number found\n";
} else {
std::cout << "found odd number:" << *odd
<< "\nat position:"<<distance(begin(v),odd)<< '\n';
}
std::cout << count(begin(v),end(v),42)<<" times 42\n";
std::cout << count_if(begin(v),end(v),
[](auto x){return 0==(x%2);})<<" even numbers\n";
}
int main(){
std::vector<X> v; // geht nicht: v(10) -> braucht X::X()
generate_n(std::back_inserter(v),10,Initializer(100));
copy(v.begin(),v.end(),std::ostream_iterator<X>(std::cout,", "));
}
std::string rand_num_str(std::string::size_type size) {
std::string s;
s.reserve(size);
generate_n(std::back_inserter(s), size, rand_num);
return s;
}
std::vector<T> gen_n(size_t count, Generator generator) {
std::vector<T> result;
result.reserve(count);
generate_n(std::back_insert_iterator<std::vector<T> >(result), count, generator);
return result;
}
/** the correlation of timeserieses in range 0..scope */
inline TimeSeriesDigit correlation(const TimeSeriesDigit& ts1, const TimeSeriesDigit& ts2, int scope) {
TimeSeriesDigit out;
CalcCorrelationFunctor gen(ts1, ts2, ts1.getAvg(), ts2.getAvg(), ts1.getSigma(), ts2.getSigma() );
generate_n(back_inserter(out), scope, gen );
return out;
}
int main(void)
{
Distribution* rng;
Pstd_mem ptr;
generate_n(rng->*ptr); // { dg-error "non-static member" }
}
