Algoritmi.

Algoritmii acoper un domeniu larg de operaii generale asupra containerelor precum: traversare, sortare, cutare,
inserare sau tergere de elemente.
Algoritmii sunt funcii generice, care se refer la containere prin intermediul iteratorilor. Tipurile iteratorilor folosii
de un algoritm sunt date ca parametri ai ablonului.
Algoritmii sunt declarai n zona de nume std i semnturile lor se afl n fiierul antet algorithm.
Cei mai muli algoritmi sunt scuri i simpli, putnd fi definii inline.
Algoritmii care produc rezultate pe care le depun ntr-un container sunt clasificai ca algoritmi de copiere i au
numele terminat cu sufixul _copy.
Algoritmii a cror funcionare este determinat de satisfacerea unui predicat sunt cunoscui ca algoritmi cu predicate.
Lista de parametri a unui asemenea algoritm va conine un obiect funcie predicat. Numele acestor algoritmi conine sufixul
_if.
n prezentarea algoritmilor vom utiliza urmtoarele abrevieri:
InIt - InputIterator, OutIt OutputIterator, FwIt ForwardIterator,
BIt BidirectionalIterator, RAIt RandomAccessIterator, Pred Predicate,
BinPred BinaryPredicate, OpUnar UnaryOperator, Func Function, T value_type
(tipul elementelor din container)
Algoritmi care nu modific secvena.
Se folosesc pentru a extrage informaii din secven sau a gsi poziia unor elemente din secven.
1. for_each() elimin un ciclu explicit, repetnd o operaie f asupra elementelor dintr-un interval de iteratori. Se
folosete pentru extragerea de informaii asupra elementelor secvenei.
template <class InIt, class Func>
Op for_each(InIt prim, InIt ultim, Func f){
while(prim!=ultim)
f(*prim++);
return f;
}

2. cutarea unei valori familia find

find() caut n secven prima valoare egal cu un parametru. ntoarce un iterator la prima valoare gsit.
template<class InIt,class T> InIt find(InIt prim, InIt ultim, const T& val);
find_if() caut n secven prima valoare care satisface un predicat.
template<class InIt,class Pred> InIt find_if(InIt prim, InIt ultim, Pred p);
find_first_of()gsete primul element din secvena 1 care se afl n secvena 2, sau gsete primul element din
secvena 1 care se satisface predicatul cu un element din secvena 2.
template<class FwIt1, class FwIt2>
FwIt1 find_first_of(FwIt1 pr1, FwIt1 ult1, FwIt2 pr2, FwIt2 ult2);
template<class FwIt1, class FwIt2>
FwIt1 find_first_of(FwIt1 pr1, FwIt1 ult1, FwIt2 pr2, FwIt2 ult2, BinPred p);

adjacent_find()gsete prima pereche de elemente vecine egale / sau care satisfac predicatul binar.
template <class FwIt> FwIt adjacent_find(FwIt prim, FwIt ultim);
template <class FwIt> FwIt adjacent_find(FwIt prim, FwIt ultim, BinPred p);

3 contorizarea apariiei unei valori

count() numr valorile din intervalul de iteratori egale cu valoarea dat ca parametru. Numrul de elemente nu
depete distana ntre iteratori.
template <class InIt, class T>
size_t count(InIt prim,InIt ultim, const T& val);
count_if()numr valorile din intervalul de iteratori care satisfac predicatul.

1
template <class InIt, class T>
size_t count_if(InIt prim, InIt ultim, Pred p);

4. compararea a dou secvene

equal() ntoarce true/false dac cele dou secvene sunt egale sau dac toate perechile satisfac predicatul
template<class InIt1,class InIt2>
bool equal(InIt1 prim1, InIt1 ultim1, InIt2 prim2);
template<class InIt1, class InIt2, class BinPred>
bool equal(InIt1 prim1, InIt1 ultim1, InIt2 prim2, BinPred p);
mismatch()ntoarce iteratori la prima pereche de elemente neegale, respectiv perechea care nu satisface predicatul
din cele dou secvene.
template<class InIt1,class InIt2>
pair<InIt1,InIt2> mismatch(InIt1 prim1, InIt1 ultim1, InIt2 prim2);
template<class InIt1, class InIt2, class BinPred>
pair<InIt1,InIt2> mismatch(InIt1 prim1, InIt1 ultim1, InIt2 prim2, BinPred p);

