Introdução Linguagem Julia para física experimental.ipynb

Kernel: Julia 1.10

This notebook was created by João Marcello Pereira, and is licensed under Creative Commons BY-SA

Objetivo do tutorial

Este guia serve apenas para você aprender conceitos básicos da linguagem Julia para serem utilizados nos cálculos estatísticos e cálculos com incertezas de medição e propagação de incertezas. Para aprender mais sobre a linguagem baixe os arquivos em: https://bit.ly/tutorial-basico-python-julia-fisica . As versões mais atuais deste tutorial podem ser encontradas para download em https://bit.ly/fisica-experimental.

Linguagem Julia

Julia é uma linguagem de programação opensource com foco em computação científica que surgiu em 2012 com a proposta de ser fácil de aprender e rápida para processar dados. De acordo com o gráfico abaixo, temos um benchmark no qual foi rodado vários códigos matemáticos que são utilizados como testes de desempenho (quanto menor o tempo de execução melhor) no qual podemos observar o poder de processamento de Julia em relação a outras linguagens de computação científica.

A linguagem vem crescendo desde 2012 e nasceu com a proposta de ser concorrente das linguagens Python, R, MatLab e Fortran. Conforme gráfico da TIOBE (https://www.tiobe.com/tiobe-index/) Julia ocupa atualmente a 26º posição das linguagens mais populares.

Para saber mais sobre a linguagens recomendo a leitura dos seguintes artigos:

https://periodicos.ifpb.edu.br/index.php/principia/article/viewFile/1345/661

https://engenharia360.com/julia-linguagem-de-programacao-que-quer-substituir-python-r-e-matlab/

Parte I

A ideia deste tutorial não é fazer o aluno apredender a programar na linguagem Julia, mas sim ensiná-lo a operar comandos de cálculos estatísticas e de incerteza de medidas como uma calculadora avançada. Caso queira aprender Julia há um excelente material neste link: https://bit.ly/tutorial-basico-python-julia-fisica

Conhecimentos inicias da linguagem

• Julia é case-sensitive, ou seja, variáveis com nomes maiúsculos e minúsculos são diferentes;

    Peso e peso -> são variáveis diferentes    
  

• NÃO USE ACENTOS OU OUTROS RECURSOS SINTÁTICOS DA LÍNGUA PORTUGUESA PARA NOMES DE VARIÁVEIS. Apesar de funcionar no Jupyter, nem todos os interpretadores garantem a funcionalidade;

    posição -> Errado!
    posicao -> Certo.        
  

• Julia é uma linguagem de tipagem dinâmica, logo o tipo de dado é definido quando o valor é atribuído a uma variável;

    a = 5   {tipo inteiro}
    a = 5.0 {tipo float}        
  

• Não é necessário ponto e vírgula ao final de um comando. Se fizer isso, o resultado do cálculo será omitido;

• A identação não é essencial na linguagem mas segui-la garante uma boa organização do código;

• Nomes dos pacotes sempre começarão com letra maiúscula Ex: IJulia, Calculus, Interpolations, LinearAlgebra.

Conhecimentos inicias da interface Web Jupyter Notebook

O Jupyter é uma aplicação web derivado do IPython que significa JUlia, PYThon, and R . Resumidamente, é um ambiente computacional interativo que permite aos usuários criar "notebooks" que incluem: código, widgets interativos, gráficos, texto, equações, imagens, vídeo e outros. O Jupyter combina três componentes:

• O Jupyter Notebook: um aplicativo web interativo para escrever e executar códigos de várias linguagens de programação.

• Kernels: "Os kernels são processos específicos de linguagem de programação que funcionam independentemente e interagem com os aplicativos Jupyter e suas interfaces de usuário" (JUPYTER, 2017). Jupyter possui suporte para mais de 50 linguagens de programação (github.com/jupyter/jupyter/wiki/Jupyter-kernels), incluindo as mais populares em computação científica como Python, R, Julia e Scala. O IJulia.jl é kernel da linguagem Julia.

• Notebooks: são arquivos com extensão ipynb que contêm a estrutura do código no formato JSON. Cada notebook possui seu próprio kernel.

Caracteristicas:

• Instalação fácil, já está presente no Anaconda (www.anaconda.com/download) e disponível para as plataformas Windows, Linux e MacOS.

• Possui uma interface web avançada que permite combinar código-fonte, textos, fórmulas, figuras e multimídia em um único documento.

• Pode ser executado em um computador local ou servidor remoto.

• Suporta mais de 50 linguagens de programação, entre os quais R, Julia e Scala.

• Permite compartilhar documentos.

• Podemos executar e visualizar imagens, vídeos, textos LaTeX e Markdown, além de manipular os resultados em tempo real.

• Documentos feitos em Jupyter Notebook podem ser exportados para diferentes formatos (PDF, HTML, reStructeredText, LaTeX, Slides, Markdown e outros)

Para aprender sobre interface Jupyter Notebook, acesse este vídeo: https://www.youtube.com/watch?v=dPb4acFiaYs

Comandos básicos

Matemática elementar

# soma e subtração. 
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

2.0 + 5.0

7.0

# treino: calcule 589.01 + 2.56

# soma e subtração. 
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

2.0 - 5.0

-3.0

# treino: calcule 589.01 - 2.56

# multiplicação e divisão. 
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

2.0 * 5.0

10.0

# treino: calcule 589.01 * 2.56

# multiplicação e divisão. 
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

2.0 / 5.0

0.4

# treino: calcule 589.01 dividido por 2.56

# potenciação e logarítmo. 
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

2.0^3.0

8.0

# treino: calcule 5.9 elevado a -2

# potenciação e logarítmo. 
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

exp(2)

7.38905609893065

# treino: calcule 'e' elevado a -3

# potenciação e logarítmo. 
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

exp(2.0)

7.38905609893065

# treino: calcule exponencial e -3

# potenciação e logarítmo. 
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

log(100.0, 10)

0.5

# treino: calcule logaritimo de 20000 na base 10 e na base 2

Trigonometria

# seno de 30 radiano. 
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

sin(30.0)

-0.9880316240928618

# treino: calcule o seno de 60 radianos

# seno de 30 graus.   
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

sind(30.0)

0.5

# treino: calcule o seno de 60º

# cosseno de 30 graus.
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

cosd(30)

0.8660254037844386

# treino: calcule o cosseno de 60º

# tangente de 30 graus.  
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

tand(30)

0.5773502691896258

# treino: calcule a tangente de 60º

# calcular o angulo em graus do arco seno de 0.5. 
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

asind(0.5)

30.000000000000004

# treino: calcular o angulo em radianos do arco seno de 0.74. 

# calcular o angulo em graus do arco cosseno de 0.5. 
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

acosd(0.5)

60.00000000000001

# treino: calcular o angulo em radianos do arco cosseno de 0.74. 

# calcular o angulo em graus do arco tangente de 0.5. 
# Para processar o cálculo execute shit+enter no teclado ou toque em Runn

atand(0.5)

26.56505117707799

# treino: calcular o angulo em graus do arco tangente de 0.74. 

Instalação de pacotes

# instalar pacotes. Se ja instalou não precisa instalar novamente
# Para processar o cálculo execute shit+enter no teclado ou toque em Run
# os pocotes só podem ser instalados na versão onffline (Jupyter máquina local), no cocalc só se pagar o plano.

using Pkg

Pkg.add("DataFrames")
Pkg.add("CSV")
Pkg.add("QuadGK")
Pkg.add("Measurements")
Pkg.add("Calculus")
Pkg.add("Plots")
Pkg.add("Statistics")
Pkg.add("Interpolations")

    Updating registry at `~/.julia/registries/General.toml`
   Resolving package versions...
  No Changes to `~/.julia/environments/v1.7/Project.toml`
  No Changes to `~/.julia/environments/v1.7/Manifest.toml`
   Resolving package versions...
  No Changes to `~/.julia/environments/v1.7/Project.toml`
  No Changes to `~/.julia/environments/v1.7/Manifest.toml`
   Resolving package versions...
  No Changes to `~/.julia/environments/v1.7/Project.toml`
  No Changes to `~/.julia/environments/v1.7/Manifest.toml`
   Resolving package versions...
  No Changes to `~/.julia/environments/v1.7/Project.toml`
  No Changes to `~/.julia/environments/v1.7/Manifest.toml`
   Resolving package versions...
  No Changes to `~/.julia/environments/v1.7/Project.toml`
  No Changes to `~/.julia/environments/v1.7/Manifest.toml`
   Resolving package versions...
  No Changes to `~/.julia/environments/v1.7/Project.toml`
  No Changes to `~/.julia/environments/v1.7/Manifest.toml`
   Resolving package versions...
    Updating `~/.julia/environments/v1.7/Project.toml`
  [10745b16] + Statistics
  No Changes to `~/.julia/environments/v1.7/Manifest.toml`
   Resolving package versions...
  No Changes to `~/.julia/environments/v1.7/Project.toml`
  No Changes to `~/.julia/environments/v1.7/Manifest.toml`

Função

Basicamente, uma função em qualquer linguagem de programação, segue um conceito semelhante a uma função definida na matemática, no qual devemos substituir valores de uma variável em uma expressão algébrica e ela calcula o valor de saída. Dessa forma, podemos entender que uma função em uma linguagem de programação é como se fosse uma pequena "máquina" que recebe valores de entrada (chamados de argumentos), processa esses valores e devolve (return) um valor de saída.

Na linguagem Julia, uma função segue o seguinte esquema:

nome_função(argumento_1, argumento_2, argumento_3, ..., argumento_n) = expressão_algébrica_dos_argumentos

Exemplo 1

Criar uma função que calcule $f (5)$, sendo $f(x) = 2x^2 - 3x +2$.

# criar a função
f(x) = 2*x^2 - 3*x + 2

f (generic function with 1 method)

# testar para f(5)
f(5)

37

Exemplo 2

Criar uma função que calcule o volume de um bloco retangular de cimento. Medidas: largura = 5,0cm, comprimento = 12,0 cm e altura = 7,0 cm.

# criar a função volume
v(l, c, h) = l*c*h

v (generic function with 1 method)

# testar para as medidas
v(5,12,7)

420

Cálculo com incertezas com dados não repetidos

Incerteza de medida com equipamentos analógicos e digitais

Quando se faz uma medida com algum equipamento de medida, sempre há uma incerteza associada à medida realizada conforme o tipo de equipamentos utilizado. Uma medida é definida como:

medida = ($m \pm \Delta m$) sendo:

• $m$ -> medida realizada por um instrumento de medida

• $\Delta m$ -> incerteza da escala ou de medição do instrumento de medida

A incerteza da escala ou de medição depende do equipamento e cada um pode apresentar uma maior ou menor incerteza. e quanto menor a incerteza melhor a medição. A incerteza $\Delta m$ depende da natureza tecnológica do instrumento.

De acordo com o equipamento, podemos observar que quanto menor a incerteza, melhor a precisão da medida. O GUM (Guia para a Expressão de Incerteza de Medição) informa que:

É geralmente suficiente fornecer a incerteza com até no máximo dois algarismos significativos, embora, em alguns casos, seja necessário reter algarismos adicionais para evitar erros de arredondamento nos cálculos subsequentes.

Equipamentos de medida analógicos

De acordo com PIACENTINI et al (2012) a incerteza de escala em equipamentos analógicos é dado por:

$~~~~~~~~~~ \displaystyle \Delta{m} = \frac{\text{menor divisão da escala}}{2}$

Para uma régua ou trena comum, a menor divisão de escala é de 1mm (0,01 cm), logo, a incerteza da escala de medição é: $~~\displaystyle \Delta{m} = \frac{0,1 cm}{2} = 0,05cm$. A medida do comprimento do parafuso da figura medido com esta régua, apresenta medida definida como:

ParseError: KaTeX parse error: Expected 'EOF', got '_' at position 18: …ext{comprimento_̲parafuso} = (2,…

Equipamentos de medida não analógico:

De acordo com PIACENTINI et al (2012) a incerteza de escala em equipamentos não-analógicos é dado por:

$~~~~~~~~~~ \displaystyle \Delta{m} = \text{menor divisão da escala}$

Para um paquímetro, a incerteza da escala é $~~\displaystyle \Delta{m} = 0,05mm, ~ou~, \Delta{m} = 0,005 cm.$

Propagação de incertezas

Quando obtemos medidas, é natural utilizá-las em alguma equação ou função. Sabendo que cada medida há uma incerteza de medida, a propagação de incerteza de uma função $f(x, y, z, ..., w)$ que relaciona várias grandezas $x, y, z ...w$, cada uma definida como $x = \bar x \pm \Delta x$, $y = \bar y \pm \Delta y$, ..., $w = \bar w \pm \Delta w$. A incerteza do cálculo realizado com esta função será dada pela raiz quadrada dos quadrados das derivadas parciais das grandezas mutiplicado pelo quadrado das incertezas:

$~~~~~~~~~~ \displaystyle \Delta m= \sqrt {\left({\frac {\partial f}{\partial {x}}}\right)^{2}(\Delta x)^{2}+\left({\frac {\partial f}{\partial {y}}}\right)^{2}(\Delta y)^{2}+... +\left({\frac {\partial f}{\partial {w}}}\right)^{2}(\Delta w)^{2}}$

Exemplo 3

Como calcular a área da base do bloco abaixo.

$L = (22.00 \pm 0.05)cm$ $~~~~~C = (20.00\pm 0.05)cm$ $~~~~~ h = (9.00 \pm 0.05)cm$

$~$

$A(L,C) = L\cdot C$

$A(L,C) = 22,00\cdot 20,00 = 440cm²$

$~$

$\displaystyle {\left({\frac {\partial A}{\partial {L}}}\right)^{2}} = C^2 = 20,00^2 = 400,00 cm^2$

$\displaystyle {\left({\frac {\partial A}{\partial {C}}}\right)^{2}} = L^2 = 22,00^2 = 484,00cm^2$

$(\Delta x)^{2} = 0,05^2 = 0,0025$

$(\Delta y)^{2} = 0,05^2 = 0,0025$

$~$

$\Delta A = \displaystyle \sqrt{400,00 \cdot 0,0025 + 484,00 \cdot 0,0025}$

$\Delta A = 1,48660687473 cm^2$

$\Delta A = 1,5 cm^2$

$~$

$A = (440,0 \pm 1,5)cm^2$

# carregar o pacote de cálculo de incertezas, apenas execute shit+enter no teclado ou toque em Run

using Measurements

# definir as variáveis. 
# apenas execute shit+enter no teclado ou toque em Run

L = measurement(22.00, 0.05)
C = measurement(20.00, 0.05)
h = measurement(9.00, 0.05)

println("largura : $L")
println("comprimento : $C")
println("altura : $h")

largura : 22.0 ± 0.05
comprimento : 20.0 ± 0.05
altura : 9.0 ± 0.05

# calcular a área da base da figura geométrica
# apenas execute shit+enter no teclado ou toque em Run

A = L*C
A

440.0 ± 1.5

# calcular o volume.
# apenas execute shit+enter no teclado ou toque em Run

V = L*C*h
V

3960.0 ± 26.0

# treino:
# calcular o volume em m² de um cilindro medido com régua de raio (50.00 +/- 0.05)cm e altura (30 +/- 0.05)cm

Exemplo 4

Criar uma função para calcular a área da base.

# Função área da base
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

area(largura, comprimento) = largura*comprimento

area (generic function with 1 method)

# calcular a área da base
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

area(measurement(20.00, 0.05), measurement(20.00, 0.05))

400.0 ± 1.4

# treino:
# calcular o volume em m² de um cilindro medido com régua de raio (50.00 +/- 0.05)cm e altura (30 +/- 0.05)cm

Cálculo com equações e sistemas lineares e não lineares

Exemplo 5

Calcular uma raiz da função $f(x) = a \cdot x^2 + b \cdot x + c$, sendo $a = 1.00 \pm 0.01$, $~b = 2.00 \pm 0.01$ e $~c = -4.00 \pm 0.01$

# carregar pacotes, apenas execute shit+enter no teclado ou toque em Run

using Roots, Measurements

# definindo a equação 1
# apenas execute shit+enter no teclado ou toque em Run

eq(x) = measurement(1.00, 0.01)*x^2 + measurement(2.00, 0.01)*x - measurement(4.00, 0.01)

eq (generic function with 1 method)

# o valor inicial é 3 exato (incerteza igual a zero)
# apenas execute shit+enter no teclado ou toque em Run

find_zero(eq, (measurement(-50, 0), measurement(50, 0)))

ArgumentError: The interval [a,b] is not a bracketing interval.
You need f(a) and f(b) to have different signs (f(a) * f(b) < 0).
Consider a different bracket or try fzero(f, c) with an initial guess c.


Stacktrace:
  [1] assert_bracket
    @ /ext/julia/depot/packages/Roots/neTBD/src/Bracketing/bracketing.jl:52 [inlined]
  [2] init_state(::A42, F::Roots.Callable_Function{Val{1}, Val{false}, typeof(eq), Nothing}, x₀::Measurement{Float64}, x₁::Measurement{Float64}, fx₀::Measurement{Float64}, fx₁::Measurement{Float64}; c::Nothing, fc::Nothing)
    @ Roots /ext/julia/depot/packages/Roots/neTBD/src/Bracketing/alefeld_potra_shi.jl:59
  [3] init_state
    @ /ext/julia/depot/packages/Roots/neTBD/src/Bracketing/alefeld_potra_shi.jl:49 [inlined]
  [4] init_state(M::A42, F::Roots.Callable_Function{Val{1}, Val{false}, typeof(eq), Nothing}, x::Tuple{Measurement{Float64}, Measurement{Float64}})
    @ Roots /ext/julia/depot/packages/Roots/neTBD/src/Bracketing/bracketing.jl:6
  [5] #init#42
    @ /ext/julia/depot/packages/Roots/neTBD/src/find_zero.jl:299 [inlined]
  [6] init
    @ /ext/julia/depot/packages/Roots/neTBD/src/find_zero.jl:289 [inlined]
  [7] #solve#46
    @ /ext/julia/depot/packages/Roots/neTBD/src/find_zero.jl:491 [inlined]
  [8] find_zero(f::Function, x0::Tuple{Measurement{Float64}, Measurement{Float64}}, M::A42, p′::Nothing; p::Nothing, verbose::Bool, tracks::Roots.NullTracks, kwargs::@Kwargs{})
    @ Roots /ext/julia/depot/packages/Roots/neTBD/src/find_zero.jl:220
  [9] find_zero (repeats 2 times)
    @ /ext/julia/depot/packages/Roots/neTBD/src/find_zero.jl:210 [inlined]
 [10] find_zero(f::Function, x0::Tuple{Measurement{Float64}, Measurement{Float64}})
    @ Roots /ext/julia/depot/packages/Roots/neTBD/src/find_zero.jl:243
 [11] top-level scope
    @ In[7]:4

Sistema de equações

Exemplo 6

Calcular o sistema linear formado por :

# carregar pacotes, apenas execute shit+enter no teclado ou toque em Run

using LinearAlgebra, Measurements

# definindo a matriz dos coeficientes A e o vetor dos termos independentes b
# apenas execute shit+enter no teclado ou toque em Run

A = [measurement(1.00, 0.05) measurement(1.00, 0.05) measurement(1.00, 0.05); 
     measurement(1.00, 0.05) measurement(2.00, 0.05) measurement(2.00, 0.05); 
     measurement(2.00, 0.05) measurement(1.00, 0.05) measurement(3.00, 0.05)]

b = [measurement(6.00, 0.05), measurement(9.00, 0.05), measurement(11.00, 0.05)];

# imprimir matriz A
# apenas execute shit+enter no teclado ou toque em Run

A

3×3 Matrix{Measurement{Float64}}:
 1.0±0.05  1.0±0.05  1.0±0.05
 1.0±0.05  2.0±0.05  2.0±0.05
 2.0±0.05  1.0±0.05  3.0±0.05

# imprimir vetor dos termos independentes b
# apenas execute shit+enter no teclado ou toque em Run

b

3-element Vector{Measurement{Float64}}:
  6.0 ± 0.05
  9.0 ± 0.05
 11.0 ± 0.05

# apenas execute shit+enter no teclado ou toque em Run
# o resultado é um vetor com os valores de x, y e z

X = A\b

3-element Vector{Measurement{Float64}}:
 3.0 ± 0.43
 2.0 ± 0.17
 1.0 ± 0.32

Cálculo diferencial e integral

Podemos definir a derivada em um ponto de uma função $\displaystyle y=f(x)$ como sendo a taxa de variação instantânea de $y$ em relação a $x$ neste ponto. Geometricamente, a derivada de uma função $f(x)$ em um ponto a fornece o coeficiente angular da reta tangente ao gráfico desta função no ponto $(a, f(a))$.

$\displaystyle \frac{d}{dx}f(a) = f'(a)=\lim _{{x\rightarrow a}}{\frac {f(x)-f(a)}{x-a}}$

A definição de integral de uma função $\displaystyle {f(x)} {f(x)}$ no intervalo fechado $[a,b]$ é igual ao limite do somatório de cada um dos valores da função $f(x)$ entre de 0 e n, multiplicados por $\displaystyle \Delta x.$

$\displaystyle {\int _{a}^{b}}{f(x)dx=\lim _{\Delta x\to 0}\sum _{i=0}^{n}{f(x_{i})}\Delta x}$

Integral indefinida:

$~~~~~~~~~~~\displaystyle \int f(x)~dx$

Integral definida:

$~~~~~~~~~~~\displaystyle \int_{0}^{5} f(x)~dx$

Tabela de derivadas e integrais

Exemplo 7

Dada a função $\displaystyle f(x) = ax^2 + bx + c$ sendo $a = 3.00 \pm 0.05, ~b = 2.00 \pm 0.05, ~c = 1.00 \pm 0.05$, calcular a derivada no ponto $x = 6,00$ e a integral entre $x_1 = 0,00, ~ x_2 = 6,00$. Gráfico:

# carregar pacotes, apenas execute shit+enter no teclado ou toque em Run

using Calculus, QuadGK, Measurements

# definir a função
# apenas execute shit+enter no teclado ou toque em Run

a = measurement(3.00, 0.05)
b = measurement(2.00, 0.05)
c = measurement(1.00, 0.05)

f(x) = a*x^2 + b*x + c

f (generic function with 1 method)

# derivada definida de uma função para um valor de X específico
# apenas execute shit+enter no teclado ou toque em Run

derivative(f, 6)

38.0 ± 0.6

# integral definida de x=0 a x=6
# apenas execute shit+enter no teclado ou toque em Run

quadgk(f, 0, 6)

(258.0 ± 3.7, 5.684341886080802e-14 ± 0.0)

# treino
# calcular a derivada de f(x) = e^x + 2 no ponto x_1 = 0.00

# treino
# calcular a integral de f(x) = e^x + 2 entre x_1 = 0.00 e x_2 = 5.00

Importar arquivos de dados

# importar pacotes
# execute shit+enter no teclado ou toque em Run

using CSV, DataFrames, Plots, Measurements

Exemplo 8

Importar dos dados da aceleração g de Luzerna a partir de um arquivo CSV.

# importar dados de arquivo CSV
# para processar execute shit+enter no teclado ou toque em Run

dados = CSV.read("Arquivos/aceleracao-g-luzerna.csv", DataFrame)

100×2 DataFrame
 Row │ Tempo      Aceleracao_g 
     │ Float64    Float64      
─────┼─────────────────────────
   1 │ 0.0471455       9.72004
   2 │ 0.049651        9.72004
   3 │ 0.0521566       9.72483
   4 │ 0.0546622       9.73919
   5 │ 0.0571466       9.76074
   6 │ 0.0596055       9.76792
   7 │ 0.0620603       9.73441
   8 │ 0.0645153       9.70807
   9 │ 0.0669702       9.72722
  10 │ 0.0694255       9.74159
  11 │ 0.0718806       9.73441
  ⋮  │     ⋮           ⋮
  91 │ 0.268283        9.74877
  92 │ 0.270737        9.72483
  93 │ 0.273193        9.72483
  94 │ 0.275647        9.74159
  95 │ 0.278102        9.76074
  96 │ 0.280557        9.76074
  97 │ 0.283012        9.72722
  98 │ 0.285468        9.70568
  99 │ 0.287923        9.72962
 100 │ 0.290378        9.75116
                79 rows omitted

# calcular a quantidade de dados da aceleração
# execute shit+enter no teclado ou toque em Run

n = length(dados.Aceleracao_g)

100

Cálculos estatísticos

Apresentação de referência: https://docs.google.com/presentation/d/1f1a3nfmnZo_kbTS421jrxrYnXLjTQx18q8gmW9fquYU/edit?usp=sharing

Histograma

O histograma é uma representação gráfica de uma distribuição de frequencia de dados por meio de retângulos. Para dados experimentais repetidos de uma grandeza física, o histograma tende, conforme o número de medições, a uma curva normal (formato de sino).

# histograma dos dados da aceleração
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

histogram(dados.Aceleracao_g)

# carregar pacote, apenas execute shit+enter no teclado ou toque em Run

using Statistics

Média

A Média Aritmética de um conjunto de dados experimentais, é uma medida de tendência central, obtida somando todos os valores e dividindo o valor pelo número de dados desse conjunto. Indica o valor provável da medida.

# média
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

mean(dados.Aceleracao_g)

9.735746278689998

Desvio Padrão

O desvio padrão é uma medida de dispersão de um conjunto de dados em torno de uma média. Quanto mais próximo de zero, melhor o dado do desvio padrão, ou seja, indica que os dados coletados do experimento estão mais uniforme possível.

${\displaystyle s={\sqrt {{\frac {1}{n-1}}\sum _{i=1}^{n}(x_{i}-{\bar {x}})^{2}}}}$

# desvio padrão
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

dP = std(dados.Aceleracao_g)

0.014329568009809421

Desvio da Média

$\displaystyle s_m = \frac{\sqrt {{\frac {1}{n-1}}\sum _{i=1}^{n}(x_{i}-{\bar {x}})^{2}}}{\sqrt{n}} = \frac{s}{\sqrt{n}}$

# desvio padrão da média
# Para processar o cálculo execute shit+enter no teclado ou toque em Run

dPm = dP/sqrt(n)

0.0014329568009809421

# coeficiente distribuição T de student. Selecione de acordo com a quantidade de dados e a propabilidade de 95,45% (tabela no slide)

t = 

# incerteza aleatória

t*dPm

# treino: 
# importar os dados da aceleração g em Macapá

# treino
# calcular a quantidade de dados da aceleração g em Macapá

# treino
# plotar o histograma

# treino
# calcular a média dos dados da aceleração g em Macapá 

# treino
# calcular o desvio padrão dos dados da aceleração g em Macapá 

# treino
# calcular o desvio padrão médio dos dados da aceleração g em Macapá

# treino
# calcular a incerteza aleatória dos dados da aceleração g em Macapá 

Parte II

interpolação

Chapra e Canale (2008) definem a interpolação como a estimativa de valores entre pontos discretos bem conhecidos. A interpolação serve para determinar a correspondência $x_{interp}$ -> y_{interp} entre dois pontos A(x1, y1) e B(x2, y2) conhecidos. Os resultados de medições experimentais fornecem, em geral, um conjunto de valores em pontos discreto. O processo de calcular os valores intermediários aos valores conhecidos é chamado interpolação. Os polinômios interpoladores de Lagrange formam uma classe específica de polinômios que podem ser usados para fazer o ajuste de um determinado conjunto de dados simplesmente a partir dos valores dos pontos (GILAT, 2008). A ideia da interpolação é determinar qual valor de $f(x)$ correspondente entre $x_0$ e $x_1$.

Exemplo 9

De acordo com o gráfico abaixo temos a variação das posições de um carro em função do tempo. Calcular a posição quando t = 3.5s

using Measurements

# dados iniciais, tempo em segundo e posição em metros.

tempo   =[measurement(0.00,0.01), measurement(1.00,0.01), measurement(2.00,0.01), measurement(3.00,0.01), measurement(4.00,0.01)]
posicao =[measurement(0.00,0.05), measurement(1.00,0.05), measurement(4.00,0.05), measurement(9.00,0.05), measurement(16.00,0.05)];

# carregar pacote, apenas execute shit+enter no teclado ou toque em Run

using Interpolations

# calcular o valor para t = 3.5s

LinearInterpolation(tempo, posicao)(3.5)

12.5 ± 0.061

# treino
# encontrar a função interpolação para os dados tempo = [0,1,2,3,4,5] e posicao = [15,20,28,45,70,150]

# treino
# calcular a posição para t = 4.75s

Referências Bibliográficas

CHAPRA, Steven C.; Canale. Raymond P. Métodos Numéricos para Engenharia, 5ª ed, McGraw Hill, 2008, ISBN: 978-85-86804-87-8.

GILAT, A.; Subramaniam, V. Métodos Numéricos para Engenheiros e Cientistas: Uma Introdução com Aplicações Usando o MATLAB. 1. ed. Bookman, 2008.

PIACENTINI, J.J. Introdução ao Laboratório de Física. Editora da UFSC, 2012.