testes curva_minmax em regressões

Author: viniciusdutra314

LabIFSC2/__init__.py

@@ -11,6 +11,6 @@
                       nominais)
 from ._medida import (Comparacao, Medida, alterar_monte_carlo_samples,
                       comparar_medidas)
-from ._regressões import (regressao_exponencial, regressao_linear,
+from ._regressoes import (regressao_exponencial, regressao_linear,
                           regressao_polinomial, regressao_potencia)
 from .constantes import constantes

LabIFSC2/_arrays.py

@@ -5,7 +5,7 @@
 import numpy as np
 
 from ._medida import Medida
-from ._regressões import Regressao
+from ._regressoes import Regressao
 from ._tipagem_forte import obrigar_tipos
 
 
@@ -58,6 +58,9 @@ def incertezas(arrayMedidas : np.ndarray,unidade:str) -> np.ndarray:
 
 @obrigar_tipos
 def _curva_min_max(arrayMedidas : np.ndarray| Regressao,op:str,unidade_y:str,sigmas:float | int) -> np.ndarray:
+    if sigmas<=0:
+        raise ValueError('O número de sigmas deve ser positivo')
+    
     if isinstance(arrayMedidas,np.ndarray):
         if not (isinstance(arrayMedidas[0],Medida)):
             raise TypeError('Os valores do array não são Medidas')

LabIFSC2/_medida.py

@@ -220,13 +220,55 @@ def __getattr__(self, func_name:str) -> Any:
             func=getattr(np,func_name)
             def funcao_recebe_medida() -> Any: return montecarlo(func, self)
             return funcao_recebe_medida
+    
+    '''Essas funções de comparação são necessárias para que max,min ou
+    np.max,np.min funcionem com medidas do jeito esperado (comparar o valor nominal)
+    Repare que não há implementação == e !=, use a função comparar_medidas.
+    '''
+    def __eq__(self:'Medida',outro:Any)-> bool:
+       raise TypeError('"Como a comparação entre Medidas pode gerar três resultados \
+    diferentes: iguais, diferentes, ou inconclusivo, optamos por fazer uma função separada \
+    chamada compara_medidas(x:Medida,y:Medida) -> [Iguais | Diferentes | Inconclusivo]"')
+    
+    def __ne__(self:'Medida',outro:Any)-> bool:
+        raise TypeError('"Como a comparação entre Medidas pode gerar três resultados \
+    diferentes: iguais, diferentes, ou inconclusivo, optamos por fazer uma função separada \
+    chamada compara_medidas(x:Medida,y:Medida) -> [Iguais | Diferentes | Inconclusivo]"')
+    
+    def __le__(self:'Medida',outro:Any) -> bool:
+        if not isinstance(outro,Medida):
+            return NotImplemented
+        else:
+            return bool(self._nominal<=outro._nominal)
+    
+    def __lt__(self:'Medida',outro:Any) -> bool:
+        if not isinstance(outro,Medida):
+            return NotImplemented
+        else:
+            return bool(self._nominal<outro._nominal)
+    def __ge__(self:'Medida',outro:Any) -> bool:
+        if not isinstance(outro,Medida):
+            return NotImplemented
+        else:
+            return bool(self._nominal>=outro._nominal)
+    
+    def __gt__(self:'Medida',outro:Any) -> bool:
+        if not isinstance(outro,Medida):
+            return NotImplemented
+        else:
+            return bool(self._nominal>outro._nominal)
+
+
     def _adicao_subtracao(self,outro: 'Medida',positivo:bool) -> 'Medida':
         if not (isinstance(outro,Medida) or isinstance(outro,Real)):
             return NotImplemented
         if isinstance(outro,Real):
-            self._nominal+=outro
-            self._histograma+=outro
-            return self
+            if positivo:
+                nova_medida=Medida(self._nominal.magnitude+outro,str(self._nominal.units),self._incerteza.magnitude)
+            else:
+                nova_medida=Medida(self._nominal.magnitude-outro,str(self._nominal.units),self._incerteza.magnitude)
+            nova_medida._histograma=self._histograma
+            return nova_medida
 
         if self._nominal.is_compatible_with(outro._nominal):
             if self is outro:
@@ -295,27 +337,8 @@ def __pow__(self:'Medida',outro:Any) -> 'Medida':
     def __rpow__(self:'Medida',outro:Any) -> 'Medida':
         if isinstance(outro,Real):
             return montecarlo(lambda x: np.pow(float(outro),x),self)
-        elif isinstance(outro,Medida):
-            return montecarlo(lambda x,y: x**y,self,outro)
         else:
             return NotImplemented
-    def __eq__(self:'Medida',outro:Any)->bool:
-        if self is outro:
-            return True
-        else:
-            raise TypeError("Como a comparação entre Medidas pode gerar três resultados \
-    diferentes: iguais, diferentes, ou inconclusivo, optamos por fazer uma função separada \
-    chamada compara_medidas(x:Medida,y:Medida) -> [Iguais | Diferentes | Inconclusivo], por favor \
-    não use !=,==,<=,<,>,>= diretamente com Medidas")
-    def __ne__(self:'Medida',outro:Any)->bool:
-        if self is outro:
-            return False
-        else:
-            raise TypeError("Como a comparação entre Medidas pode gerar três resultados \
-    diferentes: iguais, diferentes, ou inconclusivo, optamos por fazer uma função separada \
-    chamada compara_medidas(x:Medida,y:Medida) -> [Iguais | Diferentes | Inconclusivo], por favor \
-    não use !=,==,<=,<,>,>= diretamente com Medidas")
-
 
     __radd__=__add__
     __rsub__=__sub__

LabIFSC2/_regressões.py LabIFSC2/_regressoes.pyLabIFSC2/_regressões.py renamed to LabIFSC2/_regressoes.py

@@ -40,7 +40,7 @@ def _forcar_troca_de_unidade(array_medidas:np.ndarray,unidade:str)-> np.ndarray:
 class Regressao(ABC):
 
     def __init__(self)->None:
-        self._amostragem_pre_calculada: np.ndarray = np.array([])
+        self._amostragem_pre_calculada: np.ndarray | None=None 
         self._valores: Iterator = iter([])
 
     def _retornar(self,y:np.ndarray,unidade_y:str)->np.ndarray:
@@ -66,26 +66,13 @@ def amostrar(self, x:np.ndarray,unidade_y:str) -> np.ndarray:...
     def __iter__(self)->Iterator[object]:
         return self._valores
 
-    def mudar_intervalo_de_confianca(self,sigmas:Real)->None:
-        """
-        Altera o intervalo de confiança para o valor especificado.
-        
-        Args:
-            sigmas (Real): O novo valor do intervalo de confiança.
-        
-        Returns:
-            None
-        """
-        if sigmas<0:
-            raise ValueError('O intervalo de confiança precisa ser um valor positivo')
-
-        self._sigmas=float(sigmas)
 
 
 
 class MPolinomio(Regressao):
     @obrigar_tipos
     def __init__(self,coeficientes:np.ndarray):
+        super().__init__()
         if not (isinstance(coeficientes[0],Medida)):
             raise TypeError('Os valores do array não são Medidas')
 
@@ -130,6 +117,7 @@ class MExponencial(Regressao):
     __slots__ = ['cte_multiplicativa', 'expoente', 'base','_valores']
     @obrigar_tipos
     def __init__(self,a:Medida,k:Medida,base:Real):
+        super().__init__()
         self.cte_multiplicativa=a
         self.base=base
         self.expoente=k

pyproject.toml

@@ -44,7 +44,7 @@ disallow_any_generics = false
 exclude = 'tests/.*'
 
 [tool.taskipy.tasks]
-testes={ cmd="isort . && mypy LabIFSC2/ && pytest -vv -x -s --cov LabIFSC2/ --no-cov-on-fail --cov-branch --cov-report=html "}
+testes={ cmd="isort . && mypy LabIFSC2/ && pytest -vv -x -s --cov LabIFSC2/ --cov-append  --no-cov-on-fail --cov-branch --cov-report=html "}
 docs="mkdocs serve"
 
 [build-system]

tests/test_arrayM.py

@@ -2,7 +2,7 @@
 import pytest
 
 from LabIFSC2 import (Medida, arrayM, curva_max, curva_min, incertezas,
-                      linspaceM, nominais)
+                      linspaceM, nominais, regressao_linear)
 
 
 def test_nominal():