5 cutarea unei secvene

search() determin prima apariie a secvenei2 ca subsecven a secvenei1, respectiv prima apariie a secvenei2
ca subsecven n secvena1 cu elemente aflate n relaia dat cu elementele din secvena2. ntoarce un iterator la primul
element din prima secven egalat cu secvena2.
template <class FwIt1, class FwIt2>
FwIt1 search(FwIt1 prim1,FwIt1 ultim1,FwIt2 prim2,FwIt2 ultim2);
template <class FwIt1, class FwIt2, class BinPred>
FwIt1 search(FwIt1 prim1,FwIt1 ultim1,FwIt2 prim2,FwIt2 ultim2,BinPred p);
find_end() determin ultima apariie a secvenei2 ca subsecven a secvenei1. ntoarce un iterator la primul
element din ultima secven egalat cu secvena2.
template <class FwIt1, class FwIt2>
FwIt1 find_end(FwIt1 prim1,FwIt1 ultim1,FwIt2 prim2,FwIt2 ultim2);
template <class FwIt1, class FwIt2, class BinPred>
FwIt1 find_end(FwIt1 prim1,FwIt1 ultim1,FwIt2 prim2,FwIt2 ultim2,BinPred p);
search_n() gsete o secven cu cel puin n elemente egale / sau n relaia p cu valoarea val. ntoarce un
iterator la prima secven de n asemenea elemente.
template <class FwIt, class Size, class T>
FwIt search_n(FwIt prim, FwIt ultim,Size n, const T& val);
template <class FwIt, class Size, class T, class BinPred>
FwIt search_n(FwIt prim, FwIt ultim,Size n, const T& val, BinPred p);

Algoritmi care modific secvena.

Actualizarea unei secvene se poate face direct asupra acesteia (in situ) sau producnd o nou secven modificat n
cursul traversrii (varianta _copy). Operaiile de actualizare se refer la inserri, tergeri, interschimb de valori, copiere, etc.

1. algoritmi de copiere familia copy

copy() copiaz valorile dintr-un interval de iteratori la o destinaie, copierea ncepnd cu primul element din
interval. Dac nu se poate suprascrie la destinaie se folosete un iterator de inserie.
template <class InIt, class Out>
Out copy(InIt prim, InIt ultim, OutIt rez){
while(prim != ultim)
*rez++ = *prim++;
return rez;
}

copy_backward() copiaz valorile dintr-un interval de iteratori la o destinaie, copierea ncepnd de la ultimul
element din interval ctre primul.

2
template <class BIt1, class BIt2>
BIt2 copy_backward(BIt1 prim, BIt1 ultim, BIt2 rez){
while(prim != ultim)
*--rez = *--ultim;
return rez;
}

copy_if() copiaz toate valorile din intervalul de iteratori care satisfac predicatul, la destinaie.
template <class It1, class It2, class Pred>
It2 copy_if(It1 prim, It1 ultim, It2 rez, Pred p){
while(prim != ultim){
if(p(*prim))
*rez++ = *prim;
prim++;
}
return rez;
}

2. nlocuiri familia replace

replace() nlocuiete toate apariiile ale unei valori vechi valv din intervalul de iteratori cu o valoare nou valn
template <class FwIt, class T>
void replace(FwIt prim, FwIt ultim, const T& valv, const T& valn);

replace_if() nlocuiete toate valorile care satisfac o anumit condiie din intervalul de iteratori cu o valoare
nou.
template <class FwIt, class T, class Pred>
void replace_if(FwIt prim, FwIt ultim, Pred p, const T& valn);

Cei doi algoritmi au i variante replace_copy() i replace_copy_if(), n care nlocuirea nu se face in

situ ci la o destinaie, specificat printr-un iterator.
template <class InIt, class OutIt, class T>
OutIt replace_copy(InIt prim, InIt ultim, OutIt rez, const T& valv, const T& valn);
template <class InIt, class OutIt, class T, class Pred>
OutIt replace_copy_if(InIt prim, InIt ultim, OutIt rez, Pred p, const T& valn);

3. tergeri familia remove

