"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",
"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."
"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)."
"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))"
"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."
"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",
"#### 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"