Raízes - Quique perfeito

Nome Completo – Turma ??? (Matricula: )

DD/MM/AAAA

Resumo
O experimento consiste em modelar matematicamente o movimento de um objeto após tocar o solo e
fazer o movimento de parábola até tocar novamente o solo (quique).O movimento de quique
corresponde ao movimento parabólico do objeto. A ideia é encontrar a velocidade inicial logo após o
quique da bola, utilizando técnicas de raízes e comparar com velocidade inicial medida a partir das
imagens capturadas.

Materiais e ferramentas
Celular ou outro equipamento com câmera;
objeto;
régua;
Media Player Classic (MPC);
Paint.

Metodologia
O modelo físico que descreve o movimento em parábola para uma partícula em gravidade constante é
dado por:

Figura 1: Modelo do movimento de partícula em que θ é o ângulo inicial de lançamento, y0 é a altura inicial do
arremesso, y é a altura no fim da parábola, x é a distância percorrida (Δx) do início do lançamento até o alvo no
eixo x, g é a gravidade (9,81m/s2) e v0 é a velocidade inicial, que desejamos descobrir utilizando os métodos
numéricos.

Para o modelo precisamos descobrir a posição de 4 quadros de momentos específicos e ter uma
referência (régua) para converter a aceleração da gravidade de metros para pixels. Desta forma,
acomode o celular no solo de forma a filmar parado e em modo paisagem (deitado) todo o trajeto do
quique do objeto (desde tocar o solo a primeira vez até tocar o solo a segunda vez) e a régua como
referência. Faça a filmagem e, a partir do vídeo (com a ajuda do MPC), capture 4 quadros e anote seus
tempos com precisão de milissegundos:
● quadro 1: um quadro antes do objeto deixar o solo no primeiro quique.
● quadro 2: Um quadro após o primeiro quadro
● quadro 3: Instante com a altura máxima atingida pelo objeto no quique
● quadro 4: Momento em que o objeto toca o solo novamente.

Para cada imagem capturada a partir do vídeo, o aluno deve descobrir a posição (em pixel) do centro
do objeto na imagem (estimado). Utilize o Paint para descobrir a posição do objeto. O tempo com
precisão de milissegundos deve ser registrado para cada quadro capturado.
Experimento
A partir do vídeo, descubra o instante exato de cada quadro capturado (precisão de ms) e a posição x e
y do objeto em cada quadro (em pixel)

1 2 3 4

Tempo (s)

x (px)

y (px)

Utilizando os seus conhecimentos de trigonometria e aos quadros 1 e 2, descubra o ângulo inicial de

lançamento (em radianos). (Dica: Use a função np.arctan(), presente no python, para calcular o
arco tangente.)

Θ=______________(radianos)

Utilizando o tamanho da régua, em pixel, qualquer quadro, converta a gravidade de 9,81m/s² para px/s²
(pixel por segundos²).

g=____________(px/s²)
Reescreva a equação presente na Figura 1 para o formato F(v0)=0, passando o y da equação para o
lado direito e substituindo todas as constantes já calculadas.

F(v0)= _____________________ [1]

Aplicação dos métodos
Dada a equação [1], calculada anteriormente, deseja-se encontrar o valor de v0, de modo que F(v0)=0.
Para tanto, encontre um valor inicial para v0, utilizando os quadros 1, 2 e 3, e chame de v0_gráfico.

(𝑥2−𝑥1)
𝑣0𝑥 = (𝑡2−𝑡1)
= ____________

𝑣0𝑦 = 𝑔 * (𝑡3 − 𝑡1)= ______________

2 2
𝑣0𝑔𝑟𝑎𝑓𝑖𝑐𝑜 = 𝑣0𝑥 + 𝑣0𝑦 =______________________ (pixel/s)

Trace o gráfico da função F(v0), dando destaque ao valor de v0_gráfico calculado anteriormente,
fazendo o v0 variar de (0.5*v0_gráfico) até (2*v0_gráfico), com passo de 1. Altere o código abaixo para
gerar o gráfico da função.

import numpy as np
import matplotlib.pyplot as plt

def f(v0):
s = ????? #sua função aqui
return s

v0grafico= ????? # valor calculado

v0=np.arange(0.5*v0grafico, 2*v0grafico)

saida=f(v0)

plt.plot(v0,saida)
plt.grid()
Explique se no intervalo de v0 variando de 0.5*v0gráfico até 2*v0gráfico possui raízes. Justifique sua
resposta.