remove() terge toate valorile din domeniul de iteratori egale cu o valoare dat
template <class FwIt, class T>
FwIt remove(FwIt prim, FwIt ultim, const T& val);
remove_if() terge toate valorile din domeniul de iteratori care satisfac un predicat
template <class FwIt, class Pred>
FwIt remove_if(FwIt prim, FwIt ultim, Pred p);
i variantele remove_copy() i remove_copy_if()
template <class InIt, class OutIt, class T>
OutIt remove_copy(InIt prim, InIt ultim, OutIt rez, const T& val);
template <class InIt, class OutIt, class Pred>
OutIt remove_copy_if(InIt prim, InIt ultim, OutIt rez, Pred p);

4. interschimbri familia swap interschimb elementele sau chiar containerele

swap() interschimb dou elemente individuale (chiar din containere diferite)
template <class T>
void swap(T& a, T& b);
iter_swap ()interschimb dou elemente localizate prin iteratori
template <class FwIt1, class FwIt2>

3
void iter_swap(FwIt1 a, FwIt2 b);
swap_ranges() interschimb elementele din dou intervale de iteratori
template <class FwIt1, class FwIt2>
void swap_ranges(FwIt1 prim1, FwIt1 ultim1, FwIt2 prim2);

5. transform() aplic un operator unar elementelor dintr-un interval de iteratori, depunnd elementele transformate
n alt interval de iteratori
template <class InIt, class OutIt, class OpUnar>
OutIt transform(InIt prim, InIt ultim, OutIt rez, OpUnar op);

6. generate() completeaz elementele din intervalul de iteratori cu valori obinute de la un functor generator
(predicat fr argumente)
template <class FwIt, class Generator>
void generate(FwIt prim, FwIt ultim, Generator gen);
generate_n() completeaz cu valori furnizate de generator primele n elemente dintr-un domeniu de iteratori
template <class OutIt, class Size, class Generator>
OutIt generate_n(OutIt prim, Size n, Generator gen);

7. fill() completeaz cu aceeai valoare elementele dintr-un domeniu de iteratori

template <class FwIt, class T>
void fill(FwIt prim, FwIt ultim, const T& val);
fill_n() completeaz cu aceeai valoare primele n elemente dintr-un domeniu de iteratori
template <class OutIt, class Size, class T>
OutIt fill_n(OutIter prim, Size n, const T& val);

8. unique() terge elementele consecutive identice cu un element / sau elementele consecutive elementului, aflate n
relaie cu acesta.
template <class FwIt>
FwIt unique(FwIt prim, FwIt ultim);
template <class FwIt, class Pred>
FwIt unique(FwIt prim, FwIt ultim, Pred p);
i variantele _copy:
template <class InIt, class OutIt>
OutIt unique_copy(InIt prim, InIt ultim, OutIt rez);
template <class InIt, class OutIt, class Pred>
OutIt unique_copy(InIt prim, InIt ultim, OutIt rez, Pred p);

9. reverse() inverseaz ordinea elementelor din secven

template <class BIt>
void reverse(BIt prim, BIt ultim);
template <class BIt, class OutIt>
OutIt reverse_copy(InIt prim, InIt ultim, OutIt rez);

10. rotate() deplaseaz la stnga elemenetele secvenei; elementele scoase sunt inserate la sfritul secvenei
(deplasare circular). Iteratorul med indic nceputul secvenei de elemente rotite.
template <class FwIt>
void rotate(FwIt prim, FwIt med, FwIt ultim);
template <class FwIt, class OutIt>
OutIt rotate(FwIt prim, FwIt med, FwIt ultim, OutIt rez);

4
11. partition() mparte secvena n dou intervale, astfel c elementele care satisfac un predicat vor fi plasate n
primul interval (naintea celorlalte).
template <class BIt, class Pred>
BIt partition(BIt prim, BIt ultim, Pred p);
stable_partition() realizeaz n plus fa de algoritmul precedent, ordonarea relativ a elementelor din fiecare
partiie
template <class BIt, class Pred>
BIt stable_partition(BIt prim, BIt ultim, Pred p);

12. random_shuffle() amestec aleatoriu ordinea elementelor din secven. Generatorul de numere aleatoare poate
fi specificat ca argument
template <class RAIt>
void random_shuffle(RAIt prim, RAIt ultim);
template <class RAIt, class RandGen>
void random_shuffle(RAIt prim, RAIt ultim, RandGen& rand);
13. iota() umple un interval de iteratori cu valori cresctoare, pornind cu o valoare dat ca parametru
template <class FwIt, class T>
void iota(FwIt prim, FwIt ultim, T val);

Algoritmi pentru secvene sortate.

