Estatística

Produtório: o ∏ da fórmula é só um laço que multiplica

Capa do artigo Produtório: o ∏ da fórmula é só um laço que multiplica
Leitura com foco

Entenda o contexto.
Leve para a prática.

Neste artigo
  1. O que é um produtório?
  2. Como ler uma expressão com Σ ou com ∏?
  3. Como calcular um produtório em Python, PHP e C?
  4. Quais são as propriedades do produtório?
  5. O que o fatorial tem a ver com o produtório?
  6. Onde mais o produtório aparece?
  7. Aí você pergunta: e se a lista estiver vazia?
  8. Aí você pergunta: dá para trocar um produtório por um somatório?
  9. Quais são os erros mais comuns com produtório?
  10. Agora é com você!

Produtório é a multiplicação de uma sequência de valores, escrita de forma abreviada com a letra grega pi maiúscula (∏). Também é chamado de produtória. Em vez de escrever x1 × x2 × x3 × … × xn, você escreve um símbolo só, com três informações: o que multiplicar, onde começar e onde parar.

No artigo sobre o somatório, vimos como o sigma (Σ) abrevia uma soma comprida. O produtório é o irmão dele: a mesma estrutura, com a multiplicação no lugar da soma. E, se você já escreveu um laço de repetição que multiplica uma variável a cada volta, já programou um.

Pense em uma lanchonete. Para montar o combo, você escolhe 1 entre 3 pães, depois 1 entre 4 recheios e, por fim, 1 entre 2 bebidas. De quantos jeitos dá para montar? Para cada pão há 4 recheios: 3 × 4 = 12. Para cada um desses 12 há 2 bebidas: 12 × 2 = 24 combos. O produtório é o jeito de escrever “multiplique todas as quantidades, da primeira à última” sem listar uma por uma.

História em quadrinhos em três quadros: na lanchonete, 3 pães dão 3 jeitos de montar o combo; com 4 recheios para cada pão são 12; com 2 bebidas para cada um são 24
Cada etapa da escolha multiplica a quantidade de combos: 3, depois 12, depois 24.

O que é um produtório?

É uma multiplicação escrita com quatro partes:

  • O pi maiúsculo (∏): a ordem de multiplicar.
  • O índice: a letra que conta os fatores. Aqui, i.
  • Os limites: embaixo do pi, o valor em que o índice começa (limite inferior). Em cima, o valor em que ele termina (limite superior).
  • O termo geral: à direita do pi, o que entra na multiplicação para cada valor do índice.
Diagrama das partes de um produtório: o pi maiúsculo, o limite superior n, o termo geral x índice i e o índice i começando em 1
O índice assume cada valor inteiro entre os dois limites, incluindo os dois. Cada valor gera um fator.

Tome as quantidades da lanchonete: 3, 4 e 2. Chamando a primeira de x1, a segunda de x2 e a terceira de x3, o produtório das três fica assim:

 3
∏ x_i = x_1 × x_2 × x_3 = 3 × 4 × 2 = 24
i=1

ATENÇÃO: o ∏ é a letra pi maiúscula. Não confunda com o π, a letra pi minúscula, que representa um número: no Python, math.pi devolve 3.141592653589793. São dois símbolos diferentes, com dois significados diferentes.

Como ler uma expressão com Σ ou com ∏?

Se esses símbolos assustam você no meio de uma fórmula, calma! Os dois são lidos do mesmo jeito, em cinco passos:

  • Olhe embaixo do símbolo. Ali estão a letra do índice e o valor em que ela começa.
  • Olhe em cima. Ali está o valor em que o índice termina.
  • Olhe à direita. Ali está o termo geral, a conta que será repetida.
  • Troque o índice por cada número inteiro, do limite de baixo até o de cima, e anote o resultado de cada troca.
  • Junte os resultados. Com + se o símbolo for Σ. Com × se for ∏.

Em voz alta, a leitura segue a mesma ordem. O somatório abaixo se lê “soma de i, para i de 1 até 4”. Trocando uma palavra, o produtório se lê “produto de i, para i de 1 até 4”.

 4
Σ i = 1 + 2 + 3 + 4 = 10
i=1

 4
