Funções por partes são as vezes úteis quando a relação entre uma variável dependente e uma independente não pode ser adequadamente representada por uma única equação. Por exemplo, a velocidade de um foguete pode ser descrita por
v(t)= 11 t^2-5 t & 0 <= t <= 10 1100-5 t & 10 <= t <= 20 50 t+2(t-20)^2 & 20 <= t <= 30 1520 e^-0,2(t-30) & t>30 0 & qualquer outro valor
Desenvolva uma função no Scilab, Octave ou Python bem estruturada para calcular v em função de t. Em seguida, use esta função para gerar uma tabela de v versus t para t=-5 à 50 em incrementos de 0,5. Plote o gráfico 2D dessa função, eixo horizontal tempo (segundos), eixo vertical velocidade (m/s).

Passo 1

O enunciado define uma função por partes para a velocidade v(t) de um foguete e pede que a implementemos em Python, geremos uma tabela de v versus t para t variando de -5 a 50 com passo 0,5 e, por fim, plotemos o gráfico 2D (tempo no eixo x, velocidade no eixo y).

Passo 2

Vamos implementar uma função vetorizada velocity(t) usando NumPy. Essa função vai receber um array (ou escalar) de instantes de tempo e retornar o array correspondente de velocidades . Para cada intervalo de , aplicamos a fórmula correta:
import numpy as np

def velocity(t):
    """
    Calcula v(t) definido por partes:
      \(0<=\) t \(<=10\):      \(11\)*\(t^2\) - \(5\)*t
      \(10<=\) t \(<=20\):     \(1100\) - \(5\)*t
      \(20<=\) t \(<=30\):     \(50\)*t \(+2\)*(t-\(20\))**\(2\)
      t > \(30\):          \(1520\) * exp(-\(0.2\)*(t-\(30\)))
      qualquer outro: \(0\)
    """
    # Converte t para array NumPy
    t \(=\) np.array(t, dtyp\(e=f\)loat)
    # Cria vetor de saída preenchido com \(0\)
    v \(=\) np.\(zeros_like\)(t)
    # Máscaras para cada trecho
    mask\(1=\) (t >\(=0\))  & (t <\(=10\))
    mask\(2=\) (t >\(=10\)) & (t <\(=20\))
    mask\(3=\) (t >\(=20\)) & (t <\(=30\))
    mask\(4=\) (t > \(30\))
    # Aplica as fórmulas
    v[mask\(1\)] \(=11\)*t[mask\(1\)]**\(2\) - \(5\)*t[mask\(1\)]
    v[mask\(2\)] \(=1100\) - \(5\)*t[mask\(2\)]
    v[mask\(3\)] \(=50\)*t[mask\(3\)] \(+2\)*(t[mask\(3\)] - \(20\))**\(2\)
    v[mask\(4\)] \(=1520\) * np.exp(-\(0.2\)*(t[mask\(4\)] - \(30\)))
    return v

Passo 3

Geramos o vetor de instantes de tempo de a com passo usando np.arange:
\(t_values =\) np.arange(-\(5\), \(50.5\), \(0.5\))

Passo 4

Aplicamos a função velocity aos valores de tempo para obter o vetor de velocidades:
\(v_values =\) velocity(\(t_values\))

Passo 5

Para montar a tabela de v versus t, podemos imprimir um cabeçalho e depois cada par (t,v). Por exemplo:
print(f"{'t (s)':>8} | {'v (m/s)':>8}")
print("-" * 19)
for t, v in zip(t_values, v_values):
    print(f"{t:8.1f} | {v:8.2f}")

Passo 6

Finalmente, plotamos o gráfico usando Matplotlib, definindo labels, título e grade:
import matplotlib.pyplot as plt

plt.figure(figsize\(=\)(\(8,5\)))
plt.plot(\(t_values\), \(v_values\), '-o', markersize\(=4\), linewidth\(=1\))
plt.xlabel('Tempo \(t\) (s)')
plt.ylabel('Velocidade \(v(t)\) (m/s)')
plt.title('Velocidade do foguete em função do tempo')
plt.grid(True)
plt.xlim(-\(5\), \(50\))
plt.\(tight_layout\)()
plt.show()

Resposta

Segue o código completo em Python que implementa a função, gera a tabela e plota o gráfico:
import numpy as np
import matplotlib.pyplot as plt

def velocity(t):
    """
    Calcula \(v(t)\) definido por partes:
      \(0 \leq t \leq 10\):      \(11 \cdot t^2 - 5 \cdot t\)
      \(10 \leq t \leq 20\):     \(1100 - 5 \cdot t\)
      \(20 \leq t \leq 30\):     \(50 \cdot t + 2 \cdot (t - 20)^2\)
      \(t > 30\):          \(1520 \cdot \exp(-0.2 \cdot (t - 30))\)
      qualquer outro: \(0\)
    """
    t = np.array(t, dtype=float)
    v = np.zeros_like(t)
    mask1 = (t >= 0) & (t <= 10)
    mask2 = (t >= 10) & (t <= 20)
    mask3 = (t >= 20) & (t <= 30)
    mask4 = (t > 30)
    v[mask1] = 11 * t[mask1]**2 - 5 * t[mask1]
    v[mask2] = 1100 - 5 * t[mask2]
    v[mask3] = 50 * t[mask3] + 2 * (t[mask3] - 20)**2
    v[mask4] = 1520 * np.exp(-0.2 * (t[mask4] - 30))
    return v

# Gera dados
\(t_values =\) np.arange(-5, 50.5, 0.5)
\(v_values =\) velocity(t_values)

# Imprime tabela
print(f"{'t (s)':>8} | {'v (m/s)':>8}")
print("-" * 19)
for t, v in zip(t_values, v_values):
    print(f"{t:8.1f} | {v:8.2f}")

# Plota gráfico
plt.figure(figsize=(8,5))
plt.plot(t_values, v_values, '-o', markersize=4, linewidth=1)
plt.xlabel('Tempo \(t\) (s)')
plt.ylabel('Velocidade \(v(t)\) (m/s)')
plt.title('Velocidade do foguete em função do tempo')
plt.grid(True)
plt.xlim(-5, 50)
plt.tight_layout()
plt.show()

Exercícios relacionados