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;
avidemux (ou outro player que forneça a precisão do tempo do vídeo em milissegundos, como o Media
Player Classic).
inkscape (ou outro editor de imagem que forneça a posição em pixel do objeto na imagem, ex: 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 avidemux), capture 4 quadros:
 ● 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.

Figura 1: Quadro 1: momento em que o objeto perde o contato com o arremessador

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 Inkscape (ou Paint) para descobrir a posição do objeto e
lembre-se de conferir se a posição do eixo Y (altura do objeto) começa da base da figura. Caso a altura
comece do topo, lembre-se de inverter as medidas usando a altura máxima da figura. 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 (em ms) e a posição x e y do
objeto em cada quadro (em pixel)

Tempo:___________

Quadro 1 X:___________

Y:___________

Tempo:___________

Quadro 2 X:___________

Y:___________
 Tempo:___________

Quadro 3 X:___________

Y:___________

Tempo:___________

Quadro 4 X:___________

Y:___________

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

lançamento (em radianos).

Θ=______________(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.

( x 2−x 1)
v 0 x= =¿ ____________
(t 2−t 1)

v 0 y =g∗(t 3−t 1)= ______________

v 0 grafico=√❑=______________________ (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.

Gráfico da função F(v0)

Utilizando o método da bisseção (algoritmo 1), com os critérios de parada de erro relativo menor do que
−4
1 0 , ou 1000 iteração, e considerando o intervalo de 0.5*v0_gráfico até 1.5*v0_gráfico para v0.
Destaque no gráfico todos os valores de v0 encontrados pelo método até que um critério de parada seja
atingido.

V0_Bisseç
ã:

Iterações:
Gráfico da função F(v0)
+
Destaque das aproximações Erro:

Resultado1: Bisseção

Altere o algoritmo 1 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.

V0_Falsa
Posição:

Iterações:
Gráfico da função F(v0)
+
Destaque das aproximações Erro:

Resultado2: Falsa Posição

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)=_________________

Utilizando o v0_gráfico como valor inicial, DF(v0), F(v0) e o algoritmo do método de Newton para
encontrar raízes (algoritmo 2), 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.)

V0_Newto
n:

Iterações:
Gráfico da função F(v0)
+
Destaque das aproximações Erro:

Resultado3: Newton

Altere o algoritmo de Newton para implementar o método da Secante. Utilize as mesmas entradas do
método da Bisseção e destaque graficamente as sucessivas soluções apresentadas pelo método até
encontrar o resultado.

V0_Secante
:

Iterações:
Gráfico da função F(v0)
+
Destaque das aproximações Erro:

Resultado4: Secante
Comente qual dos métodos convergiu mais rápido, justificando e apresentando pontos positivos e
negativos da aplicação desse método.
Algoritmos
Algoritmo 1: Bisseção Algoritmo 2: Newton

def f(v0): def f(v0):

y=... #sua função aqui y=... #sua função aqui
return y return y

def bissecao(a,b,p,n): def df(v0):

if f(a)*f(b)>0: y=... #sua df aqui
return df
print("Não é possível aplicar o
método da Bisseção neste intervalo") def newton(xn,p,n):
else: cont=0
erro=1 erro=1
cont=0 while erro>10**(-p) and cont<n:
m=a xa=xn
while erro>10**(-p) and n>cont: xn=xa-f(xa)/df(xa)
ma=m
print(xn)
m=(a+b)/2
erro=np.fabs((xn-xa)/xn)
print(m)
if f(a)*f(m)<0:
cont=cont+1
b=m print(erro)
else: print(cont)
a=m
erro=np.fabs(m-ma)/np.fabs(m) #chamada
cont+=1 newton(v0g/2,p,n)
print(erro)
print(cont)

#chamada
bissecao(v0g/2,2*v0g,p,n) #definir os
valores das entradas