Algoritmii din aceast clas se mpart n dou categorii: prima folosete n mod implicit funcia de comparaie < , iar
cealalt necesit ca argument un obiect funcie Compare comp furnizat de utilizator.

1. sort() realizeaz sortarea elementelor din intervalul de iteratori. Se preteaz folosirii de ctre containere cu acces
direct (vector i deque). Pentru containerul list se folosete funcia membr list::sort().
Algoritmul sort() utilizeaz sortarea rapid (quicksort), avnd n medie complexitatea O(N logN) i O(N2) n
cazul cel mai nefavorabil, cu N=ultim-prim, dar sortarea nu este stabil, n sensul c elementele cu aceeai cheie pot s nu
mai ocupe acelei poziii relative dup sortare.
template <class RAIt>
void sort(RAIt prim, RAIt ultim);
template <class RAIt, class Compare>
void sort(RAIt prim, RAIt ultim, Compare cp);
2. stable_sort() algoritmul de sortare stabil stable_sort() , dei are n medie un timp de execuie cu 40%
mai mare, are n toate situaiile complexitatea O(N logN)
template <class RAIt>
void stable_sort(RAIt prim, RAIt ultim);
template <class RAIt, class Compare>
void stable_sort(RAIt prim, RAIt ultim, Compare cp);

3. partial_sort() sorteaz primele M elemente din secven, restul rmnnd nesortate. Valoarea lui M nu este dat
n mod explicit, ci prin intermediul unui iterator med, astfel c M=med-prim. Complexitatea este O(N log M)
template <class RAIt>
void partial_sort(RAIt prim, RAIt med, RAIt ultim);
template <class RAIt, class Compare>
void partial_sort(RAIt prim, RAIt med, RAIt ultim, Compare cp);
Exist i variante _copy, care au ca parametri suplimentari iteratori la intervalul destinaie.
template <class InIt, class RAIt>
RAIt partial_sort_copy(InIt prim, InIt ultim, RAIt prim_rez, RAIt ultim_rez);
template <class InIt, class RAIt, class Compare>
RAIt partial_sort(InIt prim,InItIt ultim,RAIt prim_rez,RAIt ultim_rez,Compare cp);

5
4. nth_element() furnizeaz cel de al n-lea element din secvena sortat cresctor sau descresctor (fr a sorta
secvena).
template <class RAIt>
void nth_element(RAIt prim, RAIt nth, RAIt ultim);
template <class RAIt, class Compare>
void nth_element(RAIt prim, RAIt nth, RAIt ultim, Compare cp);
Valoarea lui n este precizat prin cel de-al doilea parametru n=nth-prim, nainte de apel; dup apel *nth conine
cel de-al n-lea element din secvena sortat. Complexitatea n medie este O(N).

5. binary_search() permite localizarea foarte rapid n O(log n) a unui element ntr-un container cu acces direct
sortat.
template <class FwIt, class T>
bool binary_search(FwIt prim, FwIt ultim, const T& val);
template <class FwIt, class T, class Compare>
bool binary_search(FwIt prim, FwIt ultim, const T& val, Compare cp);

6. lower_bound() gsete prima poziie i dintr-o secven sortat, n care poate fi inserat o valoare val astfel ca
relaia de ordine s se pstreze, adic *j < val (respectiv comp(*j, val)=true)pentru j [prim, i)
template <class FwIt, class T>
FwIt lower_bound(FwIt prim, FwIt ultim, const T& val);
template <class FwIt, class T, class Compare>
FwIt lower_bound (FwIt prim, FwIt ultim, const T& val, Compare cp);

7. upper_bound() gsete ultima poziie i dintr-o secven sortat, n care poate fi inserat o valoare val astfel ca
relaia de ordine s se pstreze.
template <class FwIt, class T>
FwIt upper_bound(FwIt prim, FwIt ultim, const T& val);
template <class FwIt, class T, class Compare>
FwIt upper_bound (FwIt prim, FwIt ultim, const T& val, Compare cp);

8. equal_range() determin cel mai mare interval dintr-o secven sortat, n care poate fi inserat o valoare val ,
n orice poziie, astfel ca relaia de ordine s se pstreze.
template <class FwIt, class T>
pair<FwIt,FwIt> equal_range(FwIt prim, FwIt ultim, const T& val);
template <class FwIt, class T, class Compare>
pair<FwIt,FwIt> equal_range(FwIt prim, FwIt ultim, const T& val, Compare cp);

