Adicionar circuitos_eletricos, atualizar o tutorial, mudar o tutorial para f-strings
This commit is contained in:
parent
9d8f2de2e5
commit
f7982602d0
|
@ -2,6 +2,7 @@
|
|||
|
||||
Esse é um módulo que tem como objetivo auxiliar alunos de exatas com os trabalhos do seu curso. Atualmente, contém funções para os seguintes assuntos:
|
||||
* Física experimental: esse é o módulo mais desenvolvido, contém funções relacionadas à propagação de incertezas e manipulação dos dados utilizados, inclusive através do Método dos Mínimos Quadrados;
|
||||
* Cálculo numérico: esse módulo não tem muitas funções, mas busca implementar conceitos explorados na matéria. Não está completo, e só recomendo usar as funções depois de ter entendido bem o que elas fazem e como fazem.
|
||||
* Cálculo numérico: esse módulo não tem muitas funções, mas busca implementar conceitos explorados na matéria. Não está completo, e só recomendo usar as funções depois de ter entendido bem o que elas fazem e como fazem;
|
||||
* Circuitos elétricos: esse módulo por enquanto só auxilia no tratamento de fasores e contém algumas constantes relacionadas a componentes simétricas.
|
||||
|
||||
O tutorial para o módulo pode ser encontrado no formato Jupyter Notebook [aqui](tutorial_aluno_exatas.ipynb) e no formato Markdown [aqui](tutorial_aluno_exatas.md).
|
||||
|
|
|
@ -1,2 +1,3 @@
|
|||
import aluno_exatas.fis_exp
|
||||
import aluno_exatas.calc_num
|
||||
import aluno_exatas.calc_num
|
||||
import aluno_exatas.circuitos_eletricos
|
|
@ -0,0 +1,2 @@
|
|||
import aluno_exatas.circuitos_eletricos.fasores
|
||||
import aluno_exatas.circuitos_eletricos.componentes_simetricas
|
|
@ -0,0 +1,23 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""Esse módulo define constantes que são úteis para trabalhar-se
|
||||
com componentes simétricas em circuitos elétricos trifásicos.
|
||||
"""
|
||||
|
||||
import numpy as np
|
||||
from aluno_exatas.circuitos_eletricos.fasores import p2c
|
||||
|
||||
# relação entre fases
|
||||
alpha = p2c(1,120)
|
||||
|
||||
# matriz que multiplica a matriz de componentes
|
||||
T = [[1, 1, 1],
|
||||
[1, alpha**2, alpha],
|
||||
[1, alpha, alpha**2]]
|
||||
T = np.array(T)
|
||||
|
||||
# inversa de T
|
||||
T_i = [[1, 1, 1],
|
||||
[1, alpha, alpha**2],
|
||||
[1, alpha**2, alpha]]
|
||||
T_i = 1/3 * np.array(T_i)
|
|
@ -0,0 +1,44 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""Esse módulo contém funções que permitem trabalhar-se
|
||||
facilmente com fasores, que normalmente são representados
|
||||
na forma polar.
|
||||
"""
|
||||
|
||||
import numpy as np
|
||||
from functools import partial
|
||||
|
||||
|
||||
def polar_para_complexo(r: float, angle: float, degree=True):
|
||||
"""Essa função converte números complexos representados
|
||||
em coordenadas polares para números complexos normais.
|
||||
Pode receber o ângulo em radianos ou em graus.
|
||||
"""
|
||||
|
||||
if degree:
|
||||
return r * np.exp(1j * np.deg2rad(angle))
|
||||
else:
|
||||
return r * np.exp(1j * angle)
|
||||
|
||||
|
||||
def complexo_para_polar(n: complex, degree=True):
|
||||
"""Essa função recebe números complexos e retorna
|
||||
coordenadas polares. Pode retornar o ângulo em radianos
|
||||
ou em graus.
|
||||
"""
|
||||
|
||||
if degree:
|
||||
return np.abs(n), np.rad2deg(np.angle(n))
|
||||
else:
|
||||
return np.abs(n), np.angle(n)
|
||||
|
||||
|
||||
p2c = polar_para_complexo
|
||||
c2p = complexo_para_polar
|
||||
|
||||
p2cr = partial(polar_para_complexo, degree=False)
|
||||
p2cr.__doc__ = '''Faz a mesma coisa que p2c, mas está configurada
|
||||
para ângulos em radianos como padrão.'''
|
||||
|
||||
c2pr = partial(complexo_para_polar, degree=False)
|
||||
c2pr.__doc__ = '''Faz a mesma coisa que c2p, mas está configurada
|
||||
para ângulos em radianos como padrão.'''
|
2
setup.py
2
setup.py
|
@ -2,7 +2,7 @@ from setuptools import setup
|
|||
|
||||
setup(
|
||||
name='aluno_exatas',
|
||||
version='0.8.3',
|
||||
version='0.8.4',
|
||||
packages=['aluno_exatas'],
|
||||
install_requires = ['numpy', 'sympy'],
|
||||
license='MIT License',
|
||||
|
|
|
@ -6,7 +6,19 @@
|
|||
"source": [
|
||||
"# Tutorial para o módulo *aluno_exatas*\n",
|
||||
"\n",
|
||||
"## *aluno_exatas.fis\\_exp*\n",
|
||||
"Esse tutorial tem como objetivo explorar os módulos contidos no módulo `aluno_exatas`.\n",
|
||||
"\n",
|
||||
"Atualmente, os módulos disponíveis são:\n",
|
||||
"* [`aluno_exatas.fis_exp`](#aluno_exatas.fis_exp)\n",
|
||||
"* [`aluno_exatas.calc_num`](#aluno_exatas.calc_num)\n",
|
||||
"* [`aluno_exatas.circuitos_eletricos`](#aluno_exatas.circuitos_eletricos)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## *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",
|
||||
|
@ -45,21 +57,21 @@
|
|||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Função principal: a**2 + b*c\n",
|
||||
"Variáveis da função principal: {c, b, a} \n",
|
||||
"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"
|
||||
"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()))"
|
||||
"print (f'Função principal: {f.funcao}')\n",
|
||||
"print (f'Variáveis da função principal: {f.variaveis}\\n')\n",
|
||||
"print (f'Propagação de incertezas da função principal: {f.propagacao}')\n",
|
||||
"print (f'Incertezas da propagação de incertezas: {list(f.incertezas.values())}')"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
@ -80,8 +92,8 @@
|
|||
"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"
|
||||
"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"
|
||||
]
|
||||
}
|
||||
],
|
||||
|
@ -89,8 +101,8 @@
|
|||
"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)"
|
||||
"print (f'Função com valores constantes substituídos: {f.funcao_substituida}')\n",
|
||||
"print (f'Propagação com valores constantes substituídos: {f.propagacao_substituida}')"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
@ -112,7 +124,7 @@
|
|||
"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"
|
||||
"Propagação avaliada em c=5, u_b=1: 10.246950765959598\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
|
@ -120,8 +132,8 @@
|
|||
"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))"
|
||||
"print (f'Função principal avaliada em c=5: {f.funcao_gerada(5)}')\n",
|
||||
"print (f'Propagação avaliada em c=5, u_b=1: {f.propagacao_gerada(5,1)}')"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
@ -140,8 +152,8 @@
|
|||
"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"
|
||||
"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"
|
||||
]
|
||||
}
|
||||
],
|
||||
|
@ -149,8 +161,8 @@
|
|||
"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))"
|
||||
"print (f'Função principal avaliada em diferentes valores de c: {f.funcao_gerada(c)}')\n",
|
||||
"print (f'Propagação avaliada em diferentes valores de c e u_b: {f.propagacao_gerada(c, u_b)}')"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
@ -323,10 +335,10 @@
|
|||
"outputs": [],
|
||||
"source": [
|
||||
"def f(x):\n",
|
||||
" return x+np.cos(x)\n",
|
||||
" return x + np.cos(x)\n",
|
||||
"\n",
|
||||
"def flinha(x):\n",
|
||||
" return 1-np.sin(x)"
|
||||
" return 1 - np.sin(x)"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
@ -366,9 +378,9 @@
|
|||
"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))"
|
||||
"print(f'f(-1) = {f(-1)}')\n",
|
||||
"print(f'f(0) = {f(0)}')\n",
|
||||
"print(f'f(1) = {f(1)}')"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
@ -392,7 +404,7 @@
|
|||
"output_type": "stream",
|
||||
"text": [
|
||||
"Raiz encontrada pelo método da secante:\n",
|
||||
"x = -0.7390851332151607 | xo = -0.7390851332151607\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",
|
||||
|
@ -413,17 +425,177 @@
|
|||
" \n",
|
||||
" a_bi, b_bi = cn.metodo_bisseccao(f, a_bi, b_bi)\n",
|
||||
"\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",
|
||||
"print(f'x = {x_secante} | xo ={xo_secante}')\n",
|
||||
"print(f'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",
|
||||
"print(f'x = {x_newton}')\n",
|
||||
"print(f'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))"
|
||||
"print(f'Raiz está entre: {(a_bi, b_bi)}')\n",
|
||||
"print(f'f(a) = {f(a_bi)} | f(b) = {f(b_bi)}')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## *aluno_exatas.circuitos_eletricos*\n",
|
||||
"\n",
|
||||
"Esse módulo tem como função auxiliar o aluno que está cursando circuitos elétricos. Sua principal função é a implementação de funções que facilitam o uso de fasores.\n",
|
||||
"\n",
|
||||
"#### Importando módulos úteis:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 14,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import aluno_exatas.circuitos_eletricos as ce\n",
|
||||
"import numpy as np"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Fasores\n",
|
||||
"\n",
|
||||
"Essas funções permitem fazer a conversão entre números complexos nativos de Python e a representação fasorial (magnitude e defasagem).\n",
|
||||
"\n",
|
||||
"#### Importando as funções relativas a fasores:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"from aluno_exatas.circuitos_eletricos.fasores import *"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### Definindo constantes para serem testadas\n",
|
||||
"\n",
|
||||
"Vamos definir o mesmo número em duas representações diferentes, e verificar que as funções utilizadas retornam a mesma coisa."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 16,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Ângulo em radianos: 0.9273 e em graus: 53.1301\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"numero_complexo = 3 + 4j\n",
|
||||
"\n",
|
||||
"magnitude = 5\n",
|
||||
"angulo_rad = np.arctan(4 / 3)\n",
|
||||
"angulo_deg = np.rad2deg(angulo_rad)\n",
|
||||
"\n",
|
||||
"print(f'Ângulo em radianos: {angulo_rad:1.4f} e em graus: {angulo_deg:1.4f}')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### Funções do módulo\n",
|
||||
"\n",
|
||||
"O módulo define duas funções base:\n",
|
||||
"* `complexo_para_polar`;\n",
|
||||
"* `polar_para_complexo`.\n",
|
||||
"\n",
|
||||
"No entanto, essas funções têm nomes muito longos, e portanto é mais simples utilizar as versões com nomes simplificados:\n",
|
||||
"* `c2p`: converte números complexos para representação fasorial;\n",
|
||||
"* `p2c`: converte a representação fasorial para um número complexo;\n",
|
||||
"* `c2pr`: a mesma coisa que `c2p`, mas os ângulos são representados em radianos;\n",
|
||||
"* `p2cr`: a mesma coisa que `p2c`, mas os ângulos são representados em radianos;"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 17,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"O número (3+4j) em coordenadas polares utilizando graus é: (5.0, 53.13010235415598).\n",
|
||||
"O número (3+4j) em coordenadas polares utilizando radianos é: (5.0, 0.9272952180016122).\n",
|
||||
"\n",
|
||||
"O fasor de magnitude 5 e com defasagem 53.1301 graus ou 0.9273 rad é igual a (3+4j)\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"print(f'O número {numero_complexo} em coordenadas polares utilizando graus é: {c2p(numero_complexo)}.')\n",
|
||||
"print(f'O número {numero_complexo} em coordenadas polares utilizando radianos é: {c2pr(numero_complexo)}.\\n')\n",
|
||||
"\n",
|
||||
"print(f'O fasor de magnitude {magnitude} e com defasagem {angulo_deg:1.4f} graus ou {angulo_rad:1.4f} rad é igual a {p2c(magnitude, angulo_deg):1.4}')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### Testando ida e volta das funções\n",
|
||||
"\n",
|
||||
"Dado que as funções aqui exploradas permitem a conversão entre duas representações, é de se esperar que elas permitam reverter uma conversão. Isso pode ser observado abaixo."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 18,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Número complexo - velho: (3+4j) e novo: (3+4j).\n",
|
||||
"\n",
|
||||
"Magnitude - velha: 5.0000 e nova: 5.0000.\n",
|
||||
"Ângulo em graus - velho: 53.1301 e novo: 53.1301.\n",
|
||||
"\n",
|
||||
"Magnitude - velha: 5.0000 e nova: 5.0000.\n",
|
||||
"Ângulo em radianos - velho: 0.9273 e novo: 0.9273.\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"numero_complexo_novo = p2c(*c2p(numero_complexo))\n",
|
||||
"\n",
|
||||
"print(f'Número complexo - velho: {numero_complexo:1.4} e novo: {numero_complexo_novo:1.4}.\\n')\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"magnitude_nova, angulo_deg_novo = c2p(p2c(magnitude, angulo_deg))\n",
|
||||
"\n",
|
||||
"print(f'Magnitude - velha: {magnitude:1.4f} e nova: {magnitude_nova:1.4f}.')\n",
|
||||
"print(f'Ângulo em graus - velho: {angulo_deg:1.4f} e novo: {angulo_deg_novo:1.4f}.\\n')\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"magnitude_nova, angulo_rad_novo = c2pr(p2cr(magnitude, angulo_rad))\n",
|
||||
"\n",
|
||||
"print(f'Magnitude - velha: {magnitude:1.4f} e nova: {magnitude_nova:1.4f}.')\n",
|
||||
"print(f'Ângulo em radianos - velho: {angulo_rad:1.4f} e novo: {angulo_rad_novo:1.4f}.')"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
|
@ -1,7 +1,14 @@
|
|||
|
||||
# Tutorial para o módulo *aluno_exatas*
|
||||
|
||||
## *aluno_exatas.fis\_exp*
|
||||
Esse tutorial tem como objetivo explorar os módulos contidos no módulo `aluno_exatas`.
|
||||
|
||||
Atualmente, os módulos disponíveis são:
|
||||
* [`aluno_exatas.fis_exp`](#aluno_exatas.fis_exp)
|
||||
* [`aluno_exatas.calc_num`](#aluno_exatas.calc_num)
|
||||
* [`aluno_exatas.circuitos_eletricos`](#aluno_exatas.circuitos_eletricos)
|
||||
|
||||
## *aluno_exatas.fis_exp*
|
||||
|
||||
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.
|
||||
|
||||
|
@ -25,17 +32,17 @@ A variável `f` irá conter um objeto `FisExp` cuja função principal é `a+b*c
|
|||
```python
|
||||
f = fe.FisExp('a**2+b*c')
|
||||
|
||||
print ('Função principal: ', f.funcao)
|
||||
print ('Variáveis da função principal: ', f.variaveis, '\n')
|
||||
print ('Propagação de incertezas da função principal: ', f.propagacao)
|
||||
print ('Incertezas da propagação de incertezas: ', list(f.incertezas.values()))
|
||||
print (f'Função principal: {f.funcao}')
|
||||
print (f'Variáveis da função principal: {f.variaveis}\n')
|
||||
print (f'Propagação de incertezas da função principal: {f.propagacao}')
|
||||
print (f'Incertezas da propagação de incertezas: {list(f.incertezas.values())}')
|
||||
```
|
||||
|
||||
Função principal: a**2 + b*c
|
||||
Variáveis da função principal: {c, b, a}
|
||||
Função principal: a**2 + b*c
|
||||
Variáveis da função principal: {c, b, a}
|
||||
|
||||
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)
|
||||
Incertezas da propagação de incertezas: [u_c, u_b, u_a]
|
||||
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)
|
||||
Incertezas da propagação de incertezas: [u_c, u_b, u_a]
|
||||
|
||||
|
||||
#### Definindo valores conhecidos
|
||||
|
@ -47,12 +54,12 @@ Nesse caso, os valores de `a` e `b` são constantes, assim como as incertezas de
|
|||
f.valores_conhecidos = {'a':4, 'b':2}
|
||||
f.incertezas_conhecidas = {'a':1, 'c':2}
|
||||
|
||||
print ('Função com valores constantes substituídos: ', f.funcao_substituida)
|
||||
print ('Propagação com valores constantes substituídos: ', f.propagacao_substituida)
|
||||
print (f'Função com valores constantes substituídos: {f.funcao_substituida}')
|
||||
print (f'Propagação com valores constantes substituídos: {f.propagacao_substituida}')
|
||||
```
|
||||
|
||||
Função com valores constantes substituídos: 2*c + 16
|
||||
Propagação com valores constantes substituídos: sqrt(c**2*u_b**2 + 80)
|
||||
Função com valores constantes substituídos: 2*c + 16
|
||||
Propagação com valores constantes substituídos: sqrt(c**2*u_b**2 + 80)
|
||||
|
||||
|
||||
#### Criação de funções
|
||||
|
@ -64,12 +71,12 @@ Agora são criadas funções para calcular o valor da função principal e da pr
|
|||
f.gerar_funcao(['c'])
|
||||
f.gerar_propagacao(['c','u_b'])
|
||||
|
||||
print ('Função principal avaliada em c=5:', f.funcao_gerada(5))
|
||||
print ('Propagação avaliada em c=5, u_b=1', f.propagacao_gerada(5,1))
|
||||
print (f'Função principal avaliada em c=5: {f.funcao_gerada(5)}')
|
||||
print (f'Propagação avaliada em c=5, u_b=1: {f.propagacao_gerada(5,1)}')
|
||||
```
|
||||
|
||||
Função principal avaliada em c=5: 26
|
||||
Propagação avaliada em c=5, u_b=1 10.246950765959598
|
||||
Propagação avaliada em c=5, u_b=1: 10.246950765959598
|
||||
|
||||
|
||||
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).
|
||||
|
@ -79,12 +86,12 @@ Essas funções também podem ser utilizadas com valores armazenados em `numpy.a
|
|||
c = np.linspace(0,50,5)
|
||||
u_b = np.array([1,1,2,2,1])
|
||||
|
||||
print ('Função principal avaliada em diferentes valores de c: ', f.funcao_gerada(c))
|
||||
print ('Propagação avaliada em diferentes valores de c e u_b: ', f.propagacao_gerada(c, u_b))
|
||||
print (f'Função principal avaliada em diferentes valores de c: {f.funcao_gerada(c)}')
|
||||
print (f'Propagação avaliada em diferentes valores de c e u_b: {f.propagacao_gerada(c, u_b)}')
|
||||
```
|
||||
|
||||
Função principal avaliada em diferentes valores de c: [ 16. 41. 66. 91. 116.]
|
||||
Propagação avaliada em diferentes valores de c e u_b: [ 8.94427191 15.37042615 50.7937004 75.5314504 50.7937004 ]
|
||||
Função principal avaliada em diferentes valores de c: [ 16. 41. 66. 91. 116.]
|
||||
Propagação avaliada em diferentes valores de c e u_b: [ 8.94427191 15.37042615 50.7937004 75.5314504 50.7937004 ]
|
||||
|
||||
|
||||
#### Funcionalidades extra
|
||||
|
@ -191,10 +198,10 @@ A definição da derivada é necessária para o método de Newton.
|
|||
|
||||
```python
|
||||
def f(x):
|
||||
return x+np.cos(x)
|
||||
return x + np.cos(x)
|
||||
|
||||
def flinha(x):
|
||||
return 1-np.sin(x)
|
||||
return 1 - np.sin(x)
|
||||
```
|
||||
|
||||
#### Definindo aproximações iniciais para os métodos da secante, newton e bissecção
|
||||
|
@ -214,9 +221,9 @@ a_bi = -1.0
|
|||
b_bi = 0.0
|
||||
|
||||
print('Função inicial avaliada nas aproximações iniciais:')
|
||||
print('f(-1) =', f(-1))
|
||||
print('f(0) =', f(0))
|
||||
print('f(1) =', f(1))
|
||||
print(f'f(-1) = {f(-1)}')
|
||||
print(f'f(0) = {f(0)}')
|
||||
print(f'f(1) = {f(1)}')
|
||||
```
|
||||
|
||||
Função inicial avaliada nas aproximações iniciais:
|
||||
|
@ -240,21 +247,22 @@ for i in range(10):
|
|||
|
||||
a_bi, b_bi = cn.metodo_bisseccao(f, a_bi, b_bi)
|
||||
|
||||
|
||||
print('Raiz encontrada pelo método da secante:')
|
||||
print('x =', x_secante, '| xo =', xo_secante)
|
||||
print('f(x) =', f(x_secante), '| f(xo) =', f(xo_secante))
|
||||
print(f'x = {x_secante} | xo ={xo_secante}')
|
||||
print(f'f(x) = {f(x_secante)} | f(xo) = {f(xo_secante)}')
|
||||
|
||||
print('\nRaiz encontrada pelo método de Newton:')
|
||||
print('x =', x_newton)
|
||||
print('f(x) =', f(x_newton))
|
||||
print(f'x = {x_newton}')
|
||||
print(f'f(x) = {f(x_newton)}')
|
||||
|
||||
print('\nIntervalo encontrado pelo método da bissecção:')
|
||||
print('Raiz está entre:', (a_bi, b_bi))
|
||||
print('f(a) =', f(a_bi), '| f(b) =', f(b_bi))
|
||||
print(f'Raiz está entre: {(a_bi, b_bi)}')
|
||||
print(f'f(a) = {f(a_bi)} | f(b) = {f(b_bi)}')
|
||||
```
|
||||
|
||||
Raiz encontrada pelo método da secante:
|
||||
x = -0.7390851332151607 | xo = -0.7390851332151607
|
||||
x = -0.7390851332151607 | xo =-0.7390851332151607
|
||||
f(x) = 0.0 | f(xo) = 0.0
|
||||
|
||||
Raiz encontrada pelo método de Newton:
|
||||
|
@ -265,3 +273,102 @@ print('f(a) =', f(a_bi), '| f(b) =', f(b_bi))
|
|||
Raiz está entre: (-0.7392578125, -0.73828125)
|
||||
f(a) = -0.0002890091467900868 | f(b) = 0.001345149751805108
|
||||
|
||||
|
||||
## *aluno_exatas.circuitos_eletricos*
|
||||
|
||||
Esse módulo tem como função auxiliar o aluno que está cursando circuitos elétricos. Sua principal função é a implementação de funções que facilitam o uso de fasores.
|
||||
|
||||
#### Importando módulos úteis:
|
||||
|
||||
|
||||
```python
|
||||
import aluno_exatas.circuitos_eletricos as ce
|
||||
import numpy as np
|
||||
```
|
||||
|
||||
### Fasores
|
||||
|
||||
Essas funções permitem fazer a conversão entre números complexos nativos de Python e a representação fasorial (magnitude e defasagem).
|
||||
|
||||
#### Importando as funções relativas a fasores:
|
||||
|
||||
|
||||
```python
|
||||
from aluno_exatas.circuitos_eletricos.fasores import *
|
||||
```
|
||||
|
||||
#### Definindo constantes para serem testadas
|
||||
|
||||
Vamos definir o mesmo número em duas representações diferentes, e verificar que as funções utilizadas retornam a mesma coisa.
|
||||
|
||||
|
||||
```python
|
||||
numero_complexo = 3 + 4j
|
||||
|
||||
magnitude = 5
|
||||
angulo_rad = np.arctan(4 / 3)
|
||||
angulo_deg = np.rad2deg(angulo_rad)
|
||||
|
||||
print(f'Ângulo em radianos: {angulo_rad:1.4f} e em graus: {angulo_deg:1.4f}')
|
||||
```
|
||||
|
||||
Ângulo em radianos: 0.9273 e em graus: 53.1301
|
||||
|
||||
|
||||
#### Funções do módulo
|
||||
|
||||
O módulo define duas funções base:
|
||||
* `complexo_para_polar`;
|
||||
* `polar_para_complexo`.
|
||||
|
||||
No entanto, essas funções têm nomes muito longos, e portanto é mais simples utilizar as versões com nomes simplificados:
|
||||
* `c2p`: converte números complexos para representação fasorial;
|
||||
* `p2c`: converte a representação fasorial para um número complexo;
|
||||
* `c2pr`: a mesma coisa que `c2p`, mas os ângulos são representados em radianos;
|
||||
* `p2cr`: a mesma coisa que `p2c`, mas os ângulos são representados em radianos;
|
||||
|
||||
|
||||
```python
|
||||
print(f'O número {numero_complexo} em coordenadas polares utilizando graus é: {c2p(numero_complexo)}.')
|
||||
print(f'O número {numero_complexo} em coordenadas polares utilizando radianos é: {c2pr(numero_complexo)}.\n')
|
||||
|
||||
print(f'O fasor de magnitude {magnitude} e com defasagem {angulo_deg:1.4f} graus ou {angulo_rad:1.4f} rad é igual a {p2c(magnitude, angulo_deg):1.4}')
|
||||
```
|
||||
|
||||
O número (3+4j) em coordenadas polares utilizando graus é: (5.0, 53.13010235415598).
|
||||
O número (3+4j) em coordenadas polares utilizando radianos é: (5.0, 0.9272952180016122).
|
||||
|
||||
O fasor de magnitude 5 e com defasagem 53.1301 graus ou 0.9273 rad é igual a (3+4j)
|
||||
|
||||
|
||||
#### Testando ida e volta das funções
|
||||
|
||||
Dado que as funções aqui exploradas permitem a conversão entre duas representações, é de se esperar que elas permitam reverter uma conversão. Isso pode ser observado abaixo.
|
||||
|
||||
|
||||
```python
|
||||
numero_complexo_novo = p2c(*c2p(numero_complexo))
|
||||
|
||||
print(f'Número complexo - velho: {numero_complexo:1.4} e novo: {numero_complexo_novo:1.4}.\n')
|
||||
|
||||
|
||||
magnitude_nova, angulo_deg_novo = c2p(p2c(magnitude, angulo_deg))
|
||||
|
||||
print(f'Magnitude - velha: {magnitude:1.4f} e nova: {magnitude_nova:1.4f}.')
|
||||
print(f'Ângulo em graus - velho: {angulo_deg:1.4f} e novo: {angulo_deg_novo:1.4f}.\n')
|
||||
|
||||
|
||||
magnitude_nova, angulo_rad_novo = c2pr(p2cr(magnitude, angulo_rad))
|
||||
|
||||
print(f'Magnitude - velha: {magnitude:1.4f} e nova: {magnitude_nova:1.4f}.')
|
||||
print(f'Ângulo em radianos - velho: {angulo_rad:1.4f} e novo: {angulo_rad_novo:1.4f}.')
|
||||
```
|
||||
|
||||
Número complexo - velho: (3+4j) e novo: (3+4j).
|
||||
|
||||
Magnitude - velha: 5.0000 e nova: 5.0000.
|
||||
Ângulo em graus - velho: 53.1301 e novo: 53.1301.
|
||||
|
||||
Magnitude - velha: 5.0000 e nova: 5.0000.
|
||||
Ângulo em radianos - velho: 0.9273 e novo: 0.9273.
|
||||
|
||||
|
|
Loading…
Reference in New Issue