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.
### *aluno_exatas.fis\_exp.FisExp*
Essa classe é útil principalmente na propagação de incertezas.
#### Importando módulos úteis:
```python
import aluno_exatas.fis_exp as fe
import numpy as np
```
#### Inicializando o módulo
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).
Se, por alguma razão, o usuário desejar integrar ou derivar a função principal, há funções que permitem isso.
```python
print ('Função derivada em relação a "a": ', f.derivar('a'))
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))
print ('Função derivada em relação a "a", com valores conhecidos substituídos: ', f.derivar('a', substituir=True), '\n')
print ('Integral da função em relação a "a": ', f.integrar('a'))
print ('Integral da função em relação a "a", avaliada entre [0,5]: ', f.integrar('a', limites=[0,5]))
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))
```
Função derivada em relação a "a": 2*a
Função derivada em relação a "a", avaliada em a=1, derivada de índice 2: 2
Função derivada em relação a "a", com valores conhecidos substituídos: 8
Integral da função em relação a "a": a**3/3 + a*b*c
Integral da função em relação a "a", avaliada entre [0,5]: 5*b*c + 125/3
Integral da função em relação a "c", avaliada entre [0,5], com valores conhecidos substituídos: 105
### *aluno_exatas.fis\_exp.MMQ*
Essa classe foi feita para facilitar a utilização do MMQ linear, com incertezas variáveis ou não.
#### Importação de módulos
O módulo `fis_exp` já foi importado, de forma que não é necessário importá-lo novamente.
#### Inicializando o módulo
O módulo pode ser inicializado de diferentes formas, dependendo de que tipo de MMQ se quer calcular.
```python
mmq_inc_iguais = fe.MMQ()
mmq_inc_varia = fe.MMQ(fe.Incertezas.variaveis)
```
#### Definição de valores
Os módulos podem receber `lists`, `numpy.ndarrays` ou números normais (no caso de `incerteza_y` para incertezas iguais).
```python
x = [0, 1, 2, 3, 4]
y = np.array([1, 3, 7, 8, 10])
mmq_inc_iguais.x_values = x
mmq_inc_iguais.y_values = y
mmq_inc_iguais.incertezas_y = 1
mmq_inc_varia.x_values = x
mmq_inc_varia.y_values = y
mmq_inc_varia.incertezas_y = [1, 1, 2, 1, 3]
```
#### Recebendo de volta os coeficientes
Os coeficientes da função na forma `y = a + b*x` são retornados no formato `[a,b]`, assim como as incertezas.
Função inicial avaliada nas aproximações iniciais:
f(-1) = -0.45969769413186023
f(0) = 1.0
f(1) = 1.5403023058681398
#### Testando cada um dos métodos
Os métodos irão rodar por 9 iterações e será possível observar a qualidade da aproximação de cada um.
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.
#### 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')