9. interclasare
merge() combin dou secvene sortate ntr-o secven de asemeni sortat. Are complexitate liniar.
template <class InIt1, class InIt2, class OutIt>
OutIt merge(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2, OutIt rez);
template <class InIt1, class InIt2, class OutIt, class Compare>
OutIt merge(InIt1 prim1,InIt1 ultim1,InIt2 prim2,InIt2 ultim2,OutIt rez,Compare cp);
inplace_merge() dac cele dou domenii de iteratori sunt contigue([prim, med) i [med, ultim)), s-ar putea
face interclasare peste ele, dac s-ar utiliza o zon tampon de memorie. Rezultatul interclasrii va fi plasat n [prim,ultim)
template <class BIt>
BIt inplace_merge(BIt prim, BIt med, BIt ultim);
template <class BIt, class Compare>
BIt inplace_merge(BIt prim, BIt med, BIt ultim, Compare cp);

Algoritmi cu mulimi.

6
 Descriu principalele operaii cu mulimi (incluziune, reuniune, intersecie, diferen) pentru mulimi (containere
sortate). Au complexitate liniar O(N1+N2), unde N1 i N2 sunt cardinalele celor dou mulimi.
1. includes() determin dac mulimea M2 este inclus n mulimea M1.
template <class InIt1, class InIt2>
bool includes(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2);
template <class InIt1, class InIt2, class OutIt, class Compare>
bool includes (InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2, Compare cp);

2. set_union() construiete mulimea reuniune M1M2 a mulimilor date prin intervalele de iteratori
template <class InIt1, class InIt2, class OutIt>
OutIt set_union(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2, OutIt rez);
template <class InIt1, class InIt2, class OutIt, class Compare>
OutIt set_union(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2, OutIt rez,
Compare cp);

3. set_intersection()construiete mulimea intersecie M1M2 a mulimilor date prin intervalele de iteratori

template <class InIt1, class InIt2, class OutIt>
OutIt set_intersection(InIt1 prim1,InIt1 ultim1,InIt2 prim2,InIt2 ultim2,OutIt rez);
template <class InIt1, class InIt2, class OutIt, class Compare>
OutIt set_intersection(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2,
OutIt rez, Compare cp);

4. set_difference() construiete mulimea diferen M1-M2 a mulimilor date prin intervalele de iteratori (conine
elementele din prima mulime care nu apar n cea de a doua)
template <class InIt1, class InIt2, class OutIt>
OutIt set_difference(InIt1 prim1,InIt1 ultim1,InIt2 prim2,InIt2 ultim2,OutIt rez);
template <class InIt1, class InIt2, class OutIt, class Compare>
OutIt set_difference(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2,
OutIt rez, Compare cp);

6. set_symmetric_difference() construiete mulimea diferen simetric (M1-M2)(M2-M1)=(M1M2)-

(M1M2) a mulimilor date prin intervalele de iteratori (conine elementele din cele dou mulimi exceptnd elementele
comune)
template <class InIt1, class InIt2, class OutIt>
OutIt set_symmetric_difference(InIt1 prim1, InIt1 ultim1,
InIt2 prim2, InIt2 ultim2, OutIt rez);
template <class InIt1, class InIt2, class OutIt, class Compare>
OutIt set_symmetric_difference(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2,
OutIt rez, Compare cp);

Algoritmi cu heapuri.
Un heap este un arbore binar complet parial ordont, folosit pentru implementarea cozii prioritare.
1. pop_heap()rearanjeaz elementele din intervalul [prim, ultim-1), astfel c dac se extrage un element din
vrful heapului (din poziia prim) prin interschimbul cu elementul din poziia ultim-1 , noul interval [prim,ultim-1) s
reprezinte un heap. Complexitatea operaiei este O(log(ultim-prim)).
template <class RAIt>
void pop_heap(RAIt prim, RAIt ultim);
template <class RAIt, class Compare>
void pop_heap (RAIt prim, RAIt ultim, Compare cp);

2. push_heap()rearanjeaz elementele din heap astfel c dac se adaug un element n ultima poziie ultim-1
intervalul [prim, ultim) s reprezinte n continuare un heap. Complexitatea operaiei este O(log(ultim-prim))
template <class RAIt>
void push_heap(RAIt prim, RAIt ultim);
7
template <class RAIt, class Compare>
void push_heap (RAIt prim, RAIt ultim, Compare cp);

