C++ Academy · Aula

Algoritmos numéricos: accumulate, reduce, transform_reduce

Agregue intervalos numéricos com accumulate, reduce e transform_reduce, adequado para paralelização

Aula 4 de 414 etapas

Algoritmos numéricos: accumulate, reduce, transform_reduce é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

O cabeçalho <numeric>

Os algoritmos numéricos operam em intervalos de números. Eles estão em <numeric>.

std::accumulate

A redução clássica. Soma por padrão — forneça uma operação binária personalizada para outras reduções.

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

Redução personalizada

Forneça um valor inicial e uma operação binária.

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

O tipo do valor inicial é importante

O tipo do acumulador é deduzido a partir do valor inicial. Forneça um 0.0 para acumular valores de ponto flutuante em um 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)

Como accumulate, mas a operação precisa ser associativa e comutativa, o que permite a avaliação em paralelo.

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

reduce versus accumulate

Há duas diferenças:

reduce pode ser executado em paralelo
reduce não garante a ordem de execução da operação — isso funciona para + e *, mas falha com operações não associativas, como a concatenação de cadeias de caracteres

std::transform_reduce (C++17)

Combine uma transformação e uma redução em uma única passagem. É mais rápido e expressivo que usar transformação e redução separadamente.

// 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

O antecessor de transform_reduce. Calcula o produto interno de dois intervalos. É menos geral, mas tem uma interface de programação mais simples.

std::partial_sum

Escreva totais acumulados em um intervalo de saída.

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

O oposto de partial_sum — escreve as diferenças entre elementos consecutivos.

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}

Ressalva sobre ponto flutuante

Para números de ponto flutuante, a ordem de acumulação é importante por causa do arredondamento. reduce pode produzir resultados ligeiramente diferentes de accumulate devido à sua ordem de avaliação não especificada.

Casos de uso reais

Os algoritmos numéricos possibilitam:

cálculos de somas e produtos
agregações estatísticas (média, variância)
produtos internos e normas em álgebra linear
somas acumuladas para consultas por prefixo

Verificação rápida

Qual algoritmo do C++17 faz a redução paralela de um intervalo com uma única chamada de função?

Responda na aula interativa

Recapitulação

<numeric> fornece accumulate, reduce, transform_reduce, partial_sum e adjacent_difference para reduções numéricas e operações de prefixo. Escolha reduce para obter paralelismo e accumulate para uma ordem determinística.

Grátis para começar

Aprenda C++ com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Algoritmos numéricos: accumulate, reduce, transform_reduce” é grátis?

Sim — o texto completo de “Algoritmos numéricos: accumulate, reduce, transform_reduce” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Algoritmos numéricos: accumulate, reduce, transform_reduce”?

Agregue intervalos numéricos com accumulate, reduce e transform_reduce, adequado para paralelização Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Algoritmos numéricos: accumulate, reduce, transform_reduce”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Algoritmos que não modificam: find, count, all_of
Transformação e modificação: transform, copy_if, replace
Ordenação e particionamento: sort, stable_partition
Algoritmos numéricos: accumulate, reduce, transform_reduce

← Voltar para C++ Academy