@@ -14,31 +14,70 @@ def test_nominal():
     assert nominal[2]==-34
     assert nominal[3]==-5313.351
     with pytest.raises(TypeError):
-        nominais(np.arange(10))
+        nominais(np.arange(10),'')
+    x=np.array([Medida(13431,'cm',351),Medida(0.006132,'cm',4),
+                Medida(-34,'cm',3),Medida(-5313.351,'cm',3)])
+    metros=nominais(x,'si')
+    valores=[13431,0.006132,-34,-5313.351]
+    for x in range(len(metros)):
+        assert np.isclose(metros[x],valores[x]/100)
+
+
+
 
 def test_incerteza_array():
-    x=np.array([Medida(-351,'',3.5),Medida(0.006132,'',4.003),
-                Medida(-34,'',310),Medida(-5313.351,'',0)])
-    incerteza=incertezas(x,'')
+    x=np.array([Medida(-351,'cm',3.5),Medida(0.006132,'cm',4.003),
+                Medida(-34,'cm',310),Medida(-5313.351,'cm',0)])
+    incerteza=incertezas(x,'cm')
     assert incerteza[0]==3.5
     assert incerteza[1]==4.003
     assert incerteza[2]==310
     assert incerteza[3]==0
     with pytest.raises(TypeError):
         incertezas(np.arange(10),'')
