C++ Academy · Lektion

Numeriska algoritmer: accumulate, reduce, transform_reduce

Aggregera numeriska intervall med accumulate, reduce och den parallellvänliga transform_reduce

Lektion 4 av 414 steg

Numeriska algoritmer: accumulate, reduce, transform_reduce är en gratis lektion i C++ Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för C++ Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C++ Academy innehåller totalt 4 lektioner.

Headern <numeric>

Numeriska algoritmer arbetar med intervall av tal. De finns i <numeric>.

std::accumulate

Den klassiska reduktionsalgoritmen. Summerar som standard – skicka med en anpassad binär operation för andra reduktioner.

#include <numeric>
std::vector<int> v = {1, 2, 3, 4, 5};
int sum = std::accumulate(v.begin(), v.end(), 0);
// sum = 15

Anpassad reduktion

Ange ett initialvärde och en binär operation.

int product = std::accumulate(v.begin(), v.end(), 1,
    std::multiplies<int>{});
// product = 120

Typen för initialvärdet spelar roll

Ackumulatorns typ härleds från initialvärdet. Ange 0.0 för att ackumulera värden av typen double till en double.

std::vector<double> v = {1.5, 2.5, 3.5};
double sum_d = std::accumulate(v.begin(), v.end(), 0.0);    // 7.5
int    sum_i = std::accumulate(v.begin(), v.end(), 0);      // truncates to 6

std::reduce (C++17)

Som accumulate, men operationen måste vara associativ och kommutativ – vilket möjliggör parallell utvärdering.

#include <numeric>
#include <execution>
std::vector<int> v(1000);
int sum = std::reduce(std::execution::par,
    v.begin(), v.end(), 0);

reduce jämfört med accumulate

Två skillnader:

reduce kan köras parallellt
reduce garanterar inte operationernas ordning – det fungerar bra för + och *, men inte för icke-associativa operationer som strängkonkatenering

std::transform_reduce (C++17)

Kombinerar en transformering och en reduktion i ett enda genomlopp. Snabbare och mer uttrycksfullt än separata anrop till transformering och reduktion.

// Dot product
std::vector<int> a = {1, 2, 3}, b = {4, 5, 6};
int dot = std::transform_reduce(
    a.begin(), a.end(), b.begin(),
    0,
    std::plus<int>{},          // reduce
    std::multiplies<int>{}     // transform
);
// dot = 1*4 + 2*5 + 3*6 = 32

std::inner_product

Den äldre motsvarigheten till transform_reduce. Beräknar den inre produkten (skalärprodukten) av två intervall. Mindre generell, men med ett enklare API.

std::partial_sum

Skriver löpande summor till ett utdataintervall.

std::vector<int> v = {1, 2, 3, 4};
std::vector<int> sums(4);
std::partial_sum(v.begin(), v.end(), sums.begin());
// sums = {1, 3, 6, 10}

std::adjacent_difference

Motsatsen till partial_sum – skriver skillnaderna mellan intilliggande element.

std::vector<int> v = {1, 3, 6, 10};
std::vector<int> diffs(4);
std::adjacent_difference(v.begin(), v.end(), diffs.begin());
// diffs = {1, 2, 3, 4}

Förbehåll för flyttal

För flyttal spelar ackumuleringsordningen roll på grund av avrundning. reduce kan ge något annorlunda resultat än accumulate eftersom utvärderingsordningen inte är specificerad.

Praktiska användningsområden

Numeriska algoritmer används för:

Beräkningar av summor och produkter
Statistiska aggregat (medelvärde, varians)
Skalärprodukter och normer inom linjär algebra
Kumulativa summor för prefixfrågor

Snabbtest

Vilken C++17-algoritm utför en parallell reduktion av ett intervall med ett enda funktionsanrop?

Besvara frågan i den interaktiva lektionen

Sammanfattning

<numeric> tillhandahåller accumulate, reduce, transform_reduce, partial_sum och adjacent_difference för numeriska reduktioner och prefixoperationer. Välj reduce för parallellism och accumulate för deterministisk ordning.

Gratis att börja

Lär dig C++ med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Numeriska algoritmer: accumulate, reduce, transform_reduce” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen C++ Academy, inklusive ”Numeriska algoritmer: accumulate, reduce, transform_reduce”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i C++ Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Numeriska algoritmer: accumulate, reduce, transform_reduce”?

Aggregera numeriska intervall med accumulate, reduce och den parallellvänliga transform_reduce Ni övar på C++ Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C++ Academy?

Du behöver inga förkunskaper. Utbildningen i C++ Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Numeriska algoritmer: accumulate, reduce, transform_reduce”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C++ Academy-lektionen?

Ja. Varje C++ Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Icke-modifierande algoritmer: find, count, all_of
Modifierande algoritmer: transform, copy_if, replace
Sortering och partitionering: sort, stable_partition
Numeriska algoritmer: accumulate, reduce, transform_reduce

← Tillbaka till C++ Academy