∏ i = 1 × 2 × 3 × 4 = 24
i=1
Somatório e produtório lado a lado: a soma de i, para i de 1 até 4, dá 10, e o produto de i, para i de 1 até 4, dá 24; embaixo do símbolo fica o começo do índice, em cima o fim e à direita o termo geral
Embaixo, em cima e à direita, tudo igual. Só o símbolo mudou, e com ele a operação e o resultado.

Quando o termo geral é uma conta, a troca do quarto passo acontece dentro dela. Veja com o termo geral 2 × k, com k de 1 até 3:

 3
∏ (2 × k) = (2 × 1) × (2 × 2) × (2 × 3) = 2 × 4 × 6 = 48
k=1

Repare que o índice agora é k, e não i. A letra do índice não muda nada: trocar uma pela outra dá o mesmo resultado.

E quando o termo geral é xi? Nesse caso o índice não entra em uma conta: ele aponta uma posição em uma lista de valores. O x1 é o primeiro valor, o x2 é o segundo, e assim por diante. É o caso das quantidades da lanchonete.

Para o programador, cada parte da notação tem um par no laço de repetição:

Na expressãoNo programa
O índice (i, k…)A variável que controla o laço
Os limitesOnde o laço começa e onde termina
O termo geralA conta feita em cada volta
O ΣUm acumulador que começa em 0 e soma
O ∏Um acumulador que começa em 1 e multiplica
Somatório e produtório são laços escritos em notação matemática.

Ou seja: quem sabe escrever um laço já sabe ler um somatório e um produtório!

Como calcular um produtório em Python, PHP e C?

O produtório vira um laço com um acumulador, como no somatório. A diferença está no começo: o acumulador parte de 1, e não de 0, e é multiplicado por um fator a cada volta. O programa abaixo faz isso com as quantidades da lanchonete e depois testa, com números, cada propriedade que vem a seguir.

Python:

# Produtório: a multiplicação de uma lista de valores, escrita com a letra pi maiúscula
import math

opcoes = [3, 4, 2]
n = len(opcoes)

# o produtório é um laço com um acumulador que começa em 1
produto = 1
for i in range(n):
    produto = produto * opcoes[i]
    print("i = %d  x = %d  produto parcial = %d" % (i + 1, opcoes[i], produto))

print()
print("produto dos valores:", produto)
print("com uma função:", math.prod(opcoes))

# constante multiplicando: sai do produtório elevada a n
produto_dobro = 1
for x in opcoes:
    produto_dobro = produto_dobro * (2 * x)
print()
print("produto de 2x: %d  2 elevado a 3, vezes o produto: %d" % (produto_dobro, 2 ** n * produto))

# produtório de uma constante: a constante elevada a n
produto_const = 1
for i in range(n):
    produto_const = produto_const * 10
print("produto de 10, três vezes: %d  10 elevado a 3: %d" % (produto_const, 10 ** n))

# produto de duas listas, par a par: pode separar em dois produtórios
outros = [2, 1, 3]
produto_juntos = 1
produto_outros = 1
for i in range(n):
    produto_juntos = produto_juntos * (opcoes[i] * outros[i])
    produto_outros = produto_outros * outros[i]
print("produto de (x × y): %d  produto de x vezes produto de y: %d" % (produto_juntos, produto * produto_outros))

# o produto das somas não é a soma dos produtos
produto_somas = 1
for i in range(n):
    produto_somas = produto_somas * (opcoes[i] + outros[i])
print()
print("produto de (x + y): %d  produto de x mais produto de y: %d" % (produto_somas, produto + produto_outros))

# um fator igual a zero zera o produto inteiro
com_zero = [3, 4, 0, 2]
produto_zero = 1
for x in com_zero:
    produto_zero = produto_zero * x
print("produto com um fator igual a zero:", produto_zero)

# produto de 1 até n: o fatorial
print()
for limite in [5, 10, 20]:
    total = 1
    for i in range(1, limite + 1):
        total = total * i
    print("produto de 1 até %d: %d" % (limite, total))

# o logaritmo transforma o produtório em somatório
soma_logs = 0.0
for x in opcoes:
    soma_logs = soma_logs + math.log10(x)
print()
print("logaritmo do produto: %.4f  soma dos logaritmos: %.4f" % (math.log10(produto), soma_logs))

PHP:

