Stl Quick Reference Card (Page 8 of 8) in pdf

STL Quick Reference – Version 1.29

April 20, 2007

[A4]

7.3

Compare Object Sort

7.7

Iterator and Binder

7.8

Iterator Traits

(-0.809,-0.588)

(0.309,-0.951)

class ModN {

// self-refering int

template <class Itr>

public:

class Interator : public

typename iterator_traits<Itr>::value_type

7.5

Binary Search

ModN(unsigned m): _m(m) {}

iterator<input_iterator_tag, int, size_t> {

mid(Itr b, Itr e, input_iterator_tag) {

bool operator ()(const unsigned& u0,

int

_n;

cout << "mid(general):\n";

// first 5 Fibonacci

const unsigned& u1)

public:

Itr bm(b);

bool

next = false;

static int fb5[] = {1, 1, 2, 3, 5};

{return ((u0 % _m) < (u1 % _m));}

Interator(int n=0) : _n(n) {}

for ( ;

b != e;

++b, next = !next) {

for (int n = 0; n <= 6; ++n) {

private: unsigned _m;

int operator*() const {return _n;}

if (next) { ++bm; }

pair<int*,int*> p =

}; // ModN

Interator& operator++() {

}

equal_range(fb5, fb5+5, n);

++_n;

return *this;

}

return *bm;

cout<< n <<":["<< p.first-fb5 <<’,’

ostream_iterator<unsigned> oi(cout, " ");

Interator

operator++(int) {

} // mid<input>

<< p.second-fb5 <<") ";

unsigned

q[6];

Interator t(*this);

if (n==3 || n==6) cout << endl;

for (int n=6, i=n-1;

i>=0;

n=i--)

++_n;

return t;}

template <class Itr>

}

q[i] = n*n*n*n;

}; // Interator

typename iterator_traits<Itr>::value_type

cout<<"four-powers:

bool operator==(const Interator& i0,

mid(Itr b, Itr e,

copy(q + 0, q + 6, oi);

const Interator& i1)

random_access_iterator_tag) {

0:[0,0) 1:[0,2) 2:[2,3) 3:[3,4)

for (unsigned b=10; b<=1000; b *= 10) {

{ return (*i0 == *i1); }

cout << "mid(random):\n";

4:[4,4) 5:[4,5) 6:[5,5)

vector<unsigned>

sq(q + 0, q + 6);

bool operator!=(const Interator& i0,

Itr bm = b + (e - b)/2;

sort(sq.begin(), sq.end(), ModN(b));

const Interator& i1)

return *bm;

7.6

Transform & Numeric

cout<<endl<<"sort mod "<<setw(4)<<b<<": ";

{ return !(i0 == i1); }

} // mid<random>

copy(sq.begin(), sq.end(), oi);

} cout << endl;

template <class T>

struct Fermat: public

template <class Itr>

class AbsPwr : public unary_function<T, T> {

binary_function<int, int, bool> {

typename iterator_traits<Itr>::value_type

public:

Fermat(int p=2) : n(p) {}

mid(Itr b, Itr e) {

AbsPwr(T p): _p(p) {}

int n;

typename

four-powers:

1 16 81 256 625 1296

T operator()(const T& x) const

int nPower(int t) const { // t^n

iterator_traits<Itr>::iterator_category t;

sort mod

10: 1 81 625 16 256 1296

{ return pow(fabs(x), _p); }

int i=n, tn=1;

mid(b, e, t);

sort mod

100: 1 16 625 256 81 1296

private: T _p;

while (i--) tn *= t;

} // mid

sort mod 1000: 1 16 81 256 1296 625

}; // AbsPwr

return tn; } // nPower

int nRoot(int t) const {

template <class Ctr>

template<typename InpIter> float

return (int)pow(t +.1, 1./n); }

void fillmid(Ctr& ctr) {

7.4

Stream Iterators

normNP(InpIter xb, InpIter xe, float p) {

int xNyN(int x, int y) const

{

static int perfects[5] =

vector<float>

vf;

return(nPower(x)+nPower(y)); }

{6, 14, 496, 8128, 33550336},

void unitRoots(int n) {

transform(xb, xe, back_inserter(vf),

bool operator()(int x, int y) const {

*pb = &perfects[0];

cout << "unit " << n << "-roots:" << endl;

AbsPwr<float>(p > 0. ? p : 1.));

int zn = xNyN(x, y), z = nRoot(zn);

ctr.insert(ctr.end(), pb, pb + 5);

vector<complex<float> > roots;

return( (p > 0.)

return(zn == nPower(z));

}

int m = mid(ctr.begin(), ctr.end());

float

arg = 2.*M_PI/(float)n;

? pow(accumulate(vf.begin(), vf.end(), 0.),

}; // Fermat

cout << "mid=" << m << "\n";

complex<float> r, r1 = polar((float)1., arg);

1./p)

} // fillmid

for (r = r1; --n;

r *= r1)

for (int n=2; n<=Mp; ++n) {

: *(max_element(vf.begin(), vf.end())));

roots.push_back(r);

Fermat fermat(n);

} // normNP

list<int> l;

vector<int> v;

copy(roots.begin(), roots.end(),

for (int x=1; x<Mx; ++x) {

fillmid(l);

fillmid(v);

ostream_iterator<complex<float> >(cout,

binder1st<Fermat>

float distNP(const float* x, const float* y,

"\n"));

fx = bind1st(fermat, x);

unsigned n, float p) {

} // unitRoots

Interator iy(x), iyEnd(My);

vector<float>

diff;

while ((iy = find_if(++iy, iyEnd, fx))

mid(general):

transform(x, x + n, y, back_inserter(diff),

{ofstream o("primes.txt"); o << "2 3 5";}

!= iyEnd) {

mid=496

minus<float>());

ifstream pream("primes.txt");

int

y = *iy,

mid(random):

return normNP(diff.begin(), diff.end(), p);

vector<int> p;

z = fermat.nRoot(fermat.xNyN(x, y));

mid=496

} // distNP

istream_iterator<int>

priter(pream);

cout << x << ’^’ << n << " + "

istream_iterator<int>

eosi;

float

x3y4[] = {3., 4.,

0.};

<< y << ’^’ << n << " = "

copy(priter, eosi, back_inserter(p));

float

z12[]

= {0., 0., 12.};

<< z << ’^’ << n << endl;

for_each(p.begin(), p.end(), unitRoots);

float

p[] = {1., 2., M_PI, 0.};

if (n>2)

for (int i=0; i<4;

++i) {

cout << "Fermat is wrong!" << endl;

float d = distNP(x3y4, z12, 3, p[i]);

}

cout << "d_{" << p[i] << "}=" << d << endl;

}

unit 2-roots:

}

(-1.000,-0.000)

unit 3-roots:

(-0.500,0.866)

d_{1}=19

(-0.500,-0.866)

3^2 + 4^2 = 5^2

d_{2}=13

unit 5-roots:

5^2 + 12^2 = 13^2

d_{3.14159}=12.1676

(0.309,0.951)

6^2 + 8^2 = 10^2

d_{0}=12

(-0.809,0.588)

7^2 + 24^2 = 25^2

Yotam Medini c 1998-2007

Stl Quick Reference Card Page 8

Related Articles

Related forms

Related Categories