459 lines
14 KiB
Plaintext
459 lines
14 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"# Tutorial para o módulo *aluno_exatas*\n",
|
|
"\n",
|
|
"## *aluno_exatas.fis\\_exp*\n",
|
|
"\n",
|
|
"Esse módulo tem como objetivo auxiliar o aluno que está cursando física experimental. Além de automatizar a propagação, permite gerar funções que facilitam a manipulação dos dados medidos.\n",
|
|
"\n",
|
|
"### *aluno_exatas.fis\\_exp.FisExp*\n",
|
|
"\n",
|
|
"Essa classe é útil principalmente na propagação de incertezas.\n",
|
|
"\n",
|
|
"#### Importando módulos úteis:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 1,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"import aluno_exatas.fis_exp as fe\n",
|
|
"import numpy as np"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"#### Inicializando o módulo\n",
|
|
"\n",
|
|
"A variável `f` irá conter um objeto `FisExp` cuja função principal é `a+b*c`. Nesse objeto, pode ser achada a propagação de incertezas da função principal."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 2,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Função principal: a**2 + b*c\n",
|
|
"Variáveis da função principal: {c, b, a} \n",
|
|
"\n",
|
|
"Propagação de incertezas da função principal: sqrt(4*a**2*u_a**2 + b**2*u_c**2 + c**2*u_b**2)\n",
|
|
"Incertezas da propagação de incertezas: [u_c, u_b, u_a]\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"f = fe.FisExp('a**2+b*c')\n",
|
|
"\n",
|
|
"print ('Função principal: ', f.funcao)\n",
|
|
"print ('Variáveis da função principal: ', f.variaveis, '\\n')\n",
|
|
"print ('Propagação de incertezas da função principal: ', f.propagacao)\n",
|
|
"print ('Incertezas da propagação de incertezas: ', list(f.incertezas.values()))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"#### Definindo valores conhecidos\n",
|
|
"\n",
|
|
"Nesse caso, os valores de `a` e `b` são constantes, assim como as incertezas de `a` e `c`. Os valores desconhecidos são `c` e a incerteza de `b`."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 3,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Função com valores constantes substituídos: 2*c + 16\n",
|
|
"Propagação com valores constantes substituídos: sqrt(c**2*u_b**2 + 80)\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"f.valores_conhecidos = {'a':4, 'b':2}\n",
|
|
"f.incertezas_conhecidas = {'a':1, 'c':2}\n",
|
|
"\n",
|
|
"print ('Função com valores constantes substituídos: ', f.funcao_substituida)\n",
|
|
"print ('Propagação com valores constantes substituídos: ', f.propagacao_substituida)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"#### Criação de funções\n",
|
|
"\n",
|
|
"Agora são criadas funções para calcular o valor da função principal e da propagação em diferentes valores de `c` e `u_b`."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 4,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Função principal avaliada em c=5: 26\n",
|
|
"Propagação avaliada em c=5, u_b=1 10.246950765959598\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"f.gerar_funcao(['c'])\n",
|
|
"f.gerar_propagacao(['c','u_b'])\n",
|
|
"\n",
|
|
"print ('Função principal avaliada em c=5:', f.funcao_gerada(5))\n",
|
|
"print ('Propagação avaliada em c=5, u_b=1', f.propagacao_gerada(5,1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"Essas funções também podem ser utilizadas com valores armazenados em `numpy.arrays`, o que permite que sejam avaliadas em vários pontos. Quando os parâmetros das funções são vários `numpy.arrays`, a função é avaliada de forma sequencial, seguindo a sequência de cada array (portanto, os vetores precisam ter o mesmo tamanho)."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 5,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Função principal avaliada em diferentes valores de c: [ 16. 41. 66. 91. 116.]\n",
|
|
"Propagação avaliada em diferentes valores de c e u_b: [ 8.94427191 15.37042615 50.7937004 75.5314504 50.7937004 ]\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"c = np.linspace(0,50,5)\n",
|
|
"u_b = np.array([1,1,2,2,1])\n",
|
|
"\n",
|
|
"print ('Função principal avaliada em diferentes valores de c: ', f.funcao_gerada(c))\n",
|
|
"print ('Propagação avaliada em diferentes valores de c e u_b: ', f.propagacao_gerada(c, u_b))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"#### Funcionalidades extra\n",
|
|
"\n",
|
|
"Se, por alguma razão, o usuário desejar integrar ou derivar a função principal, há funções que permitem isso."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 6,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Função derivada em relação a \"a\": 2*a\n",
|
|
"Função derivada em relação a \"a\", avaliada em a=1, derivada de índice 2: 2\n",
|
|
"Função derivada em relação a \"a\", com valores conhecidos substituídos: 8 \n",
|
|
"\n",
|
|
"Integral da função em relação a \"a\": a**3/3 + a*b*c\n",
|
|
"Integral da função em relação a \"a\", avaliada entre [0,5]: 5*b*c + 125/3\n",
|
|
"Integral da função em relação a \"c\", avaliada entre [0,5], com valores conhecidos substituídos: 105\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"print ('Função derivada em relação a \"a\": ', f.derivar('a'))\n",
|
|
"print ('Função derivada em relação a \"a\", avaliada em a=1, derivada de índice 2: ', f.derivar('a', ponto_avaliado=1, indice=2))\n",
|
|
"print ('Função derivada em relação a \"a\", com valores conhecidos substituídos: ', f.derivar('a', substituir=True), '\\n')\n",
|
|
"\n",
|
|
"print ('Integral da função em relação a \"a\": ', f.integrar('a'))\n",
|
|
"print ('Integral da função em relação a \"a\", avaliada entre [0,5]: ', f.integrar('a', limites=[0,5]))\n",
|
|
"print ('Integral da função em relação a \"c\", avaliada entre [0,5], com valores conhecidos substituídos: ', f.integrar('c', limites=[0,5], substituir=True))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"collapsed": true
|
|
},
|
|
"source": [
|
|
"### *aluno_exatas.fis\\_exp.MMQ*\n",
|
|
"\n",
|
|
"Essa classe foi feita para facilitar a utilização do MMQ linear, com incertezas variáveis ou não.\n",
|
|
"\n",
|
|
"#### Importação de módulos\n",
|
|
"\n",
|
|
"O módulo `fis_exp` já foi importado, de forma que não é necessário importá-lo novamente.\n",
|
|
"\n",
|
|
"#### Inicializando o módulo\n",
|
|
"\n",
|
|
"O módulo pode ser inicializado de diferentes formas, dependendo de que tipo de MMQ se quer calcular."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 7,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"mmq_inc_iguais = fe.MMQ()\n",
|
|
"mmq_inc_varia = fe.MMQ(fe.Incertezas.variaveis)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"#### Definição de valores\n",
|
|
"\n",
|
|
"Os módulos podem receber `lists`, `numpy.ndarrays` ou números normais (no caso de `incerteza_y` para incertezas iguais)."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 8,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"x = [0, 1, 2, 3, 4]\n",
|
|
"y = np.array([1, 3, 7, 8, 10])\n",
|
|
"\n",
|
|
"mmq_inc_iguais.x_values = x\n",
|
|
"mmq_inc_iguais.y_values = y\n",
|
|
"mmq_inc_iguais.incertezas_y = 1\n",
|
|
"\n",
|
|
"mmq_inc_varia.x_values = x\n",
|
|
"mmq_inc_varia.y_values = y\n",
|
|
"mmq_inc_varia.incertezas_y = [1, 1, 2, 1, 3]"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"#### Recebendo de volta os coeficientes\n",
|
|
"\n",
|
|
"Os coeficientes da função na forma `y = a + b*x` são retornados no formato `[a,b]`, assim como as incertezas."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 9,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Coeficientes da função com incerteza constante: [1.2 2.3]\n",
|
|
"Incertezas dos coeficientes da função com incerteza constante: [0.77459667 0.31622777] \n",
|
|
"\n",
|
|
"Coeficientes da função com incerteza variável: [1.01265823 2.36075949]\n",
|
|
"Incertezas dos coeficientes da função com incerteza variável: [0.65822785 0.14556962]\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"coef_inc_iguais, incert_inc_iguais = mmq_inc_iguais.coeficientes()\n",
|
|
"coef_inc_varia, incert_inc_varia = mmq_inc_varia.coeficientes()\n",
|
|
"\n",
|
|
"print ('Coeficientes da função com incerteza constante: ', coef_inc_iguais)\n",
|
|
"print ('Incertezas dos coeficientes da função com incerteza constante:', incert_inc_iguais, '\\n')\n",
|
|
"\n",
|
|
"print ('Coeficientes da função com incerteza variável: ', coef_inc_varia)\n",
|
|
"print ('Incertezas dos coeficientes da função com incerteza variável:', incert_inc_varia)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## *aluno_exatas.calc_num*\n",
|
|
"\n",
|
|
"Esse módulo tem como objetivo auxiliar o aluno que está cursando cálculo numérico. Contém funções que implementam conceitos aprendidos em aula.\n",
|
|
"\n",
|
|
"#### Importando módulos úteis:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 10,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"import aluno_exatas.calc_num as cn\n",
|
|
"import numpy as np"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Métodos de aproximações sucessivas para achar zero de funções\n",
|
|
"\n",
|
|
"#### Definindo a função que será usada e sua derivada\n",
|
|
"\n",
|
|
"A definição da derivada é necessária para o método de Newton."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 11,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"def f(x):\n",
|
|
" return x+np.cos(x)\n",
|
|
"\n",
|
|
"def flinha(x):\n",
|
|
" return 1-np.sin(x)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"#### Definindo aproximações iniciais para os métodos da secante, newton e bissecção\n",
|
|
"\n",
|
|
"* O método da secante precisa apenas da própria função e de duas aproximações para a raiz;\n",
|
|
"* O método de Newton precisa da função, sua derivada, e uma aproximação inicial;\n",
|
|
"* O método da bissecção precisa própria função e de duas aproximações para o intervalo que contém a raiz."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 12,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Função inicial avaliada nas aproximações iniciais:\n",
|
|
"f(-1) = -0.45969769413186023\n",
|
|
"f(0) = 1.0\n",
|
|
"f(1) = 1.5403023058681398\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"x_secante = 0.0\n",
|
|
"xo_secante = 1.0\n",
|
|
"\n",
|
|
"x_newton = 1.0\n",
|
|
"\n",
|
|
"a_bi = -1.0\n",
|
|
"b_bi = 0.0\n",
|
|
"\n",
|
|
"print('Função inicial avaliada nas aproximações iniciais:')\n",
|
|
"print('f(-1) =', f(-1))\n",
|
|
"print('f(0) =', f(0))\n",
|
|
"print('f(1) =', f(1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"#### Testando cada um dos métodos\n",
|
|
"\n",
|
|
"Os métodos irão rodar por 9 iterações e será possível observar a qualidade da aproximação de cada um.\n",
|
|
"\n",
|
|
"O método da secante, que é sujeito a erros por estar realizando divisão por 0, evita isso retornando os mesmos valores de `x` e `xo` que foram utilizados como entrada da função."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 13,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Raiz encontrada pelo método da secante:\n",
|
|
"x = -0.7390851332151607 | xo = -0.7390851332151607\n",
|
|
"f(x) = 0.0 | f(xo) = 0.0\n",
|
|
"\n",
|
|
"Raiz encontrada pelo método de Newton:\n",
|
|
"x = -0.7390851332151607\n",
|
|
"f(x) = 0.0\n",
|
|
"\n",
|
|
"Intervalo encontrado pelo método da bissecção:\n",
|
|
"Raiz está entre: (-0.7392578125, -0.73828125)\n",
|
|
"f(a) = -0.0002890091467900868 | f(b) = 0.001345149751805108\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"for i in range(10):\n",
|
|
" x_secante, xo_secante = cn.metodo_secante(f, x_secante, xo_secante)\n",
|
|
" \n",
|
|
" x_newton = cn.metodo_newton(f, flinha, x_newton)\n",
|
|
" \n",
|
|
" a_bi, b_bi = cn.metodo_bisseccao(f, a_bi, b_bi)\n",
|
|
"\n",
|
|
"print('Raiz encontrada pelo método da secante:')\n",
|
|
"print('x =', x_secante, '| xo =', xo_secante)\n",
|
|
"print('f(x) =', f(x_secante), '| f(xo) =', f(xo_secante))\n",
|
|
"\n",
|
|
"print('\\nRaiz encontrada pelo método de Newton:')\n",
|
|
"print('x =', x_newton)\n",
|
|
"print('f(x) =', f(x_newton))\n",
|
|
"\n",
|
|
"print('\\nIntervalo encontrado pelo método da bissecção:')\n",
|
|
"print('Raiz está entre:', (a_bi, b_bi))\n",
|
|
"print('f(a) =', f(a_bi), '| f(b) =', f(b_bi))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": []
|
|
}
|
|
],
|
|
"metadata": {
|
|
"kernelspec": {
|
|
"display_name": "Python 3",
|
|
"language": "python",
|
|
"name": "python3"
|
|
},
|
|
"language_info": {
|
|
"codemirror_mode": {
|
|
"name": "ipython",
|
|
"version": 3
|
|
},
|
|
"file_extension": ".py",
|
|
"mimetype": "text/x-python",
|
|
"name": "python",
|
|
"nbconvert_exporter": "python",
|
|
"pygments_lexer": "ipython3",
|
|
"version": "3.6.5"
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 2
|
|
}
|