<?php
// Produtório: a multiplicação de uma lista de valores, escrita com a letra pi maiúscula
$opcoes = [3, 4, 2];
$n = count($opcoes);

// o produtório é um laço com um acumulador que começa em 1
$produto = 1;
for ($i = 0; $i < $n; $i++) {
    $produto = $produto * $opcoes[$i];
    printf("i = %d  x = %d  produto parcial = %d\n", $i + 1, $opcoes[$i], $produto);
}

echo "\nproduto dos valores: $produto\n";
echo "com uma função: " . array_product($opcoes) . "\n";

// constante multiplicando: sai do produtório elevada a n
$produto_dobro = 1;
foreach ($opcoes as $x) {
    $produto_dobro = $produto_dobro * (2 * $x);
}
printf("\nproduto de 2x: %d  2 elevado a 3, vezes o produto: %d\n", $produto_dobro, 2 ** $n * $produto);

// produtório de uma constante: a constante elevada a n
$produto_const = 1;
for ($i = 0; $i < $n; $i++) {
    $produto_const = $produto_const * 10;
}
printf("produto de 10, três vezes: %d  10 elevado a 3: %d\n", $produto_const, 10 ** $n);

// produto de duas listas, par a par: pode separar em dois produtórios
$outros = [2, 1, 3];
$produto_juntos = 1;
$produto_outros = 1;
for ($i = 0; $i < $n; $i++) {
    $produto_juntos = $produto_juntos * ($opcoes[$i] * $outros[$i]);
    $produto_outros = $produto_outros * $outros[$i];
}
printf("produto de (x × y): %d  produto de x vezes produto de y: %d\n", $produto_juntos, $produto * $produto_outros);

// o produto das somas não é a soma dos produtos
$produto_somas = 1;
for ($i = 0; $i < $n; $i++) {
    $produto_somas = $produto_somas * ($opcoes[$i] + $outros[$i]);
}
printf("\nproduto de (x + y): %d  produto de x mais produto de y: %d\n", $produto_somas, $produto + $produto_outros);

// um fator igual a zero zera o produto inteiro
$com_zero = [3, 4, 0, 2];
$produto_zero = 1;
foreach ($com_zero as $x) {
    $produto_zero = $produto_zero * $x;
}
echo "produto com um fator igual a zero: $produto_zero\n";

// produto de 1 até n: o fatorial
echo "\n";
foreach ([5, 10, 20] as $limite) {
    $total = 1;
    for ($i = 1; $i <= $limite; $i++) {
        $total = $total * $i;
    }
    printf("produto de 1 até %d: %d\n", $limite, $total);
}

// o logaritmo transforma o produtório em somatório
$soma_logs = 0.0;
foreach ($opcoes as $x) {
    $soma_logs = $soma_logs + log10($x);
}
printf("\nlogaritmo do produto: %.4f  soma dos logaritmos: %.4f\n", log10($produto), $soma_logs);

C:

/* Produtório: a multiplicação de uma lista de valores, escrita com a letra pi maiúscula */
#include <stdio.h>
#include <math.h>

/* função que multiplica os n primeiros elementos de um vetor */
long long multiplicar(const int v[], int n) {
    long long total = 1;
    for (int i = 0; i < n; i++) {
        total = total * v[i];
    }
    return total;
}

/* função que calcula a base elevada ao expoente com um laço */
long long potencia(int base, int expoente) {
    long long resultado = 1;
    for (int i = 0; i < expoente; i++) {
        resultado = resultado * base;
    }
    return resultado;
}