Reposta:

−4
Utilizando o método da bisseção, com os critérios de parada de erro relativo menor do que 10 , ou
1000 iteração, e considerando o intervalo com solução encontrado anteriormente. Destaque no gráfico
todos os valores de v0 encontrados pelo método até que um critério de parada seja atingido.
Modifique o código abaixo para gerar o gráfico de solução por bisseção e completar as informações
solicitadas.

plt.plot(v0,saida) #plota x por y (gera gráfico)

plt.grid() #insere o Grid na tela
plt.plot(v0grafico,0,'ro') #coloca um ponto vermelho na solução gráfica

"""bisseçao"""
def bissecao(a,b,p,n):
if f(a)*f(b)>0:
print("Não é possível aplicar o método da Bisseção neste intervalo")
else:
erro=1
cont=0
m=a
while erro>10**(-p) and n>cont:
ma=m
m=(a+b)/2 #solução intermediária
plt.plot(m,0,'go') #coloca ponto verde nas soluções intermediárias
if f(a)*f(m)<0:
b=m
else:
a=m
erro=np.fabs(m-ma)/np.fabs(m)
cont+=1
plt.plot(m,0,'yo') #coloca um ponto amarelo na solução final
print(m)
print(erro)
print(cont)

#chamada
bissecao(????,????,????,????) #definir os valores das entradas (INICIO,FIM,
NUMERO DE CASAS DECIMAIS, MAXIMO DE ITERAÇÕES )
Resultado1: Bisseção

Solução Bisseção Erro Iterações

Altere o algoritmo da bisseção para que este implemente o método da falsa posição. Considera as
mesmas entradas utilizadas anteriormente, apresente graficamente as soluções sucessivas
encontradas pelo método até um critério de parada ser atingido.
(𝑏−𝑎)
(DICA: as soluções intermediárias na falsa posição são calculadas por: 𝑚 = 𝑎 − 𝑓(𝑎) (𝑓(𝑏)−𝑓(𝑎))
)

Resultado2: Falsa Posição

Solução Falsa Posição Erro Iterações

Para a aplicação do método de Newton, deve-se encontrar a derivada da função em relação a variável
v0. O resultado dessa derivada será:

DF(v0)=_________________

def df(v0):
s=??????? #sua derivada aqui
return s

Utilizando o v0_gráfico como valor inicial, DF(v0), F(v0) e o algoritmo do método de Newton para
encontrar raízes, destaque graficamente as soluções sucessivas encontradas pelo método até o critério
de parada ser atingido (usar os mesmos critérios que foram utilizados para os métodos anteriores.)

plt.plot(v0,saida) #plota x por y (gera gráfico)

plt.grid() #insere o Grid na tela
plt.plot(v0grafico,0,'ro') #coloca um ponto vermelho na solução gráfica

def newton(xn,p,n):
cont=0
erro=1
while erro>10**(-p) and cont<n:
xa=xn
xn=xa-f(xa)/df(xa)
plt.plot(xn,0,'go')
erro=np.fabs((xn-xa)/xn)
cont=cont+1
plt.plot(xn,0,'yo')
print(xn)
print(erro)
print(cont)

#chamada
newton(v0grafico,????,????) #colocar as entradas aqui (Valor inicial, precisão,
iterações máximas)
Resultado3: Newton

Solução Newton Erro Iterações

Altere o algoritmo abaixo para implementar o método da Secante. Utilize o valor de v0gráfico e
v0gráfico+1 como entradas, além do erro e número máximo de iterações já utilizado. Destaque
graficamente as sucessivas soluções apresentadas pelo método até encontrar o resultado.

"""secante"""
plt.plot(v0,saida) #plota x por y (gera gráfico)
plt.grid() #insere o Grid na tela
plt.plot(v0grafico,0,'ro') #coloca um ponto vermelho na solução gráfica

def secante(x1,x2,p,n):
cont=0
erro=1
while erro>10**(-p) and cont<n:
x0=x1
x1=x2
x2=x1-f(x1)*(x0-x1)/(f(x0)-f(x1))
plt.plot(x2,0,'go')
erro=np.fabs((x2-x1)/x2)
print(erro)
cont=cont+1
plt.plot(x2,0,'yo')
print(x2)
print(erro)
print(cont)
#chamada
secante(v0grafico,v0grafico+1,????,????)

Resultado4: Secante

Explique a diferença entre os métodos da falsa posição e da secante.

Resposta: