Lista 13 · Integrando dados medidos

Acompanha o capítulo 13. Integrar tabelas de medições: faixa por faixa, com a integral acumulada, e atenção à deriva.

Baixar o caderno

Como esta lista funciona

Abra o caderno no Colab, escreva a sua solução no lugar do # TODO e rode a célula de teste logo abaixo. Ela mesma diz o que passou e o que falhou — você não precisa esperar correção de ninguém.

O código de cada exercício também está aqui embaixo, caso você prefira colar num editor local. Os testes comparam números com tolerância.

Exercícios marcados com ✏️ são à mão, no papel, com 4 casas decimais — como na parte em papel das avaliações.

Exercício 01

✏️ À mão. A velocidade de um carro saindo de um semáforo foi registrada a cada 2 s:

\(t\) (s)	0	2	4	6	8
\(v\) (m/s)	0	6	10	12	12

a) Calcule a distância acumulada até cada instante, pela regra do trapézio.

b) Em que intervalo de 2 s o carro percorreu mais metros? Por quê?

c) Se o velocímetro tivesse um erro fixo de +0,5 m/s, quanto a distância total sairia errada?

Exercício 02

Escreva integral_acumulada(t, y), que devolve um array com a integral de \(y\) de \(t_0\) até cada \(t_i\):

\[ E_0 = 0, \qquad E_i = E_{i-1} + \frac{(t_i - t_{i-1})(y_{i-1} + y_i)}{2}. \]

integral_acumulada([0, 2, 4, 6, 8], [0, 6, 10, 12, 12])    # -> [ 0.  6. 22. 44. 68.]

import numpy as np


def integral_acumulada(t, y):
    """Array com a integral de y desde t[0] até cada t[i] (trapézio faixa a faixa)."""
    E = np.zeros(len(t))
    # TODO: para i de 1 em diante, E[i] = E[i - 1] + a área da faixa i
    return E


# --- testes (não altere) ---
E = integral_acumulada([0, 2, 4, 6, 8], [0, 6, 10, 12, 12])
esperado = [0, 6, 22, 44, 68]
for i in range(5):
    assert abs(E[i] - esperado[i]) < 1e-12, f"posição {i}: veio {E[i]}"
E = integral_acumulada([0, 0.5, 2], [2, 2, 2])
assert abs(E[2] - 4) < 1e-12, "espaçamento irregular"
print("Exercício 02: todos os testes passaram!")

Exercício 03

Esporte — a marca dos 80 m. O GPS de um corredor registrou a velocidade (m/s) a cada segundo. Escreva instante_da_distancia(t, v, d), que devolve o primeiro instante da tabela em que a distância acumulada chega a d (ou None, se não chegar). A integral_acumulada já está escrita.

t = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
v = [0, 4.2, 6.8, 8.1, 8.9, 9.3, 9.5, 9.6, 9.6, 9.5, 9.5, 9.4, 9.3]
instante_da_distancia(t, v, 80)     # -> 10

import numpy as np


def integral_acumulada(t, y):
    """JÁ ESCRITA."""
    E = np.zeros(len(t))
    for i in range(1, len(t)):
        E[i] = E[i - 1] + (t[i] - t[i - 1]) * (y[i] + y[i - 1]) / 2
    return E


def instante_da_distancia(t, v, d):
    """Primeiro instante da tabela em que a distância acumulada chega a d."""
    # TODO: a integral acumulada e um laço procurando o primeiro >= d
    pass


# --- testes (não altere) ---
t = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
v = [0, 4.2, 6.8, 8.1, 8.9, 9.3, 9.5, 9.6, 9.6, 9.5, 9.5, 9.4, 9.3]
assert instante_da_distancia(t, v, 80) == 10
assert instante_da_distancia(t, v, 10) == 3
assert instante_da_distancia(t, v, 1000) is None, "não chega a 1 km"
print("Exercício 03: todos os testes passaram!")

Exercício 04

Eletrônica — a carga de uma bateria. Um carregador registra a corrente (A) em alguns minutos da carga. A carga entregue, em ampère-hora (Ah), é a integral da corrente no tempo em horas. Escreva carga_ah(minutos, corrente).

minuto	0	10	20	30	45	60	90	120
corrente (A)	2,0	2,0	2,0	1,8	1,4	1,0	0,5	0,2

Se a bateria tem 3 Ah e estava com 30 %, ela terminou carregada?

def carga_ah(minutos, corrente):
    """Carga (Ah) entregue a uma bateria: integral da corrente (A) no tempo (em horas)."""
    total = 0.0
    # TODO: trapézio faixa a faixa, com a largura convertida para horas
    return total


# --- testes (não altere) ---
assert abs(carga_ah([0, 10, 20, 30, 45, 60, 90, 120], [2.0, 2.0, 2.0, 1.8, 1.4, 1.0, 0.5, 0.2]) - 2.2333333333333334) < 1e-12
assert abs(carga_ah([0, 60], [1.0, 1.0]) - 1.0) < 1e-12, "1 A durante 1 hora = 1 Ah"
print("Exercício 04: todos os testes passaram!")

Exercício 05

Saneamento — a caixa-d'água. A vazão que entra (da rua) e a que sai (para a casa) foram registradas em alguns minutos. O volume muda com a diferença entre as duas. Escreva volume_final(t, entrada, saida, V0), que parte do volume V0 (L) e soma a integral de (entrada − saída).

volume_final([0, 30, 60, 90, 120], [20, 20, 15, 0, 0], [5, 12, 25, 18, 6], 500)

def volume_final(t, entrada, saida, V0):
    """Volume (L) de uma caixa-d'água depois de todo o período: V0 + integral de
    (entrada - saída), com as vazões em L/min e t em minutos."""
    V = V0
    # TODO: trapézio faixa a faixa da vazão líquida (entrada - saída)
    return V


# --- testes (não altere) ---
assert abs(volume_final([0, 30, 60, 90, 120], [20, 20, 15, 0, 0], [5, 12, 25, 18, 6], 500) - 35.0) < 1e-9
assert abs(volume_final([0, 10], [5, 5], [5, 5], 300) - 300) < 1e-12, "entra o mesmo que sai: volume constante"
print("Exercício 05: todos os testes passaram!")

Exercício 06

Sensores — corrigindo a deriva. Um acelerômetro parado deveria ler zero, mas lê um pequeno valor fixo (o offset). Se o aparelho começa parado, dá para estimar o offset pela média das primeiras leituras e subtraí-lo de todas. Escreva remove_offset(a, n_parado), que faz isso (média = np.sum dividido pela quantidade).

import numpy as np
a = np.array([0.02, 0.03, 0.01, 0.52, 1.02, 0.52, 0.02])
remove_offset(a, 3)    # -> [0.   0.01 -0.01  0.5  1.   0.5  0.  ]

import numpy as np


def remove_offset(a, n_parado):
    """Subtrai de todas as leituras a média das n_parado primeiras (sensor parado)."""
    # TODO: a média das n_parado primeiras (fatia a[:n_parado]) e a subtração
    pass


# --- testes (não altere) ---
import numpy as np


r = remove_offset(np.array([0.02, 0.03, 0.01, 0.52, 1.02, 0.52, 0.02]), 3)
assert r is not None, "faltou o return?"
esperado = [0.0, 0.01, -0.01, 0.5, 1.0, 0.5, 0.0]
for i in range(7):
    assert abs(r[i] - esperado[i]) < 1e-12, f"posição {i}: veio {r[i]}"
print("Exercício 06: todos os testes passaram!")

Exercício 07

Energia — a metade do dia. A que horas um painel solar já gerou metade da energia do dia? Escreva hora_da_metade(t, p), que calcula a integral acumulada (já escrita) e devolve o primeiro instante em que ela chega à metade do total (o último valor).

Num dia de sol limpo, a resposta é perto do meio-dia. Num dia de manhã nublada e tarde de sol, seria antes ou depois?

import numpy as np


def integral_acumulada(t, y):
    """JÁ ESCRITA."""
    E = np.zeros(len(t))
    for i in range(1, len(t)):
        E[i] = E[i - 1] + (t[i] - t[i - 1]) * (y[i] + y[i - 1]) / 2
    return E


def hora_da_metade(t, p):
    """Primeiro instante em que a integral acumulada chega à metade do total."""
    # TODO: a acumulada; o total é o último valor; procure o primeiro >= metade
    pass


# --- testes (não altere) ---
assert hora_da_metade([6, 9, 12, 15, 18], [0, 2, 4, 2, 0]) == 12, "sol simétrico: meio-dia"
assert hora_da_metade([6, 9, 12, 15, 18], [0, 0, 2, 4, 0]) == 15, "manhã nublada: depois do meio-dia"
print("Exercício 07: todos os testes passaram!")