int main(void) {
    int opcoes[] = {3, 4, 2};
    int n = 3;

    /* o produtório é um laço com um acumulador que começa em 1 */
    long long produto = 1;
    for (int i = 0; i < n; i++) {
        produto = produto * opcoes[i];
        printf("i = %d  x = %d  produto parcial = %lld\n", i + 1, opcoes[i], produto);
    }

    printf("\nproduto dos valores: %lld\n", produto);
    printf("com uma função: %lld\n", multiplicar(opcoes, n));

    /* constante multiplicando: sai do produtório elevada a n */
    long long produto_dobro = 1;
    for (int i = 0; i < n; i++) {
        produto_dobro = produto_dobro * (2 * opcoes[i]);
    }
    printf("\nproduto de 2x: %lld  2 elevado a 3, vezes o produto: %lld\n", produto_dobro, potencia(2, n) * produto);

    /* produtório de uma constante: a constante elevada a n */
    long long produto_const = 1;
    for (int i = 0; i < n; i++) {
        produto_const = produto_const * 10;
    }
    printf("produto de 10, três vezes: %lld  10 elevado a 3: %lld\n", produto_const, potencia(10, n));

    /* produto de duas listas, par a par: pode separar em dois produtórios */
    int outros[] = {2, 1, 3};
    long long produto_juntos = 1, produto_outros = 1;
    for (int i = 0; i < n; i++) {
        produto_juntos = produto_juntos * (opcoes[i] * outros[i]);
        produto_outros = produto_outros * outros[i];
    }
    printf("produto de (x × y): %lld  produto de x vezes produto de y: %lld\n", produto_juntos, produto * produto_outros);

    /* o produto das somas não é a soma dos produtos */
    long long produto_somas = 1;
    for (int i = 0; i < n; i++) {
        produto_somas = produto_somas * (opcoes[i] + outros[i]);
    }
    printf("\nproduto de (x + y): %lld  produto de x mais produto de y: %lld\n", produto_somas, produto + produto_outros);

    /* um fator igual a zero zera o produto inteiro */
    int com_zero[] = {3, 4, 0, 2};
    printf("produto com um fator igual a zero: %lld\n", multiplicar(com_zero, 4));

    /* produto de 1 até n: o fatorial */
    int limites[] = {5, 10, 20};
    printf("\n");
    for (int t = 0; t < 3; t++) {
        int limite = limites[t];
        long long total = 1;
        for (int i = 1; i <= limite; i++) {
            total = total * i;
        }
        printf("produto de 1 até %d: %lld\n", limite, total);
    }

    /* o logaritmo transforma o produtório em somatório */
    double soma_logs = 0.0;
    for (int i = 0; i < n; i++) {
        soma_logs = soma_logs + log10(opcoes[i]);
    }
    printf("\nlogaritmo do produto: %.4f  soma dos logaritmos: %.4f\n", log10((double) produto), soma_logs);
    return 0;
}

Saída:

i = 1  x = 3  produto parcial = 3
i = 2  x = 4  produto parcial = 12
i = 3  x = 2  produto parcial = 24

produto dos valores: 24
com uma função: 24

produto de 2x: 192  2 elevado a 3, vezes o produto: 192
produto de 10, três vezes: 1000  10 elevado a 3: 1000
produto de (x × y): 144  produto de x vezes produto de y: 144

produto de (x + y): 125  produto de x mais produto de y: 30
produto com um fator igual a zero: 0

produto de 1 até 5: 120
produto de 1 até 10: 3628800
produto de 1 até 20: 2432902008176640000

logaritmo do produto: 1.3802  soma dos logaritmos: 1.3802

O Python tem a função math.prod, e o PHP tem a array_product, que fazem o laço por você. No programa em C, a função multiplicar foi escrita à mão. Foque no conceito, e não na linguagem! Nos três casos, o que acontece por baixo é o mesmo acumulador.

ATENÇÃO: no produtório deste artigo o índice começa em 1. Nos três programas, a primeira posição do vetor é a 0. Por isso o laço vai de 0 até n − 1, e a saída mostra i + 1.

Ver a animação do acumulador multiplicando as três quantidades
Animação do acumulador multiplicando 3, 4 e 2: ele começa em 1 e passa por 3 e 12 até chegar a 24
O acumulador começa em 1 e é multiplicado por um fator a cada volta. Depois de três voltas, ele guarda o produtório.

Aí você pergunta: por que o acumulador começa em 1? Porque multiplicar por 1 não muda o valor, assim como somar 0 não muda. Se ele começasse em 0, toda multiplicação daria 0: no teste, o laço com as três quantidades terminou em 0, e não em 24.

Quais são as propriedades do produtório?

São três regras que permitem mexer na conta sem mudar o resultado. Ao lado de cada uma está o que o programa mediu.

  • Constante multiplicando sai do produtório, elevada a n. Multiplicar o dobro de cada quantidade é o mesmo que multiplicar o produto por 2 × 2 × 2, um 2 para cada fator: 192 e 192.
  • Produto de duas listas separa em dois produtórios. Multiplicar x por y, par a par, é o mesmo que multiplicar os x, multiplicar os y e juntar os dois resultados: 144 e 144.
  • Produtório de uma constante é a constante elevada a n. Multiplicar o número 10 três vezes dá 10 elevado a 3: 1000 e 1000. Uma potência é um produtório em que todos os fatores são iguais.

