O produto escalar de dois vetores tridimensionais é definido como
a) Escreva um programa que defina uma a função escvetor(u,v) para calcular o produto
. Ela deve receber os vetores como listas com 3 elementos cada e retornar uma variável de ponto flutuante.
b) Generalize a sua função para que ela funcione com um vetores de dimensão arbitrária, por exemplo, bidimensional, tridimensional, quadridimensional etc.
Dica: Para escrever uma função que aceite dimensão arbitrária use o método sum aplicado em um comprehension que varre os índices do vetor e cria uma lista onde cada elemento é o resultado da multiplicação das componentes corresondentes de cada vetor.
Por exemplo:
Teste
Resultado
print('%.2f'%escvetor([4,5,3], [3,2,1]))
25.00
print('%.2f' %escvetor(
))
-4.00
Resposta: (penalty regime:
)
a) Escreva um programa que defina uma a função escvetor(u,v) para calcular o produto
b) Generalize a sua função para que ela funcione com um vetores de dimensão arbitrária, por exemplo, bidimensional, tridimensional, quadridimensional etc.
| Teste | Resultado |
| print('%.2f'%escvetor([4,5,3], [3,2,1])) | 25.00 |
| print('%.2f' %escvetor(
|
-4.00 |
Passo 1
O enunciado pede duas coisas bem claras:
- Escrever um programa (em Python) que defina uma função chamada
escvetor(u, v)que calcule o produto escalar de dois vetores tridimensionais. A função deve receber os vetores como listas com 3 elementos cada e retornar um número de ponto flutuante. - Generalizar a função para que funcione para vetores de dimensão arbitrária (2D, 3D, 4D, …).
Informações relevantes dadas no enunciado:
- A definição do produto escalar é
. - Os vetores virão na forma de listas Python com os componentes (por exemplo,
[4,5,3]). - A sugestão é usar
sumcom uma comprehension que percorre índices e multiplica componentes correspondentes. - Testes esperados:
deve produzir 25.00; edeve produzir -4.00.
Passo 2
Vamos entender passo a passo o que é o produto escalar (a parte matemática que você precisa ter na cabeça).
- Dados dois vetores com componentes
e , o produto escalar é
- Cada termo é o produto das componentes correspondentes; depois somamos tudo.
Exemplo numérico (pequena “aula” com um exemplo concreto): - Para
e : - multiplicações par a par:
, , - soma:
- portanto
.
- multiplicações par a par:
Passo 3
Estratégia para implementar em Python (parte (a), função para 3D):
- Receber duas listas
uevcom exatamente 3 elementos cada. - Calcular o produto das componentes correspondentes e somar.
- Garantir que o retorno seja
float. - Fazer uma checagem simples de tamanho para evitar erros óbvios na prova (se os comprimentos forem diferentes, lançar uma exceção ou tratar como erro).
Passo 4
Implementação passo a passo da versão 3D (explicando cada linha do código).
Código (versão dedicada a 3D):
Código (versão dedicada a 3D):
def escvetor(u, v):
"""
Produto escalar para vetores tridimensionais.
Recebe u e v como listas com 3 elementos cada.
Retorna float.
"""
# checar se ambos têm exatamente 3 componentes
if len(u) != 3 or len(v) != 3:
raise ValueError("As listas devem ter exatamente 3 elementos.")
# calcular soma dos produtos
resultado = 0.0
resultado += u[0] * v[0] # primeiro termo u_x * v_x
resultado += u[1] * v[1] # segundo termo u_y * v_y
resultado += u[2] * v[2] # terceiro termo u_z * v_z
return float(resultado)
Explicação das linhas:
if len(u) != 3 or len(v) != 3:verifica o comprimento das listas.resultado = 0.0inicia a soma comofloat.- Cada
resultado += u[i] * v[i]multiplica componentes correspondentes e acumula. return float(resultado)garante que o retorno é de ponto flutuante.
Passo 5
Testando a função 3D e mostrando como você faria na prova sem complicação.
Exemplo com formatação pedida no enunciado:
Exemplo com formatação pedida no enunciado:
print('%.2f' % escvetor([4,5,3], [3,2,1])) # deve mostrar 25.00
Raciocínio manual (para acompanhar o código):
-
, , → → '25.00'.
Passo 6
Agora a generalização (parte (b)): o objetivo é permitir vetores de qualquer dimensão.
- Ideia: percorrer todos os índices de
0atélen(u)-1e somaru[i]*v[i]. - Importante: antes de multiplicar, checar se
len(u) == len(v). Se não forem iguais, isso não representa um produto escalar bem definido; então tratamos como erro.
Implementação genérica usando a sugestão do enunciado (comprehension +
sum):def escvetor(u, v):
"""
Produto escalar para vetores de dimensão arbitrária.
Recebe u e v como listas (ou iteráveis indexáveis) do mesmo tamanho.
Retorna float.
"""
if len(u) != len(v):
raise ValueError("As listas devem ter o mesmo tamanho.")
# comprehension que cria uma sequência de produtos u[i]*v[i], somada por sum
resultado = sum(u[i] * v[i] for i in range(len(u)))
return float(resultado)
Observações:
range(len(u))gera os índices0,1,2,...,len(u)-1.u[i] * v[i]é o produto das componentes correspondentes.sum(...)soma todos os produtos. Isso é exatamente a generalização da fórmula do produto escalar.
Passo 7
Explicando alternativas e por que escolhi essa implementação:
- Poderíamos usar
zip(u, v)comosum(x*y for x, y in zip(u, v)). Isso é frequentemente mais elegante e lida naturalmente com iteráveis. - Usei
range(len(u))porque o enunciado sugeriu uma comprehension que varre índices — é exatamente isso e é fácil de explicar e reproduzir manualmente numa prova (você escreve o loop dos índices). - Ambas as alternativas (com
rangeou comzip) são corretas; a principal exigência é checar tamanhos iguais se quiser sinalizar erro quando não batem.
Passo 8
Exemplos de uso da versão geral (para você copiar e colar e testar rápido):
print('%.2f' % escvetor([4,5,3], [3,2,1])) # saída esperada: 25.00
print('%.2f' % escvetor([4,4], [1,-2])) # saída esperada: -4.00
print('%.2f' % escvetor([1,2,3,4], [4,3,2,1])) # exemplo 4D: 20.00
Passo a passo (manual) para o segundo exemplo:
- Para
e : e . Soma . Assim ' -4.00'.
Passo 9
Dicas rápidas para a prova (truques práticos e erros comuns):
- Sempre antes de começar a somar produtos, verifique se os vetores têm o mesmo tamanho; isso evita trapalhadas.
- Se estiver sem tempo, escreva direto
sum(u[i]*v[i] for i in range(len(u)))— é curto e seguro. - Se quiser evitar a checagem de tamanhos e confiar no avaliador, use
zip(u, v); atenção:zipcorta no menor comprimento sem avisar, então pode mascarar erros de entrada. - Lembre-se de retornar
float, porque a saída pedida é de ponto flutuante (no Python,sumpode retornarintse tudo for inteiro).
Passo 10
Resumo final do que entreguei:
- Uma versão inicial específica para 3D (útil para entender passo a passo).
- Uma versão generalizada que atende ao que o enunciado exige e aos testes apresentados.
Resposta
def escvetor(u, v):
“”"
Produto escalar para vetores de dimensão arbitrária.
Recebe u e v como listas (ou iteráveis indexáveis) do mesmo tamanho.
Retorna float.
“”"
if len(u) != len(v):
raise ValueError(“As listas devem ter o mesmo tamanho.”)
resultado = sum(u[i] * v[i] for i in range(len(u)))
return float(resultado)
“”"
Produto escalar para vetores de dimensão arbitrária.
Recebe u e v como listas (ou iteráveis indexáveis) do mesmo tamanho.
Retorna float.
“”"
if len(u) != len(v):
raise ValueError(“As listas devem ter o mesmo tamanho.”)
resultado = sum(u[i] * v[i] for i in range(len(u)))
return float(resultado)