Home - qdidactic.com
Didactica si proiecte didacticeBani si dezvoltarea cariereiStiinta  si proiecte tehniceIstorie si biografiiSanatate si medicinaDezvoltare personala
referate stiintaSa fii al doilea inseamna sa fii primul care pierde - Ayrton Senna





Aeronautica Comunicatii Drept Informatica Nutritie Sociologie
Tehnica mecanica




Informatica


Qdidactic » stiinta & tehnica » informatica
Algoritmi - algoritmi care nu modifica secventa



Algoritmi - algoritmi care nu modifica secventa


Algoritmii acopera un domeniu larg de operatii generale asupra containerelor precum: traversare, sortare, cautare, inserare sau stergere de elemente.

Algoritmii sunt functii generice, care se refera la containere prin intermediul iteratorilor. Tipurile iteratorilor folositi de un algoritm sunt date ca parametri ai sablonului.

Algoritmii sunt declarati in zona de nume std si semnaturile lor se afla in fisierul antet algorithm.

Cei mai multi algoritmi sunt scurti si simpli, putand fi definiti inline.

Algoritmii care produc rezultate pe care le depun intr-un container sunt clasificati ca algoritmi de copiere si au numele terminat cu sufixul _copy.

Algoritmii a caror functionare este determinata de satisfacerea unui predicat sunt cunoscuti ca algoritmi cu predicate. Lista de parametri a unui asemenea algoritm va contine un obiect functie predicat. Numele acestor algoritmi contine sufixul _if.

In prezentarea algoritmilor vom utiliza urmatoarele 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 modifica secventa.

Se folosesc pentru a extrage informatii din secventa sau a gasi pozitia unor elemente din secventa.

1. for_each() elimina un ciclu explicit, repetand o operatie f asupra elementelor dintr-un interval de iteratori. Se foloseste pentru extragerea de informatii asupra elementelor secventei.

template <class InIt, class Func>

Op for_each(InIt prim, InIt ultim, Func f)


2. cautarea unei valori –familia find

find() cauta in secventa prima valoare egala cu un parametru. Intoarce un iterator la prima valoare gasita.

template<class InIt,class T> InIt find(InIt prim, InIt ultim, const T& val);

find_if() cauta in secventa prima valoare care satisface un predicat.

template<class InIt,class Pred> InIt find_if(InIt prim, InIt ultim, Pred p);

find_first_of()gaseste primul element din secventa 1 care se afla in secventa 2, sau gaseste primul element din secventa 1 care se satisface predicatul cu un element din secventa 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()gaseste 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 aparitiei unei valori

count() numara valorile din intervalul de iteratori egale cu valoarea data ca parametru. Numarul de elemente nu depaseste distanta intre iteratori.

template <class InIt, class T>

size_t count(InIt prim,InIt ultim, const T& val);

count_if()numara valorile din intervalul de iteratori care satisfac predicatul.

template <class InIt, class T>

size_t count_if(InIt prim, InIt ultim, Pred p);


4. – compararea a doua secvente

equal() intoarce true/false daca cele doua secvente sunt egale sau daca 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()intoarce iteratori la prima pereche de elemente neegale, respectiv perechea care nu satisface predicatul din cele doua secvente.

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);


cautarea unei secvente

search() – determina prima aparitie a secventei2 ca subsecventa a secventei1, respectiv prima aparitie a secventei2 ca subsecventa in secventa1 cu elemente aflate in relatia data cu elementele din secventa2. Intoarce un iterator la primul element din prima secventa egalata cu secventa2.

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() determina ultima aparitie a secventei2 ca subsecventa a secventei1. Intoarce un iterator la primul element din ultima secventa egalata cu secventa2.

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() gaseste o secventa cu cel putin n elemente egale / sau in relatia p cu valoarea val. Intoarce un iterator la prima secventa 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 modifica secventa.

Actualizarea unei secvente se poate face direct asupra acesteia (in situ) sau producand o noua secventa modificata in cursul traversarii (varianta _copy). Operatiile de actualizare se refera la inserari, stergeri, interschimb de valori, copiere, etc.


1. algoritmi de copiere – familia copy

copy() copiaza valorile dintr-un interval de iteratori la o destinatie, copierea incepand cu primul element din interval. Daca nu se poate suprascrie la destinatie se foloseste un iterator de insertie.

template <class InIt, class Out>

Out copy(InIt prim, InIt ultim, OutIt rez)


copy_backward() copiaza valorile dintr-un interval de iteratori la o destinatie, copierea incepand de la ultimul element din interval catre primul.

template <class BIt1, class BIt2>

BIt2 copy_backward(BIt1 prim, BIt1 ultim, BIt2 rez)


copy_if() copiaza toate valorile din intervalul de iteratori care satisfac predicatul, la destinatie.

template <class It1, class It2, class Pred>

It2 copy_if(It1 prim, It1 ultim, It2 rez, Pred p)

return rez;



inlocuiri – familia replace