E duas coisas para guardar:

  • O produto das somas não é a soma dos produtos. Somar x com y, par a par, e multiplicar tudo dá 125. Multiplicar cada lista e somar os dois resultados dá 30.
  • Um fator igual a zero zera tudo. Com as quantidades 3, 4, 0 e 2, o produto é 0.

Sacou? No somatório, a constante sai uma vez só. No produtório, ela sai uma vez para cada fator.

Lado a lado, os dois símbolos ficam assim:

ComparaçãoSomatório (Σ)Produtório (∏)
OperaçãoSomaMultiplicação
O acumulador começa em01
Sem nenhum valor, o resultado é01
Constante c multiplicando o termo geralSai como cSai como c elevado a n
Termo geral igual a uma constante cn × cc elevado a n
Função pronta no Pythonsummath.prod
Função pronta no PHParray_sumarray_product
As diferenças entre o somatório e o produtório.

O que o fatorial tem a ver com o produtório?

O fatorial de um número n, escrito n!, é o produto dos números inteiros de 1 até n. Em notação de produtório, o termo geral é o próprio índice:

      n
n! =  ∏ i = 1 × 2 × 3 × ... × n
     i=1

O programa calculou três: o produto de 1 até 5 é 120, o de 1 até 10 é 3.628.800, e o de 1 até 20 é 2.432.902.008.176.640.000. Repare como o resultado dispara! O limite só dobrou de 10 para 20, e o produto passou de 7 para 19 dígitos.

O fatorial será o assunto de um dos próximos artigos.

Onde mais o produtório aparece?

  • Na contagem. A conta dos combos da lanchonete é um produtório: as quantidades de opções de cada etapa, multiplicadas.
  • Na média geométrica. Ela é a raiz de ordem n do produto dos n valores. Para 2, 4 e 8, o produto é 64, e a raiz cúbica de 64 é 4, porque 4 × 4 × 4 = 64. As outras médias estão no artigo sobre as médias estatísticas.
  • Na probabilidade. Quando dois eventos são independentes, a probabilidade de os dois acontecerem é o produto das probabilidades de cada um. Se cada uma for 0,5, a dos dois juntos é 0,5 × 0,5 = 0,25.

Aí você pergunta: e se a lista estiver vazia?

Um produtório sem nenhum fator vale 1, e não 0, por definição. As funções prontas seguem a regra: no teste, math.prod([]) devolveu 1 no Python e array_product([]) devolveu 1 no PHP. Combina com o acumulador: se o laço não dá nenhuma volta, a variável continua com o 1 do começo.

É a mesma ideia do expoente zero, do artigo sobre potenciação: nenhuma multiplicação feita, resultado 1. E é por essa regra que o fatorial de 0 vale 1.

Aí você pergunta: dá para trocar um produtório por um somatório?

Dá, com a ajuda do logaritmo. O logaritmo de um produto é igual à soma dos logaritmos dos fatores. Na última linha da saída, o logaritmo de 24 e a soma dos logaritmos de 3, 4 e 2 deram o mesmo número: 1,3802.

Para o programador, essa troca resolve um problema real. O produto de muitos números pequenos, como probabilidades, encolhe tão depressa que deixa de caber em uma variável. No teste, multiplicar 0,1 por ele mesmo 400 vezes deu 0.0 no Python, no PHP e no C. O resultado certo não é zero: é um número com 400 casas depois da vírgula. Somando o logaritmo de 0,1 na base 10 a cada volta, no lugar de multiplicar, o mesmo laço chegou a −400 sem perder nada. Por isso é comum guardar e somar os logaritmos das probabilidades, em vez de multiplicá-las.

Quais são os erros mais comuns com produtório?

  • Começar o acumulador com 0. Tudo o que é multiplicado por 0 dá 0. Com as três quantidades, o resultado seria 0, e não 24.
  • Esquecer de criar o acumulador antes do laço. No Python, usar total = total * 3 sem ter criado total interrompe o programa com NameError: name ‘total’ is not defined.
  • Errar os limites. Para multiplicar de 1 até 5 no Python, range(5) vai de 0 até 4, e o fator 0 zera tudo. O certo é range(1, 6), que dá 120.
  • Tirar a constante sem elevar a n. O produto de 2x deu 192, e não 2 × 24 = 48.
  • Confundir o produto das somas com a soma dos produtos. 125 não é 30.
  • Confundir ∏ com π. O maiúsculo manda multiplicar. O minúsculo é um número.
  • Esquecer que o resultado cresce depressa. O produto de 1 até 20 ainda coube em um inteiro de 64 bits nas três linguagens. O de 1 até 21, não: no teste, o Python devolveu 51090942171709440000, o PHP trocou o inteiro por um número com vírgula e mostrou 5.1090942171709E+19, e o C, com uma variável unsigned long long, mostrou 14197454024290336768, um valor errado e sem nenhum aviso.
  • Multiplicar texto por número. No Python, math.prod([‘3’, 4]) não deu erro: devolveu o texto ‘3333’, porque multiplicar um texto por 4 repete o texto. No PHP 8.3, array_product([3, “quatro”]) emitiu o aviso “Multiplication is not supported on type string” e devolveu 0.
  • Esperar resultado exato com números com vírgula. Multiplicando 0.1 dez vezes em um laço, o Python mostrou 1.0000000000000006e-10, e a comparação com 1e-10 deu falso nas três linguagens.

Agora é com você!

No papel:

  • Escreva fator por fator e calcule o produtório de 3 × i, com i de 1 até 3.
  • Leia em voz alta e calcule o somatório e o produtório de (i + 1), com i de 1 até 3.
  • Para os valores 2, 5 e 10, calcule o produto e o produto do triplo de cada valor. Depois confira a regra da constante.

No computador:

  • Altere o programa para multiplicar apenas os valores maiores que 2.
  • Escreva um laço que calcule o produto dos números pares de 2 até 10.
  • Troque o 20 por 25 no laço do fatorial e compare a saída das três linguagens.

Tente sozinho, sem pedir a resposta pronta para ninguém, nem para a IA!

Até o próximo artigo!

Confiança Sempre!!!

Fontes:

Compartilhe este artigo

Sobre quem escreve

Walmir Silva

Olá! Sou Walmir, engenheiro de software com MBA em Engenharia de Software e o cérebro por trás do GrowthCode e autor do livro "Além do Código".

Se você acha que programação é apenas sobre escrever código, prepare-se para expandir seus horizontes. Aqui, nós vamos além do código e exploramos as interseções fascinantes entre tecnologia, negócios, artes e filosofia.

Você está em busca de crescimento na carreira? Quer se destacar em um mercado competitivo? Almeja uma vida mais rica em conhecimento e realização? Então você chegou ao lugar certo. No GrowthCode, oferecemos insights profundos, estratégias comprovadas e um toque de sabedoria filosófica para catalisar seu crescimento pessoal e profissional.

Ver todos os artigos →

Continue a conversa

Compartilhe sua perspectiva

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Guardamos o IP e o navegador de quem comenta por 6 meses, para barrar spam e porque o Marco Civil da Internet pede a guarda dos registros de acesso por esse prazo. Veja como tratamos seus dados.

Encontre sua próxima resposta

O que você quer aprender?

Preferências de cookies

Os cookies opcionais começam desligados. Você pode mudar a escolha a qualquer momento por esta tela.

NecessáriosSempre ativos

Guardam a sua escolha de cookies e o código do registro dela, e mantêm o site funcionando. Não são usados para publicidade.

Contam visitas e mostram como o site é usado: Google Analytics e Microsoft Clarity, carregados pelo Google Tag Manager.

Exibem anúncios do Google AdSense sem personalização. Os cookies desta categoria limitam a repetição dos anúncios e medem o resultado deles.

Usa a sua navegação para escolher anúncios e formar públicos de anúncio: anúncios do Google escolhidos pelos seus interesses e os indicadores do Google no Analytics. Desligado, os anúncios aparecem sem personalização. Depende de Publicidade.

Também é possível bloquear cookies nas configurações do navegador. Detalhes na Política de privacidade.