3. make_heap() aranjeaz elementele din intervalul de iteratori, astfel nct acestea s reprezinte un heap
template <class RAIt>
void make_heap(RAIt prim, RAIt ultim);
template <class RAIt, class Compare>
void make_heap (RAIt prim, RAIt ultim, Compare cp);

4. sort_heap() transform un heap ntr-o secven sortat (metoda de sortare heapsort). Complexitatea este O(N
log N) i sortarea nu este stabil.
template <class RAIt>
void sort_heap(RAIt prim, RAIt ultim);
template <class RAIt, class Compare>
void sort_heap (RAIt prim, RAIt ultim, Compare cp);

Algoritmi pentru minim i maxim.

1. min(), max()determin cel mai mic (respectiv cel mai mare) ntre dou elemente
template <class T>
const T& min(const T& a, const T& b);
template <class T, class Compare>
const T& min(const T& a, const T& b, Compare cp);
template <class T>
const T& max(const T& a, const T& b);
template <class T, class Compare>
const T& max(const T& a, const T& b, Compare cp);
2. min_element(), max_element() furnizeaz un iterator la cel mai mic (cel mai mare) element din intervalul
de iteratori.
template <class FwIt>
FwIt min_element(FwIt prim, FwIt ultim);
template <class FwIt, class Compare>
FwIt min_element(FwIt prim, FwIt ultim, Compare cp);
template <class FwIt>
FwIt max_element(FwIt prim, FwIt ultim);
template <class FwIt, class Compare>
FwIt max_element(FwIt prim, FwIt ultim, Compare cp);

Algoritmi de permutare.
O permutare provine dintr-o secven prin schimbarea ntre ele a dou elemente. Pentru o secven avnd N elemente,
exist N! permutri. Mulimea celor N! permutri se poate considera ordonat dup relaia < (i n general comp) ntre
elemente. Conform acestei relaii de ordine putem defini permutarea urmtoare (respectiv permutarea precedent) n raport cu
permutarea curent.
prev_permutation(), next_permutation() genereaz n intervalul de iteratori permutarea precedent
(urmtoare). ntoarece true dac exist permutarea precedent (urmtoare) i false n caz contrar.
template <class BIt>
bool prev_permutation(BIt prim, BIt ultim);
template <class Bit, class Compare>
bool prev_permutation(BIt prim, BIt ultim, Compare cp);
template <class BIt>
bool next_permutation(BIt prim, BIt ultim);
template <class Bit, class Compare>
bool next_permutation(BIt prim, BIt ultim, Compare cp);

8
 Algoritmi numerici.
Descriu operaii numerice generale. Accesul la acetia se obine prin includerea fiierului antet <numeric>.
1. accumulate() adun la elementele din intervalul de iteratori o valoare iniial dat ca parametru.
template <class InIt, class T>
T accumulate(InIt prim, InIt ultim, T vinit);
template <class InIt, class T, class BinOp>
T accumulate(InIt prim, InIt ultim, T vinit, BinOp bop);

2. inner_product() adaug o valoare iniial la produsul scalar al celor dou containere x i y:

rez vinit xiyi .

template <class InIt1, class InIt2, class T>
T inner_product(InIt1 prim1, InIt1 ultim1, init2 prim2, T vinit);
template <class InIt1, class InIt2, class T, class BinOp1, class BinOp2>
T inner_product(InIt1 prim1, InIt1 ultim1, InIt2 prim2, T vinit,
BinOp1 bop1, BinOp2 bop2);

3. partial_sum() calculeaz n containerul rezultat valorile acumulate din prima poziie, primele dou, primele trei,
etc.
template <class InIt, class OutIt>
OutIt partial_sum(InIt prim, InIt ultim, OutIt rez);
template <class InIt, class OutIt, class BinOp>
OutIt partial_sum(InIt prim, InIt ultim, OutIt rez, BinOp bop);

4. adjacent_difference() calculeaz diferenele ntre elementele consecutive ale unui container c, adic d0=c0,
di=ci-ci-1, i>0.
template <class InIt, class OutIt>
OutIt adjacent_difference(InIt prim, InIt ultim, OutIt rez);
template <class InIt, class OutIt, class BinOp>
OutIt adjacent_difference (InIt prim, InIt ultim, OutIt rez, BinOp bop);