replace() inlocuieste toate aparitiile ale unei valori vechi valv din intervalul de iteratori cu o valoare noua valn

template <class FwIt, class T>

void replace(FwIt prim, FwIt ultim, const T& valv, const T& valn);


replace_if() inlocuieste toate valorile care satisfac o anumita conditie din intervalul de iteratori cu o valoare noua.

template <class FwIt, class T, class Pred>

void replace_if(FwIt prim, FwIt ultim, Pred p, const T& valn);


Cei doi algoritmi au si variante replace_copy() si replace_copy_if(), in care inlocuirea nu se face in situ ci la o destinatie, specificata 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. stergeri – familia remove

remove() sterge toate valorile din domeniul de iteratori egale cu o valoare data

template <class FwIt, class T>


FwIt remove(FwIt prim, FwIt ultim, const T& val);

remove_if() sterge toate valorile din domeniul de iteratori care satisfac un predicat

template <class FwIt, class Pred>

FwIt remove_if(FwIt prim, FwIt ultim, Pred p);

si variantele remove_copy() si 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. interschimbari – familia swap interschimba elementele sau chiar containerele

swap() interschimba doua elemente individuale (chiar din containere diferite)

template <class T>

void swap(T& a, T& b);

iter_swap ()interschimba doua elemente localizate prin iteratori

template <class FwIt1, class FwIt2>

void iter_swap(FwIt1 a, FwIt2 b);

swap_ranges() interschimba elementele din doua intervale de iteratori

template <class FwIt1, class FwIt2>

void swap_ranges(FwIt1 prim1, FwIt1 ultim1, FwIt2 prim2);


transform() aplica un operator unar elementelor dintr-un interval de iteratori, depunand elementele transformate in alt interval de iteratori

template <class InIt, class OutIt, class OpUnar>

OutIt transform(InIt prim, InIt ultim, OutIt rez, OpUnar op);


generate() completeaza elementele din intervalul de iteratori cu valori obtinute de la un functor generator (predicat fara argumente)

template <class FwIt, class Generator>

void generate(FwIt prim, FwIt ultim, Generator gen);

generate_n() completeaza 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);


fill() completeaza cu aceeasi valoare elementele dintr-un domeniu de iteratori

template <class FwIt, class T>

void fill(FwIt prim, FwIt ultim, const T& val);

fill_n() completeaza cu aceeasi 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);


unique() sterge elementele consecutive identice cu un element / sau elementele consecutive elementului, aflate in relatie cu acesta.

template <class FwIt>

FwIt unique(FwIt prim, FwIt ultim);

template <class FwIt, class Pred>

FwIt unique(FwIt prim, FwIt ultim, Pred p);

si 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);


reverse() inverseaza ordinea elementelor din secventa

template <class BIt>

void reverse(BIt prim, BIt ultim);

template <class BIt, class OutIt>

OutIt reverse_copy(InIt prim, InIt ultim, OutIt rez);


rotate() deplaseaza la stanga elemenetele secventei; elementele scoase sunt inserate la sfarsitul secventei (deplasare circulara). Iteratorul med indica inceputul secventei 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);


partition() imparte secventa in doua intervale, astfel ca elementele care satisfac un predicat vor fi plasate in primul interval (inaintea celorlalte).

template <class BIt, class Pred>

BIt partition(BIt prim, BIt ultim, Pred p);

stable_partition() realizeaza in plus fata de algoritmul precedent, ordonarea relativa a elementelor din fiecare partitie

template <class BIt, class Pred>

BIt stable_partition(BIt prim, BIt ultim, Pred p);


random_shuffle() amesteca aleatoriu ordinea elementelor din secventa. 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);

iota() umple un interval de iteratori cu valori crescatoare, pornind cu o valoare data ca parametru

template <class FwIt, class T>

void iota(FwIt prim, FwIt ultim, T val);


Algoritmi pentru secvente sortate.

Algoritmii din aceasta clasa se impart in doua categorii: prima foloseste in mod implicit functia de comparatie < , iar cealalta necesita ca argument un obiect functie Compare comp furnizat de utilizator.


sort() realizeaza sortarea elementelor din intervalul de iteratori. Se preteaza folosirii de catre containere cu acces direct (vector si deque). Pentru containerul list se foloseste functia membra list::sort().

Algoritmul sort() utilizeaza sortarea rapida (quicksort), avand in medie complexitatea O(N logN) si O(N2) in cazul cel mai nefavorabil, cu N=ultim-prim, dar sortarea nu este stabila, in sensul ca elementele cu aceeasi cheie pot sa nu mai ocupe acelesi pozitii relative dupa sortare.

template <class RAIt>

void sort(RAIt prim, RAIt ultim);

template <class RAIt, class Compare>

void sort(RAIt prim, RAIt ultim, Compare cp);

stable_sort() algoritmul de sortare stabila stable_sort() , desi are in medie un timp de executie cu 40% mai mare, are in toate situatiile 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);


partial_sort() sorteaza primele M elemente din secventa, restul ramanand nesortate. Valoarea lui M nu este data in mod explicit, ci prin intermediul unui iterator med, astfel ca 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);

Exista si variante _copy, care au ca parametri suplimentari iteratori la intervalul destinatie.

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);


nth_element() furnizeaza cel de al n-lea element din secventa sortata crescator sau descrescator (fara a sorta secventa).

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 precizata prin cel de-al doilea parametru n=nth-prim, inainte de apel; dupa apel *nth contine cel de-al n-lea element din secventa sortata. Complexitatea in medie este O(N).


binary_search() permite localizarea foarte rapida in O(log n) a unui element intr-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);


lower_bound() gaseste prima pozitie i dintr-o secventa sortata, in care poate fi inserata o valoare val astfel ca relatia de ordine sa se pastreze, adica *j < val (respectiv comp(*j, val)=true)pentru j I [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);


upper_bound() gaseste ultima pozitie i dintr-o secventa sortata, in care poate fi inserata o valoare val astfel ca relatia de ordine sa se pastreze.

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);


equal_range() determina cel mai mare interval dintr-o secventa sortata, in care poate fi inserata o valoare val , in orice pozitie, astfel ca relatia de ordine sa se pastreze.

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() combina doua secvente sortate intr-o secventa de asemeni sortata. Are complexitate liniara.

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() daca cele doua domenii de iteratori sunt contigue([prim, med) si [med, ultim)), s-ar putea face interclasare peste ele, daca s-ar utiliza o zona tampon de memorie. Rezultatul interclasarii va fi plasat in [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 multimi.

Descriu principalele operatii cu multimi (incluziune, reuniune, intersectie, diferenta) pentru multimi (containere sortate). Au complexitate liniara O(N1+N2), unde N1 si N2 sunt cardinalele celor doua multimi.

includes() determina daca multimea M2 este inclusa in multimea 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);


set_union() construieste multimea reuniune M1 M2 a multimilor 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);


set_intersection()construieste multimea intersectie M1 M2 a multimilor 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);


set_difference() construieste multimea diferenta M1-M2 a multimilor date prin intervalele de iteratori (contine elementele din prima multime care nu apar in 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);


set_symmetric_difference() construieste multimea diferenta simetrica (M1-M2) (M2-M1)=(M1 M2)-(M1 M2) a multimilor date prin intervalele de iteratori (contine elementele din cele doua multimi exceptand 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 partial ordont, folosit pentru implementarea cozii prioritare.

pop_heap()rearanjeaza elementele din intervalul [prim, ultim-1), astfel ca daca se extrage un element din varful heapului (din pozitia prim) prin interschimbul cu elementul din pozitia ultim-1 , noul interval [prim,ultim-1) sa reprezinte un heap. Complexitatea operatiei 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);


push_heap()rearanjeaza elementele din heap astfel ca daca se adauga un element in ultima pozitie ultim-1 intervalul [prim, ultim) sa reprezinte in continuare un heap. Complexitatea operatiei este O(log(ultim-prim))

template <class RAIt>

void push_heap(RAIt prim, RAIt ultim);

template <class RAIt, class Compare>

void push_heap (RAIt prim, RAIt ultim, Compare cp);


make_heap() aranjeaza elementele din intervalul de iteratori, astfel incat acestea sa 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);


sort_heap() transforma un heap intr-o secventa sortata (metoda de sortare heapsort). Complexitatea este O(N log N) si sortarea nu este stabila.

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 si maxim.

min(), max()determina cel mai mic (respectiv cel mai mare) intre doua 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);

min_element(), max_element() furnizeaza 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 secventa prin schimbarea intre ele a doua elemente. Pentru o secventa avand N elemente, exista N! permutari. Multimea celor N! permutari se poate considera ordonata dupa relatia < (si in general comp) intre elemente. Conform acestei relatii de ordine putem defini permutarea urmatoare (respectiv permutarea precedenta) in raport cu permutarea curenta.

prev_permutation(), next_permutation() genereaza in intervalul de iteratori permutarea precedenta (urmatoare). Intoarece true daca exista permutarea precedenta (urmatoare) si false in 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);


Algoritmi numerici.

Descriu operatii numerice generale. Accesul la acestia se obtine prin includerea fisierului antet <numeric>.

accumulate() aduna la elementele din intervalul de iteratori o valoare initiala data 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);


inner_product() adauga o valoare initiala la produsul scalar al celor doua containere x si y:

.

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);


partial_sum() calculeaza in containerul rezultat valorile acumulate din prima pozitie, primele doua, 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);


adjacent_difference() calculeaza diferentele intre elementele consecutive ale unui container c, adica 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);








Contact |- ia legatura cu noi -|
Adauga document |- pune-ti documente online -|
Termeni & conditii de utilizare |- politica de cookies si de confidentialitate -|
Copyright © |- 2022 - Toate drepturile rezervate -|