-        
+    si_incertezas=incertezas(x,'si')
+    for x in range(len(si_incertezas)):
+        assert np.isclose(si_incertezas[x],incerteza[x]/100)
 
 def test_curvamin():
     t=np.array([Medida(5,'',0.1),Medida(9,'',2),Medida(11,'',0.5)])
     curva_min(t,'')
     assert np.array_equal(curva_min(t,''),np.array([4.8,5,10]))
     assert np.array_equal(curva_min(t,'',3),np.array([4.7,3,9.5]))  
+    with pytest.raises(TypeError):
+        curva_min(np.arange(10),'')
+
+
 def test_curvamax():
     t=np.array([Medida(5,'',0.1),Medida(9,'',2),Medida(11,'',0.5)])
     assert np.array_equal(curva_max(t,''),np.array([5.2,13,12]))
     assert np.array_equal(curva_max(t,'',3),np.array([5.3,15,12.5]))      
+    with pytest.raises(TypeError):
+        curva_max(np.arange(10),'')
+        
+def test_curva_max_regressao():
+    x=np.array([Medida(1,'cm',0.1),Medida(2,'cm',0.1),Medida(3,'cm',0.1),Medida(4,'cm',0.1),Medida(5,'cm',0.1)])
+    y=x
+    linha=regressao_linear(x,y)
+    with pytest.raises(ValueError):
+        curva_max(linha,'')
+    linha.amostrar(x,'cm')
+    valores_nominais=nominais(linha._amostragem_pre_calculada,'m')
+    valores_incertezas=incertezas(linha._amostragem_pre_calculada,'m')
+    curva_maxima=curva_max(linha,'si')
+    curva_minima=curva_min(linha,'si')
+    assert np.array_equal(valores_nominais+2*valores_incertezas,curva_maxima)
+    assert np.array_equal(valores_nominais-2*valores_incertezas,curva_minima)
+    curva_maxima=curva_max(linha,'si',3)
+    curva_minima=curva_min(linha,'si',3)
 
