Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Download

Tutorial básico Julia Python

496 views
ubuntu2004
Kernel: SageMath 9.1

ESTATÍSTICA DESCRITIVA

A estatística descritiva ocupa-se da organização, apresentação e sintetização dos dados.

Dados

Tabela de dados de intervalo de tempo para cada intervalo de 0,10m de um carrinho movido a pilha de massa 0,250g com velocidade constante

ΔT
5,973
6,812
6,659
7,124
6,925
6,459
6,393
6,525
import pandas as pd
MRU = pd.DataFrame() MRU['DT'] = [5.973, 6.812, 6.659, 7.124, 6.925, 6.459, 6.393, 6.525] MRU

Histograma

Histogramas são gráficos de barras verticais justapostas em um eixo contínuo. Neles, o eixo xx recebe a variável em estudo, ou seja, abriga as classes. A largura das colunas representa a amplitude das classes. O eixo yy recebe as frequências (absolutas, relativas, percentuais ou densidades de frequência). Sintaxe:

histogram(MRU.DT)
Image in a Jupyter notebook

Medidas de Posição

Médias

Média aritimétrica

É o quociente entre a soma dos valores do conjunto e o número total dos valores.

Xˉ=i=1nxin \displaystyle \bar{X} = {\sum_{i=1}^n x_{i} \over n}

x_dt = mean(MRU.DT) x_dt
6.60875
MRU.DT.mean()
6.60875

Mediana

A mediana de um conjunto de valores, dispostos segundo uma ordem (crescente ou decrescente) é o elemento que ocupa a posição central, ou seja, divide o conjunto de dados em duas partes iguais.

  • Se a série dada tiver número ímpar de termos: O valor mediano será o termo de ordem dado pela fórmula:

Md=n+12\displaystyle M_d = {{n+1} \over 2}

  • Se a série dada tiver número par de termos: O valor mediano será o termo de ordem dado pela fórmula:

Md_DT = median(MRU.DT)
MRU.DT.median()
6.5920000000000005

Moda

É valor mais frequente, aquele que mais se repete.

moda_dx = MRU.DT.mode() moda_dx
0 5.97300000000000 1 6.39300000000000 2 6.45900000000000 3 6.52500000000000 4 6.65900000000000 5 6.81200000000000 6 6.92500000000000 7 7.12400000000000 dtype: object

Describe

A função describe() lista várias informações sobre o dataframe.

MRU.DT.describe()
count 8 unique 8 top 6.52500000000000 freq 1 Name: DT, dtype: object

Medidas de Dispersão

Amplitude Total (A)

É a diferença entre o maior e menor dos valores da série de medidas.

A_DT = MRU.DT.max() - MRU.DT.min() A_DT
1.15100000000000

Desvio de uma medida

Δxi=xixˉ\Delta x_i = x_i - \bar{x}

for k in range(0, len(MRU)): print(MRU.DT.max() - MRU.DT[k])
1.15100000000000 0.311999999999999 0.465000000000000 0.000000000000000 0.199000000000000 0.665000000000000 0.731000000000000 0.598999999999999

Variancia

Variância dos dados amostrais dado por :

i=1nΔxi2n1=i=1n(xixˉ)2n1\displaystyle {{\sum_{i=1}^n { \Delta x_i ^ 2} \over {n-1}}} = {{\sum_{i=1}^n {(x_{i} - \bar{x} )^2} \over {n-1}}}

var_DT = MRU.DT.var() var_DT
0.1270710714285714

Desvio padrão

O desvio padrão é a medida da variação, da dispersão, de um conjunto. Dessa forma, quanto maior for o desvio padrão, pior estão sendo as medidas, ou seja, há erros que estão diversificando os valores das medidas.

i=1n(xixˉ)n1\displaystyle \sqrt{\sum_{i=1}^n {(x_{i} - \bar{x} )} \over {n-1}}

Dp_DT = MRU.DT.std() Dp_DT
0.356470295296216

Desvio padrão da média

σm=σn\displaystyle \sigma_m = {\sigma \over \sqrt{n}}

σ_m_Dt = MRU.Dt.std() / sqrt(len(MRU)) σ_m_Dt.n()
0.126031281547763

Coeficiente de Variação (CV)

Trata-se de uma medida relativa de dispersão, útil para a comparação em termos relativos do grau de concentração em torno da média de séries distintas. o coeficiente de variação é muito utilizado para comparação entre amostras (por exemplo: o que é mais variável, o ganho de peso de suínos ou a altura de plantas de milho?).

print(MRU.cov())
Empty DataFrame Columns: [] Index: []

Erro Aleatório

Ea=±  tσmE_a = \pm ~~t \cdot \sigma_m

Ea_Dt = 1*σ_m_Dt Ea_Dt.n()
0.126031281547763

Resultado da medida

Δt=(Δˉt±Ea)\Delta t = ( \bar{\Delta} t \pm E_a)

Δt=(6.60875±0.12603)\Delta t = (6.60875 \pm 0.12603 )

Erro de escala

M=(m± Δm)uM = (m \pm ~ \Delta{m})u

sendo:

  • m: medida

  • Δm\bold {\Delta m}: erro de escala

Erro de escala Instrumento Analógico

Eesc=± menor divisa~o de escala2\displaystyle E_{esc} = \pm ~ {{menor ~divisão ~de ~escala} \over 2}

Erro de escala Instrumentos Não Analógicos

Eesc=± menor divisa~o de escala\displaystyle E_{esc} = \pm ~ {{menor ~divisão ~de ~escala}}

Exemplo 1: Os valores do período de (T) e do comprimento (L) de um pêndulo simples foram obtidos experimentalmente de acordo com a tabela abaixo:

T(s)2,839 ± 0,0012,835 ± 0,0012,832 ± 0,0012,838 ± 0,0012,842 ± 0,001
L(m)2,0005 ± 0,00051,9997 ± 0,00052,0002 ± 0,00051,997 ± 0,00052,0000 ± 0,0005

a) Calcular O erro aleatório de T e L

b) Escrever o resultado de acordo com a teria de erros

import pandas as pd PEN = pd.DataFrame() PEN['T_s'] = [2.839, 2.835, 2.832, 2.838, 2.842] PEN['L_m'] = [2.0005, 1.9997, 2.0002, 1.997, 2.0000] PEN
PEN.T_s
0 2.83900000000000 1 2.83500000000000 2 2.83200000000000 3 2.83800000000000 4 2.84200000000000 Name: T_s, dtype: object
# média aritimética x_T = PEN.T_s.mean() # visualizar dado x_T
2.8372
# desvio padrão médio σ_m_T = PEN.T_s.std() / sqrt(len(PEN.T_s)) # erro aleatório Ea_T = (1.0*σ_m_T).n() # visualizar dado Ea_T
0.00171464281994826
Δm = round(Ea_T + 0.001, 4) Δm
0.0027

T = (2.8372±0.00272.8372 \pm 0.0027)

Erro relativo Percentual

E%=xxˉxˉ\displaystyle E\% = \left | {{x - \bar{x}} \over \bar{x}} \right |

for k in range(0, len(MRU)): print(abs((MRU.Dt[k] - x_dt)/x_dt))
0.09619822205409492 0.030754681293739452 0.00760355589181012 0.07796481936826177 0.0478532248912427 0.02265935313031966 0.03264611310762246 0.012672593153016732

Propagação de erros

y=f(x1,x2,x3,...,xn) \displaystyle {y = f(x_1, x_2, x_3,..., x_n)}

Equação do erro determinado

Δ=fx1Δx1+fx2Δx2+...+fxnΔxn\displaystyle \Delta = \left | {{\partial f} \over \partial x_1} \right | \cdot \Delta x_1 + \left | {{\partial f} \over \partial x_2} \right | \cdot \Delta x_2 + ... + \left | {{\partial f} \over \partial x_n} \right | \cdot \Delta x_n

X=X0+VtX = X_0 + V t

sendo X0=0X_0 = 0

ΔX=XtΔt\displaystyle \Delta X = {{\partial X} \over \partial t} \cdot \Delta t

ΔX=VΔt\displaystyle \Delta X = V \cdot \Delta t

ΔX=V0.12603\displaystyle \Delta X = V \cdot 0.12603

PACOTE UNCERTAINTIES

O pacote uncertainties é um programa gratuito de plataforma cruzada que lida de forma transparente com cálculos contendo incertezas (como 3,14 ± 0,01). Também pode produzir os derivados de qualquer expressão. Sintaxe:

var = unfloat(valor, incerteza)
# instalar o pacote Incertezas !pip3 install --upgrade uncertainties
Collecting uncertainties Downloading https://files.pythonhosted.org/packages/b0/e0/fc200da8190729dcb685ae4877ed6936d31d64aeccb8cc355d9ec982681d/uncertainties-3.1.4-py2.py3-none-any.whl (246kB) |████████████████████████████████| 256kB 2.7MB/s eta 0:00:01 Requirement already satisfied, skipping upgrade: future in /ext/sage/sage-9.0/local/lib/python3.7/site-packages (from uncertainties) (0.17.1) Installing collected packages: uncertainties Found existing installation: uncertainties 3.1.2 Uninstalling uncertainties-3.1.2: ERROR: Could not install packages due to an EnvironmentError: [Errno 30] Read-only file system: 'INSTALLER'
# importar o pacote import uncertainties as unc

Exemplo: Calcular a força peso conforme tabela abaixo

Massa (kg)g (m/s^2)
0.512 ± 0.0019.78 ± 0.02
0.610 ± 0.001 9.81 ± 0.02
0.704 ± 0.0019.88 ± 0.02 
0.599 ± 0.0019.79 ± 0.02 
%display unicode_art
import pandas as pd
Tabela = pd.DataFrame() Tabela['Massa'] = [unc.ufloat(0.51, 0.01),unc.ufloat(0.61, 0.01), unc.ufloat(0.74, 0.01), unc.ufloat(0.59, 0.01)] Tabela['g'] = [unc.ufloat(9.78, 0.02), unc.ufloat(9.81, 0.02), unc.ufloat(9.88, 0.02), unc.ufloat(9.78, 0.02)] Tabela
Tabela.Massa[[1]] * Tabela.g[[1]]
1 5.98+/-0.10 dtype: object
forca = pd.DataFrame() forca['Forca'] = [] forca
for i in range(0, 2): #forca.append(Tabela.Massa[[i]] * Tabela.g[[i]]) forca.loc[i] = [Tabela.Massa[[i]] * Tabela.g[[i]]]
forca
forca.append(pd.DataFrame([[8]]), ignore_index=True)

INTERPOLAÇÃO

Os resultados de medições experimentais ou simulações numéricas fornecem, em geral,um conjunto de valores de uma função em pontos discretos de uma variável independente. Esses valores podem ser apresentados naforma de uma tabela para valores discretos de 𝑥. O processo de calcular a função para valores intermédios aos valores conhecidos de 𝑓(𝑥)é chamado interpolação (MIRANDA, 2018). Tipos de interpolação:

  • Interpolação linear (padrão da funçao interp1d)

  • Interpolação polinomial

  • Interpolação trigonométrica

  • Spline

Gráfico interpolação linear:

Sintaxe:

# carrregar a função interp1d from scipy.interpolate import interp1d # calcular a função interpolação nome_função = interp1d(dados_x, dados_y, kind='tipo_interp')

'linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'previous', 'next', where 'zero', 'slinear', 'quadratic' and 'cubic' refer to a spline interpolation of zeroth, first, second or third order; 'previous' and 'next' simply return the previous or next value of the point

# Dados x_dados = [0.0, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0] y_dados = [0.0, 0.5, 0.84, 1.0, 0.91, 0.6, 0.14, -0.35, -0.76, -0.98]
import pandas as pd
dados = pd.DataFrame() dados['x'] = x_dados dados['y'] = y_dados dados
# gráfico com axes_labels = ['x','y'], gridlines = 'minor', figsize = (4, 3) scatter_plot([[dados.x, dados.y]])
Image in a Jupyter notebook
# Importar a função interp1d do scipy.interpolate from scipy.interpolate import interp1d
# fint recebe interp1d(x_dados, y_dados) fint = interp1d(dados.x, dados.y)
# testar a função fint(3)
array(0.600000000000000, dtype=object)
# gráfico pontos + gráfico fint plot(fint, 0, 5, color = 'gray') + scatter_plot([[dados.x, dados.y]], gridlines = 'minor', axes_labels = ['x','y'], figsize = (4, 3))
Image in a Jupyter notebook

AJUSTE DE CURVAS

Ajuste de Curvas é um método que consiste em encontrar uma curva que se ajuste a uma série de pontos e que possivelmente cumpra uma série de parâmetros adicionais. Ajuste de curvas pode envolver tanto interpolação, onde é necessário um ajuste exato aos dados, quanto suavização, na qual é construída uma função "suave" que se aproximadamente se ajusta aos dados. Outro assunto relacionado é análise de regressão, a qual se foca mais em questões da inferência estatística (Wikipedia, 2019).

Algoritmo:

# Definir as constantes var('k_1', 'k_2', k_3, ..., k_n) # definir um modelo matemático modelo(x) = expressão_matemática # calcular as constantes do modelo constantes_modelo = find_fit(dados_pontos, modelo, [k_1_i, k_2_i, ..., k_n_i], solution_dict = True) # substituir as cosntantes no modelo modelo(x) = modelo.subs(constantes)

Modelo polinomial

Modelo Reta

# Importar CSV e pandas import pandas import csv
# importar dados_reta.csv para variável dados_reta dados_reta = pandas.read_csv('dados_reta.csv')
# visualizar dados dados_reta
# Gráfico dos dados com axes_labels = ['x','y'], gridlines = 'minor', figsize = (5, 4) scatter_plot([[dados_reta.x, dados_reta.y]], axes_labels = ['x','y'], gridlines = 'minor', markersize = 10, figsize=(4, 3))
Image in a Jupyter notebook
# Definir os símbolos a e b do modelo_reta var('a', 'b')
(a, b)
# função modelo_reta 'ax + b' modelo_reta(x) = a*x + b modelo_reta(x)
a*x + b
# coeficientes coef recebe os dados da função find_fit(dados_pontos, modelo, [ai, bi], solution_dict = True) constantes = find_fit(dados_reta, modelo_reta, [0.5, 0.5], solution_dict = False) constantes
[a == 0.45996226645180155, b == -0.17573217304516242]
des
b == -0.17573217304516242
#imprimir coef 'a' constantes[a]
0.45996226645180155
# substituir coef no modelo reta modelo_reta(x) = modelo_reta.subs(constantes) modelo_reta(x)
0.45996226645180155*x - 0.17573217304516242
# Gráfico pontos e modelo reta scatter_plot([[dados_reta.x, dados_reta.y]], axes_labels = ['x','y'], gridlines = 'minor', markersize = 10, figsize = (5, 4)) + \ plot(modelo_reta(x),(x, 0, 3.5), color = 'green', legend_label = "reta")
Image in a Jupyter notebook

Modelo não polinomial

Movimento harmônico simples

O movimento harmônico simples é o movimento que ocorre em função de uma força restauradora que desloca um determinado corpo de sua posição de equilíbrio e proporcional ao deslocamento. O exemplo mais simples de oscilador harmônico é o sistema massa mola. O gráfico mostra o deslocamento xx em função do tempo t t que obedece à lei de Hook, Fx=kxFx = -kx, no qual xx varia senoidalmente com o tempo e pode ser descrito pela função x(t)=Acos(ωt+φ)x(t) = Acos(ωt + φ). Sendo A (amplitude) , ω (frequencia angular) e φ (fase) constantes.

De acordo com o montagem experimental abaixo, foram coletados dados de função posição xx na vertical (cm) em função do tempo (s) e salvas em um arquivo CSV. A pardir dos dados, determine a função do movimento harmônico simples.

# Importar CSV e pandas import pandas import csv
# importar dados_senoide.csv para variável dados_senoide dados_senoide = pandas.read_csv('dados_senoide.csv')
# visualizar dados dados_senoide
scatter_plot([[dados_senoide.t, dados_senoide.x]], axes_labels = ['t(s)','x(cm)'], gridlines = 'minor', markersize = 10, figsize=(4, 3))
Image in a Jupyter notebook
# Definir os símbolos A, w, p e t do modelo_senoide var('A', 'w', 'p', 't')
(A, w, p, t)
# função modelo_senoide modelo_senoide(t) = A*sin(w*t + p) modelo_senoide(t)
A*sin(t*w + p)
constantes = find_fit(dados_senoide, modelo_senoide, [0.5, 0.5, 0.5], solution_dict = True) constantes
{A: 1.1743532071992284, p: -0.09744247201199815, w: 0.4826611233436039}
# substituir constantes no modelo senoide modelo_senoide(t) = modelo_senoide.subs(constantes) modelo_senoide(t)
1.1743532071992284*sin(0.4826611233436039*t - 0.09744247201199815)
# Gráfico pontos e modelo senoide scatter_plot([[dados_senoide.t, dados_senoide.x]], axes_labels = ['t(s)','x(cm)'], gridlines = 'minor', markersize = 10, figsize = (5, 4)) + \ plot(modelo_senoide(t),(t, 0, 12.5), color = 'green', legend_label = "reta")
Image in a Jupyter notebook

FIM