-
+    assert np.array_equal(valores_nominais+3*valores_incertezas,curva_maxima)
+    assert np.array_equal(valores_nominais-3*valores_incertezas,curva_minima)
+    with pytest.raises(ValueError):
+        curva_max(linha,'si',0)
+    with pytest.raises(ValueError):
+        curva_max(linha,'si',-1)
+        
 def test_linspace():
     a=1 ; b=20 ; N=20
     x=linspaceM(a,b,N,'',0.1)

tests/test_classe_medida.py

@@ -20,15 +20,16 @@ def test_inicializacao():
 def test_comparacoes():
     x=lab.Medida(5, '', 1)
     y=lab.Medida(6, '', 0.1)
-    comparacoes=[lambda x,y: x==y,lambda x,y: x!=y,
-                 lambda x,y: x>y, lambda x,y: x>=y,
-                 lambda x,y: x<y, lambda x,y: x<=y]
+    comparacoes=[lambda x,y: x==y,lambda x,y: x!=y]
     for comparacao in comparacoes:
         with pytest.raises(TypeError):
             comparacao(x,y)
-    assert x==x 
-    assert not x!=x
-    
+    comparacoes=[lambda x,y: x<y,lambda x,y: x<=y,lambda x,y: x>y,lambda x,y: x>=y]
+    for comparacao in comparacoes:
+        with pytest.raises(TypeError):
+            comparacao(x,3)
+
+
 def test_igualdades():
     x=lab.Medida(1, '', 0.1)
     y=lab.Medida(0.9, '', 0.01)

tests/test_classe_medida_operacoes.py

@@ -7,6 +7,11 @@
 def test_soma():
 
     x, y = lab.Medida(0, '', 0.1), lab.Medida(5, '', 0.3)
+
+    assert (y+3).nominal('')==8
+    assert (y-3).nominal('')==2
+    assert (y-3.13).nominal('')==5-3.13
+
     assert (x + y).nominal("") == 5
     assert (x + y).incerteza("") == np.sqrt(0.1**2 + 0.3**2)
 

tests/test_classe_para_regressoes.py

@@ -7,17 +7,16 @@
 def test_initialization():
     coeficientes = lab.linspaceM(1,3,3,'',0)
     with pytest.raises(TypeError):
-        lab._regressões.MPolinomio(np.array([1, 2, 3]))
-    polinomio=lab._regressões.MPolinomio(coeficientes)
-    assert np.array_equal(polinomio._coeficientes,coeficientes)
+        lab._regressoes.MPolinomio(np.array([1, 2, 3]))
+    polinomio=lab._regressoes.MPolinomio(coeficientes)
     assert polinomio.grau == 2
     assert polinomio.a.nominal("") == 1
     assert polinomio.b.nominal("") == 2
     assert polinomio.c.nominal("") == 3
 
 def test_call():
     coeficientes = lab.linspaceM(1,3,3,'',0)
-    polinomio=lab._regressões.MPolinomio(coeficientes)
+    polinomio=lab._regressoes.MPolinomio(coeficientes)
     with pytest.raises(TypeError):
         polinomio(0)
     pontos=lab.linspaceM(0,2,3,'',0)
@@ -29,7 +28,7 @@ def test_call():
 
 def test_unpacking():
     coeficientes = lab.linspaceM(1,3,3,'',0)
-    polinomio = lab._regressões.MPolinomio(coeficientes)
+    polinomio = lab._regressoes.MPolinomio(coeficientes)
     a, b, c = polinomio
     assert a.nominal("") == 1
     assert b.nominal("") == 2

tests/test_doc_dimensao.py

@@ -0,0 +1,8 @@
+from LabIFSC2 import *
+
+
+def test_doc_dimensao():
+    velocidade=Medida(10,'m/s',0.1)
+    print(velocidade.dimensao) #[length] / [time]
+
+    assert str(velocidade.dimensao) == '[length] / [time]'