API Completa

Aqui nós temos todas as docstrings de todos os métodos e classes que o usuário da biblioteca encontrará, somente classes e métodos internos não estão aqui documentados.

Eu só recomendo dar uma olhada nisso aquelas pessoas que estão já muito acostumados com a biblioteca e querem encontrar algum detalhe que não está tão bem explicado na documentação, caso contrário, por favor leia a seção introdução

Medida

Source code in LabIFSC2/_medida.py

class Medida:

    @obrigar_tipos
    def __init__(self,nominal:Real | list,unidade : str,incerteza : Real):
        """
        Inicializa uma instância da classe com valores nominais, unidade e incerteza.

        Args:
            nominal (Real | list): Valor nominal ou uma lista de valores nominais.
            unidade (str): Unidade de medida.
            incerteza (Real): Incerteza associada ao valor nominal.

        Raises:
            ValueError: Se a incerteza for negativa.
            ValueError: Se a lista de medidas tiver menos de 2 elementos.
        """

        if incerteza<0: raise ValueError("Incerteza não pode ser negativa")

        if isinstance(nominal,list):
            if len(nominal)<2:
                raise ValueError("Lista de medidas deve ter pelo menos 2 elementos")
            mean=np.average(nominal)
            std=np.std(nominal,ddof=1)
            self._nominal= ureg.Quantity(mean,unidade).to_reduced_units()
            if std>incerteza:
                self._incerteza=ureg.Quantity(std,unidade).to_reduced_units()
            else:
                self._incerteza=ureg.Quantity(incerteza,unidade).to_reduced_units()
        else:
            self._nominal=ureg.Quantity(nominal,unidade).to_reduced_units()
            self._incerteza=ureg.Quantity(incerteza,unidade).to_reduced_units()
        self._histograma:Any=None
        self._nominal.ito_reduced_units
        self._incerteza.ito_reduced_units

    @obrigar_tipos
    def nominal(self:'Medida',unidade:str) -> float:
        """
        Retorna o valor nominal da medida na unidade especificada.

        Args:
            unidade (str): A unidade na qual o valor nominal deve ser retornado. 
                           Se 'si', retorna o valor em unidades do Sistema Internacional (SI).

        Returns:
            float: O valor nominal da medida na unidade especificada.
        """
        if unidade.lower()=='si':
            return float(self._nominal.to_base_units().magnitude)
        else:
            return float(self._nominal.to(unidade).magnitude)
    @obrigar_tipos
    def incerteza(self:'Medida',unidade:str) -> float:
        """
        Retorna a incerteza da medida na unidade especificada.

        Args:
            unidade (str): A unidade na qual a incerteza deve ser retornado. 
                           Se 'si', retorna o valor em unidades do Sistema Internacional (SI).

        Returns:
            float: O valor da incerteza da medida na unidade especificada.
        """
        if unidade.lower()=='si':
            return float(self._incerteza.to_base_units().magnitude)
        else:
            return float(self._incerteza.to(unidade).magnitude)

    @property
    def dimensao(self:'Medida') -> UnitsContainer:
        return self._nominal.dimensionality

    @property
    def histograma(self:'Medida') -> Any:
        if self._histograma is None:
            if self._incerteza.magnitude!=0:
                self._histograma=np.random.normal(self._nominal.magnitude,
                                                  self._incerteza.magnitude,
                                                  size=MCSamples)*self._nominal.units
            else:
                self._histograma=self._nominal
        return self._histograma

    @obrigar_tipos
    def __format__(self, format_spec:str) -> str:


        #parsing format_spec
        format_spec=format_spec.lower()
        match_reg=re.search(r'e([+-]?\d+)',format_spec) #E3=3, -E1=-1, +E2=2
        fmt_exp=int(match_reg.group(1)) if match_reg else False
        unidade=format_spec.split('_')[0]

        if unidade=='':
            unidade=str(self._nominal.units)
            nominal_pint = self._nominal
            incerteza_pint = self._incerteza
        elif unidade=='si':
            nominal_pint=self._nominal.to_base_units()
            incerteza_pint=self._incerteza.to_base_units()
        elif not (re.search(r'e[+-]?(\d+)',unidade) or 'latex' in unidade):
            nominal_pint=self._nominal.to(unidade)
            incerteza_pint=self._incerteza.to(unidade)
        else:
            nominal_pint = self._nominal
            incerteza_pint = self._incerteza
            unidade=str(self._nominal.units)
        nominal=Decimal(nominal_pint.magnitude)
        incerteza=Decimal(incerteza_pint.magnitude)

        exato= (incerteza==0)
        latex= ('latex' in format_spec)
        #templates
        template_console=Template(r"($nominal ± $incerteza)$potencia $unidade")
        template_console_exato=Template(r"$nominal$potencia $unidade")
        template_latex=Template(r"($nominal \, \pm \, $incerteza)$potencia \, $unidade")
        template_latex_exato=Template(r"$nominal$potencia \, $unidade")



        og_nominal = math.floor(math.log10(abs(nominal))) if nominal else 0

        if fmt_exp is False:
            nominal *= Decimal(f"1e{-og_nominal}")
            incerteza *= Decimal(f"1e{-og_nominal}")
        else:
            nominal *= Decimal(f"1e{-fmt_exp}")
            incerteza *= Decimal(f"1e{-fmt_exp}")

        #arredondando nominal e incerteza
        og_incerteza = math.floor(math.log10(abs(incerteza))) if incerteza else 0
        arred_nominal = nominal.quantize(Decimal(f'1e{og_incerteza}'), rounding=ROUND_HALF_UP) if not exato else nominal
        arred_incerteza = incerteza.quantize(Decimal(f'1e{og_incerteza}'), rounding=ROUND_HALF_UP) if not exato else incerteza
        arred_nominal_str = str(arred_nominal).replace(".", ",")
        arred_incerteza_str = str(arred_incerteza).replace(".", ",")

        #potencia bonitinha
        expoente_normalizacao=fmt_exp if fmt_exp is not False else og_nominal
        if expoente_normalizacao==0: potencia_bonita=''
        elif latex:
            potencia_bonita=rf"\times 10^{{{expoente_normalizacao}}}"
        elif not latex:
            superscript_map = {'0': '⁰', '1': '¹', '2': '²', '3': '³', '4': '⁴',
            '5': '⁵', '6': '⁶', '7': '⁷', '8': '⁸', '9': '⁹','-': '⁻'}
            potencia_bonita = 'x10'+''.join(superscript_map[char] for char in str(expoente_normalizacao))

        #escolhendo template
        if exato:
            if latex: template = template_latex_exato
            else: template = template_console_exato
        else:
            if latex: template = template_latex
            else: template = template_console

        unidade=f"{nominal_pint.units:~L}" if latex else f"{nominal_pint.units:~P}"
        return template.substitute(nominal=arred_nominal_str,incerteza=arred_incerteza_str,
                                           potencia=potencia_bonita,unidade=unidade)

    def __str__(self) -> str:
        printado:str=self.__format__('')
        return printado
    def __repr__(self) -> str:
        representacao:str=self.__format__('')
        return representacao

    '''O método abaixo faz a magia que basicamente qualquer função do numpy possa
    ser aplicada diretamente em uma medida
    '''
    def __getattr__(self, func_name:str) -> Any:
        funcoes_suportadas=['sin','cos','exp','sqrt',"sinh","cosh","tanh","arcsinh","arccosh",
                            "arctanh","cbrt","power","pow",
                            'tan','arcsin','arccos','arctan','log','log2','log10']
        if func_name not in funcoes_suportadas:
            raise AttributeError
        else:
            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):
            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:
                return 2*self if positivo else Medida(0,str(self._nominal.units),0)

            elif (self._histograma is None and outro._histograma is None):
                #Como existe solução analítica da soma/subtração entre duas gaussianas
                #iremos usar esse resultado para otimizar o código
                if positivo: media=self._nominal+outro._nominal
                else: media=self._nominal-outro._nominal
                desvio_padrao=(self._incerteza**2 + outro._incerteza**2)**(1/2)
                desvio_padrao.ito(media.units)
                return Medida(media.magnitude,str(media.units),desvio_padrao.magnitude)
            else:
                if positivo: return montecarlo(lambda x,y: x+y,self,outro)
                else : return montecarlo(lambda x,y: x-y,self,outro)
        else:
            raise ValueError(f"A soma/subtração entre {self._nominal.dimensionality} e \
{outro._nominal.dimensionality} não é possível")

    def __add__(self:'Medida',outro:Any) -> 'Medida':
        return self._adicao_subtracao(outro,True)
    def __sub__(self:'Medida',outro:Any)-> 'Medida':
        return self._adicao_subtracao(outro,False)

    def __mul__(self:'Medida',outro:Any)-> 'Medida':
        if self is outro: return montecarlo(lambda x: x**2,self)
        elif isinstance(outro,Medida):
            return montecarlo(lambda x,y: x*y,self,outro)
        elif isinstance(outro,Real):
            resultado=Medida(self._nominal.magnitude*outro,str(self._nominal.units),abs(self._incerteza.magnitude*outro),)
            if self._histograma is not None:
                resultado._histograma=self._histograma*outro
            return resultado
        else:
            return NotImplemented

    def __truediv__(self:'Medida', outro:Any) -> 'Medida':
        if self is outro: return Medida(1,str(self._nominal.units),0)
        elif isinstance(outro,Real):
            resultado=Medida(self._nominal.magnitude/float(outro),
                             str(self._nominal.units),
                             self._incerteza.magnitude/abs(float(outro)),
                             )
            if self._histograma is not None:
                resultado._histograma=self._histograma/float(outro)
            return resultado
        elif isinstance(outro,Medida):
            return montecarlo(lambda x,y: x/y,self,outro)
        else:
            return NotImplemented

    def __rtruediv__(self:'Medida',outro:Any) -> 'Medida':
        if isinstance(outro,Real):
            return montecarlo(lambda x: outro/x,self)
        else:
            return NotImplemented

    def __pow__(self:'Medida',outro:Any) -> 'Medida':
        if isinstance(outro,Real):
            return montecarlo(lambda x: np.power(x,float(outro)),self)
        elif isinstance(outro,Medida):
            return montecarlo(lambda x,y: x**y,self,outro)
        else:
            return NotImplemented
    def __rpow__(self:'Medida',outro:Any) -> 'Medida':
        if isinstance(outro,Real):
            return montecarlo(lambda x: np.power(float(outro),x),self)
        else:
            return NotImplemented

    __radd__=__add__
    __rsub__=__sub__
    __rmul__=__mul__

    def __abs__(self:'Medida') -> 'Medida':
        resultado=Medida(abs(self._nominal.magnitude),
                         str(self._nominal.units),
                         self._incerteza.magnitude,)
        if self._histograma is not None:
            resultado._histograma=abs(self._histograma)
        return resultado

    def __neg__(self:'Medida') -> 'Medida':
        resultado=Medida(-(self._nominal.magnitude),
                         str(self._nominal.units),
                         self._incerteza.magnitude,)
        if self._histograma is not None:
            resultado._histograma=-self._histograma
        return resultado

    def __pos__(self) -> 'Medida':
        return self

    @obrigar_tipos
    def probabilidade_de_estar_entre(self,a:Real,b:Real,unidade:str) -> float:
        """
        Calcula a probabilidade de uma medida estar entre dois valores especificados.

        Args:
            a (Real): O valor inferior do intervalo.
            b (Real): O valor superior do intervalo.
            unidade (str): A unidade de medida dos valores a e b.

        Returns:
            float: A probabilidade de a medida estar entre os valores a e b.

        Raises:
            ValueError: Se o valor de `a` for maior que `b`.
            ValueError: Se a unidade fornecida não for compatível com a unidade da medida.
        """
        if a>b: raise ValueError("a deve ser menor que b")
        if not self._nominal.is_compatible_with(unidade):
                raise ValueError(f"Unidade {unidade} não é compatível com a unidade da medida")

        if self._histograma is None:
            #estamos resolvendo de maneira análitica
            mu=self._nominal.to(unidade).magnitude
            sigma=self._incerteza.to(unidade).magnitude
            gaussiana=NormalDist(mu,sigma)
            return gaussiana.cdf(float(b))-gaussiana.cdf(float(a))
        else:
            a_quantidade=ureg.Quantity(a,unidade)
            b_quantidade=ureg.Quantity(b,unidade)
            probabilidade= np.mean((self._histograma >= a_quantidade) & (self._histograma <= b_quantidade),dtype=float)
            return float(probabilidade)

    @obrigar_tipos
    def intervalo_de_confiança(self:'Medida',p:Real,unidade:str) -> list:
        """
        Calcula o intervalo de confiança para a medida.

        Args:
            p (Real): Probabilidade associada ao intervalo de confiança. Deve estar entre 0 e 1.
            unidade (str): Unidade de medida para o intervalo de confiança.

        Returns:
            list: Lista contendo os limites inferior e superior do intervalo de confiança.

        Raises:
            ValueError: Se `p` não estiver entre 0 e 1.
        """

        if not 0<float(p)<=1: raise ValueError("p deve estar 0 e 1")

        elif p==1: return [float(min(self.histograma.magnitude)),float(max(self.histograma.magnitude))]

        elif self._histograma is None:
            #estamos resolvendo de maneira analítica
            mu=self._nominal.magnitude
            sigma=self._incerteza.magnitude
            gaussiana=NormalDist(mu,sigma)
            limite_inferior=gaussiana.inv_cdf((1-float(p))/2)
            limite_superior=gaussiana.inv_cdf((1+float(p))/2)
            return [limite_inferior,limite_superior]
        else:
            self._histograma.sort()
            self._histograma.ito(unidade)
            num_elements = len(self._histograma)
            selected_elements = int(np.floor(float(p) * num_elements))
            magnitudes = np.array([item.magnitude for item in self._histograma])
            intervals = magnitudes[selected_elements:] - magnitudes[:-selected_elements]

            shortest_interval_index = np.argmin(intervals)
            shortest_interval = [float(self._histograma[shortest_interval_index].magnitude),
                                float(self._histograma[shortest_interval_index + selected_elements].magnitude)]
            return shortest_interval

__init__(nominal, unidade, incerteza)

Inicializa uma instância da classe com valores nominais, unidade e incerteza.

Parameters:

Name	Type	Description	Default
nominal	Real | list	Valor nominal ou uma lista de valores nominais.	required
unidade	str	Unidade de medida.	required
incerteza	Real	Incerteza associada ao valor nominal.	required

Raises:

Type	Description
ValueError	Se a incerteza for negativa.
ValueError	Se a lista de medidas tiver menos de 2 elementos.

Source code in LabIFSC2/_medida.py

@obrigar_tipos
def __init__(self,nominal:Real | list,unidade : str,incerteza : Real):
    """
    Inicializa uma instância da classe com valores nominais, unidade e incerteza.

    Args:
        nominal (Real | list): Valor nominal ou uma lista de valores nominais.
        unidade (str): Unidade de medida.
        incerteza (Real): Incerteza associada ao valor nominal.

    Raises:
        ValueError: Se a incerteza for negativa.
        ValueError: Se a lista de medidas tiver menos de 2 elementos.
    """

    if incerteza<0: raise ValueError("Incerteza não pode ser negativa")

    if isinstance(nominal,list):
        if len(nominal)<2:
            raise ValueError("Lista de medidas deve ter pelo menos 2 elementos")
        mean=np.average(nominal)
        std=np.std(nominal,ddof=1)
        self._nominal= ureg.Quantity(mean,unidade).to_reduced_units()
        if std>incerteza:
            self._incerteza=ureg.Quantity(std,unidade).to_reduced_units()
        else:
            self._incerteza=ureg.Quantity(incerteza,unidade).to_reduced_units()
    else:
        self._nominal=ureg.Quantity(nominal,unidade).to_reduced_units()
        self._incerteza=ureg.Quantity(incerteza,unidade).to_reduced_units()
    self._histograma:Any=None
    self._nominal.ito_reduced_units
    self._incerteza.ito_reduced_units

incerteza(unidade)

Retorna a incerteza da medida na unidade especificada.

Parameters:

Name	Type	Description	Default
unidade	str	A unidade na qual a incerteza deve ser retornado. Se 'si', retorna o valor em unidades do Sistema Internacional (SI).	required

Returns:

Name	Type	Description
float	float	O valor da incerteza da medida na unidade especificada.

Source code in LabIFSC2/_medida.py

@obrigar_tipos
def incerteza(self:'Medida',unidade:str) -> float:
    """
    Retorna a incerteza da medida na unidade especificada.

    Args:
        unidade (str): A unidade na qual a incerteza deve ser retornado. 
                       Se 'si', retorna o valor em unidades do Sistema Internacional (SI).

    Returns:
        float: O valor da incerteza da medida na unidade especificada.
    """
    if unidade.lower()=='si':
        return float(self._incerteza.to_base_units().magnitude)
    else:
        return float(self._incerteza.to(unidade).magnitude)

intervalo_de_confiança(p, unidade)

Calcula o intervalo de confiança para a medida.

Parameters:

Name	Type	Description	Default
p	Real	Probabilidade associada ao intervalo de confiança. Deve estar entre 0 e 1.	required
unidade	str	Unidade de medida para o intervalo de confiança.	required

Returns:

Name	Type	Description
list	list	Lista contendo os limites inferior e superior do intervalo de confiança.

Raises:

Type	Description
ValueError	Se p não estiver entre 0 e 1.

Source code in LabIFSC2/_medida.py

@obrigar_tipos
def intervalo_de_confiança(self:'Medida',p:Real,unidade:str) -> list:
    """
    Calcula o intervalo de confiança para a medida.

    Args:
        p (Real): Probabilidade associada ao intervalo de confiança. Deve estar entre 0 e 1.
        unidade (str): Unidade de medida para o intervalo de confiança.

    Returns:
        list: Lista contendo os limites inferior e superior do intervalo de confiança.

    Raises:
        ValueError: Se `p` não estiver entre 0 e 1.
    """

    if not 0<float(p)<=1: raise ValueError("p deve estar 0 e 1")

    elif p==1: return [float(min(self.histograma.magnitude)),float(max(self.histograma.magnitude))]

    elif self._histograma is None:
        #estamos resolvendo de maneira analítica
        mu=self._nominal.magnitude
        sigma=self._incerteza.magnitude
        gaussiana=NormalDist(mu,sigma)
        limite_inferior=gaussiana.inv_cdf((1-float(p))/2)
        limite_superior=gaussiana.inv_cdf((1+float(p))/2)
        return [limite_inferior,limite_superior]
    else:
        self._histograma.sort()
        self._histograma.ito(unidade)
        num_elements = len(self._histograma)
        selected_elements = int(np.floor(float(p) * num_elements))
        magnitudes = np.array([item.magnitude for item in self._histograma])
        intervals = magnitudes[selected_elements:] - magnitudes[:-selected_elements]

        shortest_interval_index = np.argmin(intervals)
        shortest_interval = [float(self._histograma[shortest_interval_index].magnitude),
                            float(self._histograma[shortest_interval_index + selected_elements].magnitude)]
        return shortest_interval

nominal(unidade)

Retorna o valor nominal da medida na unidade especificada.

Parameters:

Name	Type	Description	Default
unidade	str	A unidade na qual o valor nominal deve ser retornado. Se 'si', retorna o valor em unidades do Sistema Internacional (SI).	required

Returns:

Name	Type	Description
float	float	O valor nominal da medida na unidade especificada.

Source code in LabIFSC2/_medida.py

@obrigar_tipos
def nominal(self:'Medida',unidade:str) -> float:
    """
    Retorna o valor nominal da medida na unidade especificada.

    Args:
        unidade (str): A unidade na qual o valor nominal deve ser retornado. 
                       Se 'si', retorna o valor em unidades do Sistema Internacional (SI).

    Returns:
        float: O valor nominal da medida na unidade especificada.
    """
    if unidade.lower()=='si':
        return float(self._nominal.to_base_units().magnitude)
    else:
        return float(self._nominal.to(unidade).magnitude)

probabilidade_de_estar_entre(a, b, unidade)

Calcula a probabilidade de uma medida estar entre dois valores especificados.

Parameters:

Name	Type	Description	Default
a	Real	O valor inferior do intervalo.	required
b	Real	O valor superior do intervalo.	required
unidade	str	A unidade de medida dos valores a e b.	required

Returns:

Name	Type	Description
float	float	A probabilidade de a medida estar entre os valores a e b.

Raises:

Type	Description
ValueError	Se o valor de a for maior que b.
ValueError	Se a unidade fornecida não for compatível com a unidade da medida.

Source code in LabIFSC2/_medida.py

@obrigar_tipos
def probabilidade_de_estar_entre(self,a:Real,b:Real,unidade:str) -> float:
    """
    Calcula a probabilidade de uma medida estar entre dois valores especificados.

    Args:
        a (Real): O valor inferior do intervalo.
        b (Real): O valor superior do intervalo.
        unidade (str): A unidade de medida dos valores a e b.

    Returns:
        float: A probabilidade de a medida estar entre os valores a e b.

    Raises:
        ValueError: Se o valor de `a` for maior que `b`.
        ValueError: Se a unidade fornecida não for compatível com a unidade da medida.
    """
    if a>b: raise ValueError("a deve ser menor que b")
    if not self._nominal.is_compatible_with(unidade):
            raise ValueError(f"Unidade {unidade} não é compatível com a unidade da medida")

    if self._histograma is None:
        #estamos resolvendo de maneira análitica
        mu=self._nominal.to(unidade).magnitude
        sigma=self._incerteza.to(unidade).magnitude
        gaussiana=NormalDist(mu,sigma)
        return gaussiana.cdf(float(b))-gaussiana.cdf(float(a))
    else:
        a_quantidade=ureg.Quantity(a,unidade)
        b_quantidade=ureg.Quantity(b,unidade)
        probabilidade= np.mean((self._histograma >= a_quantidade) & (self._histograma <= b_quantidade),dtype=float)
        return float(probabilidade)

comparar_medidas(medida1, medida2, sigma_inferior=2, sigma_superior=3)

Compara duas medidas considerando suas incertezas e retorna o resultado da comparação.

Parameters:

Name	Type	Description	Default
medida1	Medida	A primeira medida a ser comparada.	required
medida2	Medida	A segunda medida a ser comparada.	required
sigma_inferior	(float, opcional)	O fator sigma inferior para considerar as medidas equivalentes. Default é 2.	2
sigma_superior	(float, opcional)	O fator sigma superior para considerar as medidas diferentes. Default é 3.	3

Returns:

Name	Type	Description
Comparacao	Comparacao	O resultado da comparação, que pode ser EQUIVALENTES, DIFERENTES ou INCONCLUSIVO.

Raises:

Type	Description
ValueError	Se o sigma_inferior for maior que o sigma_superior.

Source code in LabIFSC2/_medida.py

@obrigar_tipos
def comparar_medidas(medida1: Medida, medida2: Medida, sigma_inferior: float = 2, sigma_superior: float = 3) -> Comparacao:
    """
    Compara duas medidas considerando suas incertezas e retorna o resultado da comparação.

    Args:
        medida1 (Medida): A primeira medida a ser comparada.
        medida2 (Medida): A segunda medida a ser comparada.
        sigma_inferior (float, opcional): O fator sigma inferior para considerar as medidas equivalentes. Default é 2.
        sigma_superior (float, opcional): O fator sigma superior para considerar as medidas diferentes. Default é 3.

    Returns:
        Comparacao: O resultado da comparação, que pode ser EQUIVALENTES, DIFERENTES ou INCONCLUSIVO.

    Raises:
        ValueError: Se o sigma_inferior for maior que o sigma_superior.
    """

    diferenca_nominal=abs(medida1._nominal-medida2._nominal)
    soma_incertezas=medida1._incerteza+medida2._incerteza
    if sigma_inferior>sigma_superior:
        raise ValueError("Sigma para serem consideradas iguais é maior que o sigma \
para serem diferentes")

    if diferenca_nominal<sigma_inferior*soma_incertezas:
        return Comparacao.EQUIVALENTES
    elif diferenca_nominal>sigma_superior*soma_incertezas:
        return Comparacao.DIFERENTES
    else:
        return Comparacao.INCONCLUSIVO

arrayM(nominais, unidade, incerteza)

Cria um array de objetos Medida a partir de valores nominais, unidade e incerteza.

Parameters:

Name	Type	Description	Default
nominais	ndarray | Sequence	Uma sequência de valores nominais.	required
unidade	str	A unidade de medida.	required
incerteza	Real	A incerteza associada aos valores nominais.	required

Returns:

Type	Description
ndarray	np.ndarray: Um array de objetos Medida.

Raises:

Type	Description
TypeError	Se os valores do array não forem números reais.

Source code in LabIFSC2/_arrays.py

@obrigar_tipos
def arrayM(nominais:np.ndarray | Sequence ,unidade:str,incerteza:Real) ->np.ndarray:
    """
    Cria um array de objetos Medida a partir de valores nominais, unidade e incerteza.

    Args:
        nominais (np.ndarray | Sequence): Uma sequência de valores nominais.
        unidade (str): A unidade de medida.
        incerteza (Real): A incerteza associada aos valores nominais.

    Returns:
        np.ndarray: Um array de objetos Medida.

    Raises:
        TypeError: Se os valores do array não forem números reais.
    """

    if not (isinstance(nominais[0],Real)):
        raise TypeError('Os valores do array não são números reais')

    return np.array([Medida(nominal,unidade,incerteza) for nominal in nominais],dtype=Medida)

curva_max(arrayMedidas, unidade_y, sigmas=2)

Calcula a curva máxima de uma série de medidas.

Parameters:

Name	Type	Description	Default
arrayMedidas	ndarray | Regressao	Array de objetos Medida ou objeto Regressao.	required
unidade_y	str	Unidade da variável dependente.	required
sigmas	float | int	Número de sigmas para a curva máxima.	2

Returns:

Type	Description
ndarray	np.ndarray: Array de valores da curva máxima.

Raises:

Type	Description
TypeError	Se algum dos valores no array não for um objeto Medida.

Source code in LabIFSC2/_arrays.py

def curva_max(arrayMedidas:np.ndarray | Regressao, unidade_y:str,sigmas:float | int=2) -> np.ndarray:
    """
    Calcula a curva máxima de uma série de medidas.

    Args:
        arrayMedidas (np.ndarray | Regressao): Array de objetos Medida ou objeto Regressao.
        unidade_y (str): Unidade da variável dependente.
        sigmas (float | int): Número de sigmas para a curva máxima.

    Returns:
        np.ndarray: Array de valores da curva máxima.

    Raises:
        TypeError: Se algum dos valores no array não for um objeto Medida.
    """
    resultado:np.ndarray= _curva_min_max(arrayMedidas,'max',unidade_y,sigmas)
    return resultado

curva_min(arrayMedidas, unidade_y, sigmas=2)

Calcula a curva mínima de uma série de medidas.

Parameters:

Name	Type	Description	Default
arrayMedidas	ndarray | Regressao	Array de objetos Medida ou objeto Regressao.	required
unidade_y	str	Unidade da variável dependente.	required
sigmas	float | int	Número de sigmas para a curva mínima.	2

Returns:

Type	Description
ndarray	np.ndarray: Array de valores da curva mínima.

Raises:

Type	Description
TypeError	Se algum dos valores no array não for um objeto Medida.

Source code in LabIFSC2/_arrays.py

@obrigar_tipos
def curva_min(arrayMedidas:np.ndarray | Regressao,unidade_y:str,sigmas:float | int=2) -> np.ndarray:
    """
    Calcula a curva mínima de uma série de medidas.

    Args:
        arrayMedidas (np.ndarray | Regressao): Array de objetos Medida ou objeto Regressao.
        unidade_y (str): Unidade da variável dependente.
        sigmas (float | int): Número de sigmas para a curva mínima.

    Returns:
        np.ndarray: Array de valores da curva mínima.

    Raises:
        TypeError: Se algum dos valores no array não for um objeto Medida.
    """
    resultado:np.ndarray= _curva_min_max(arrayMedidas,'min',unidade_y,sigmas)
    return resultado

incertezas(arrayMedidas, unidade)

Converte um array de objetos Medida para um array de incertezas em uma unidade especificada.

Parameters:

Name	Type	Description	Default
arrayMedidas	ndarray	Array de objetos Medida.	required
unidade	str	Unidade para a conversão das incertezas. Use 'si' para unidades do Sistema Internacional.	required

Returns:

Type	Description
ndarray	np.ndarray: Array de incertezas convertidas para a unidade especificada.

Raises:

Type	Description
TypeError	Se algum dos valores no array não for um objeto Medida.

Source code in LabIFSC2/_arrays.py

@obrigar_tipos
def incertezas(arrayMedidas : np.ndarray,unidade:str) -> np.ndarray:
    """
        Converte um array de objetos Medida para um array de incertezas em uma unidade especificada.

        Args:
            arrayMedidas (np.ndarray): Array de objetos Medida.
            unidade (str): Unidade para a conversão das incertezas. Use 'si' para unidades do Sistema Internacional.

        Returns:
            np.ndarray: Array de incertezas convertidas para a unidade especificada.

        Raises:
            TypeError: Se algum dos valores no array não for um objeto Medida.
    """

    if not (isinstance(arrayMedidas[0],Medida)):
        raise TypeError('Os valores do array não são Medidas')
    if unidade=='si':
        return np.array([medida._incerteza.to_base_units().magnitude for medida in arrayMedidas],dtype=float)
    else:
        return np.array([medida._incerteza.to(unidade).magnitude for medida in arrayMedidas],dtype=float)

linspaceM(a, b, n, unidade, incertezas)

Gera um array de Medidas com valores igualmente espaçados.

Parameters:

Name	Type	Description	Default
a	Real	O valor inicial do intervalo.	required
b	Real	O valor final do intervalo.	required
n	int	O número de elementos no array.	required
unidade	str	A unidade das medidas.	required
incertezas	Real	A incerteza associada a cada medida.	required

Returns:

Type	Description
ndarray	np.ndarray: Um array de objetos Medida com valores igualmente espaçados.

Source code in LabIFSC2/_arrays.py

@obrigar_tipos
def linspaceM(a:Real,b:Real,n : int,unidade:str,incertezas:Real) -> np.ndarray:
    """Gera um array de Medidas com valores igualmente espaçados.

    Args:
        a (Real): O valor inicial do intervalo.
        b (Real): O valor final do intervalo.
        n (int): O número de elementos no array.
        unidade (str): A unidade das medidas.
        incertezas (Real): A incerteza associada a cada medida.

    Returns:
        np.ndarray: Um array de objetos Medida com valores igualmente espaçados.
    """
    return np.array([Medida(i,unidade,incertezas) for i in np.linspace(float(a),float(b),n)],dtype=object)

nominais(arrayMedidas, unidade)

Converte um array de objetos Medida para um array de valores nominais em uma unidade especificada.

Parameters:

Name	Type	Description	Default
arrayMedidas	ndarray	Array de objetos Medida.	required
unidade	str	Unidade para a conversão dos valores nominais. Use 'si' para unidades do Sistema Internacional.	required

Returns:

Type	Description
ndarray	np.ndarray: Array de valores nominais convertidos para a unidade especificada.

Raises:

Type	Description
TypeError	Se algum dos valores no array não for um objeto Medida.

Source code in LabIFSC2/_arrays.py

@obrigar_tipos
def nominais(arrayMedidas : np.ndarray,unidade:str) -> np.ndarray:
    """
        Converte um array de objetos Medida para um array de valores nominais em uma unidade especificada.

        Args:
            arrayMedidas (np.ndarray): Array de objetos Medida.
            unidade (str): Unidade para a conversão dos valores nominais. Use 'si' para unidades do Sistema Internacional.

        Returns:
            np.ndarray: Array de valores nominais convertidos para a unidade especificada.

        Raises:
            TypeError: Se algum dos valores no array não for um objeto Medida.
    """


    if not (isinstance(arrayMedidas[0],Medida)):
        raise TypeError('Os valores do array não são Medidas')
    if unidade=='si':
        return np.array([medida._nominal.to_base_units().magnitude for medida in arrayMedidas],dtype=float)
    else:
        return np.array([medida._nominal.to(unidade).magnitude for medida in arrayMedidas],dtype=float)

MExponencial

Bases: Regressao

Classe para modelar uma função exponencial y = a * base^(kx)

Source code in LabIFSC2/_regressoes.py

class MExponencial(Regressao):
    '''Classe para modelar uma função exponencial
    y = a * base^(kx)
    '''
    __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
        self._valores=iter((a,k,base))

    @obrigar_tipos
    def amostrar(self:'MExponencial', x:np.ndarray,unidade_y:str)->np.ndarray:
        """
        Gera uma amostra de valores exponenciais com base nos parâmetros fornecidos.
        Args:
            x (np.ndarray): Um array de valores de entrada.
            unidade_y (str): A unidade dos valores de saída.
        Returns:
            np.ndarray: Um array de valores calculados com base na função exponencial.
        Raises:
            TypeError: Se o tipo de `x` não for np.ndarray.
        """

        self._verificar_tipo_de_x(x)
        y:np.ndarray=np.power(float(self.base),(self.expoente*x))*self.cte_multiplicativa
        return self._retornar(y,unidade_y)

    def __repr__(self)->str:
        return f'MExponencial(cte_multiplicativa={self.cte_multiplicativa},expoente={self.expoente},base={self.base})'

amostrar(x, unidade_y)

Gera uma amostra de valores exponenciais com base nos parâmetros fornecidos. Args: x (np.ndarray): Um array de valores de entrada. unidade_y (str): A unidade dos valores de saída. Returns: np.ndarray: Um array de valores calculados com base na função exponencial. Raises: TypeError: Se o tipo de x não for np.ndarray.

Source code in LabIFSC2/_regressoes.py

@obrigar_tipos
def amostrar(self:'MExponencial', x:np.ndarray,unidade_y:str)->np.ndarray:
    """
    Gera uma amostra de valores exponenciais com base nos parâmetros fornecidos.
    Args:
        x (np.ndarray): Um array de valores de entrada.
        unidade_y (str): A unidade dos valores de saída.
    Returns:
        np.ndarray: Um array de valores calculados com base na função exponencial.
    Raises:
        TypeError: Se o tipo de `x` não for np.ndarray.
    """

    self._verificar_tipo_de_x(x)
    y:np.ndarray=np.power(float(self.base),(self.expoente*x))*self.cte_multiplicativa
    return self._retornar(y,unidade_y)

MLeiDePotencia

Bases: Regressao

Source code in LabIFSC2/_regressoes.py

class MLeiDePotencia(Regressao):    
    @obrigar_tipos
    def __init__(self, a: Medida, n: Medida,y_unidade:pint.Quantity):
        super().__init__()
        self.cte_multiplicativa = a
        self.potencia = n
        self._valores=iter([a,n])
        self._y_unidade=y_unidade

    @obrigar_tipos
    def amostrar(self:'MLeiDePotencia', x:np.ndarray,unidade_y:str) -> np.ndarray:
        """
        Amostra valores baseados na lei de potência.
        Args:
            x (np.ndarray): Array de valores de entrada.
            unidade_y (str): Unidade da variável dependente y.
        Returns:
            np.ndarray: Array de valores amostrados com a unidade especificada.
        Raises:
            ValueError: Se a unidade de x não for compatível com a unidade esperada.
        """

        self._verificar_tipo_de_x(x)
        unidade_expoente=str((x[0]._nominal**self.potencia._nominal).units)
        x=_forcar_troca_de_unidade(x,'')    
        expoente=x**self.potencia
        expoente_medida=_forcar_troca_de_unidade(expoente,unidade_expoente)
        y=expoente_medida*self.cte_multiplicativa
        if not y[0]._nominal.is_compatible_with(self._y_unidade):
            raise ValueError(f'Unidade de x não está correta')
        return self._retornar(y,unidade_y)

    def __repr__(self)->str:
        return f'MLeiDePotencia(cte_multiplicativa={self.cte_multiplicativa}, potencia={self.potencia})'

amostrar(x, unidade_y)

Amostra valores baseados na lei de potência. Args: x (np.ndarray): Array de valores de entrada. unidade_y (str): Unidade da variável dependente y. Returns: np.ndarray: Array de valores amostrados com a unidade especificada. Raises: ValueError: Se a unidade de x não for compatível com a unidade esperada.

Source code in LabIFSC2/_regressoes.py

@obrigar_tipos
def amostrar(self:'MLeiDePotencia', x:np.ndarray,unidade_y:str) -> np.ndarray:
    """
    Amostra valores baseados na lei de potência.
    Args:
        x (np.ndarray): Array de valores de entrada.
        unidade_y (str): Unidade da variável dependente y.
    Returns:
        np.ndarray: Array de valores amostrados com a unidade especificada.
    Raises:
        ValueError: Se a unidade de x não for compatível com a unidade esperada.
    """

    self._verificar_tipo_de_x(x)
    unidade_expoente=str((x[0]._nominal**self.potencia._nominal).units)
    x=_forcar_troca_de_unidade(x,'')    
    expoente=x**self.potencia
    expoente_medida=_forcar_troca_de_unidade(expoente,unidade_expoente)
    y=expoente_medida*self.cte_multiplicativa
    if not y[0]._nominal.is_compatible_with(self._y_unidade):
        raise ValueError(f'Unidade de x não está correta')
    return self._retornar(y,unidade_y)

MPolinomio

Bases: Regressao

Source code in LabIFSC2/_regressoes.py

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')

        self._coeficientes:list[Medida]=[]
        for index,coef in enumerate(coeficientes):
            self._coeficientes.append(coef)
            setattr(self,string.ascii_lowercase[index],coef)
        self.grau=len(coeficientes)-1

    @obrigar_tipos
    def amostrar(self:'MPolinomio', x:np.ndarray,unidade_y:str) -> np.ndarray:
        """
        Calcula os valores de um polinômio para um conjunto de entradas x.
        Args:
            x (np.ndarray): Um array de valores nos quais o polinômio será avaliado.
            unidade_y (str): A unidade de medida para os valores calculados do polinômio.
        Returns:
            np.ndarray: Um array contendo os valores calculados do polinômio nas unidades especificadas.
        Raises:
            TypeError: Se o tipo de `x` não for np.ndarray.
        """


        self._verificar_tipo_de_x(x)
        y:Any=Medida(0,unidade_y,0)
        for index,coef in enumerate(self._coeficientes):y+=power(x,self.grau-index)*coef
        polinomio_calculado:np.ndarray=y
        return self._retornar(polinomio_calculado,unidade_y)

    def __iter__(self) -> Iterator[Medida]:
        return iter(self._coeficientes)

    def __repr__(self) -> str:
        return f"MPolinomio(coefs={self._coeficientes},grau={self.grau})"

amostrar(x, unidade_y)

Calcula os valores de um polinômio para um conjunto de entradas x. Args: x (np.ndarray): Um array de valores nos quais o polinômio será avaliado. unidade_y (str): A unidade de medida para os valores calculados do polinômio. Returns: np.ndarray: Um array contendo os valores calculados do polinômio nas unidades especificadas. Raises: TypeError: Se o tipo de x não for np.ndarray.

Source code in LabIFSC2/_regressoes.py

@obrigar_tipos
def amostrar(self:'MPolinomio', x:np.ndarray,unidade_y:str) -> np.ndarray:
    """
    Calcula os valores de um polinômio para um conjunto de entradas x.
    Args:
        x (np.ndarray): Um array de valores nos quais o polinômio será avaliado.
        unidade_y (str): A unidade de medida para os valores calculados do polinômio.
    Returns:
        np.ndarray: Um array contendo os valores calculados do polinômio nas unidades especificadas.
    Raises:
        TypeError: Se o tipo de `x` não for np.ndarray.
    """


    self._verificar_tipo_de_x(x)
    y:Any=Medida(0,unidade_y,0)
    for index,coef in enumerate(self._coeficientes):y+=power(x,self.grau-index)*coef
    polinomio_calculado:np.ndarray=y
    return self._retornar(polinomio_calculado,unidade_y)

regressao_exponencial(x_medidas, y_medidas, base=np.exp(1))

y=ae^{kx} Realiza uma regressão exponencial nos dados fornecidos.

Parameters:

Name	Type	Description	Default
x_medidas	ndarray	Array de medidas da variável independente.	required
y_medidas	ndarray	Array de medidas da variável dependente.	required
base	(Real, opcional)	Base da exponencial usada, o padrão é o número de Euler (e).	exp(1)

Raises:

Type	Description
ValueError	Se a base for menor que 1.
ValueError	Se y_medidas contiver valores negativos ou zero.
ValueError	Se x_medidas e y_medidas não tiverem o mesmo tamanho

Returns:

Name	Type	Description
MExponencial	MExponencial	Objeto contendo os parâmetros a e k da regressão exponencial e a base utilizada.

Source code in LabIFSC2/_regressoes.py

@obrigar_tipos
def regressao_exponencial(x_medidas:np.ndarray,y_medidas:np.ndarray,
                          base:Real=np.exp(1)) -> MExponencial:
    """
    y=ae^{kx}
    Realiza uma regressão exponencial nos dados fornecidos.

    Args:
        x_medidas (np.ndarray): Array de medidas da variável independente.
        y_medidas (np.ndarray): Array de medidas da variável dependente.
        base (Real, opcional): Base da exponencial usada, o padrão é o número de Euler (e).

    Raises:
        ValueError: Se a base for menor que 1.
        ValueError: Se y_medidas contiver valores negativos ou zero.
        ValueError: Se `x_medidas` e `y_medidas` não tiverem o mesmo tamanho 

    Returns:
        MExponencial: Objeto contendo os parâmetros `a` e `k` da regressão exponencial e a base utilizada.
    """
    if any(y._nominal.magnitude <= 0 for y in y_medidas):
        raise ValueError('Todos os valores de y_medidas devem ser positivos e não nulos para a regressão exponencial.')
    if base<1: raise ValueError('Base precisa ser maior que 1')
    pegar_log=lambda x: log(x)/log(float(base))
    log_y_medidas=_aplicar_funcao_sem_passar_pelo_sistema_de_unidades(y_medidas,pegar_log) 
    polinomio=regressao_linear(x_medidas,log_y_medidas)
    k=polinomio.a
    a=_aplicar_funcao_sem_passar_pelo_sistema_de_unidades(np.array([polinomio.b]),exp)[0]
    k=_forcar_troca_de_unidade(np.array([k]),str((1/x_medidas[0]._nominal).units))
    a=_forcar_troca_de_unidade(np.array([a]),str(y_medidas[0]._nominal.units))
    return MExponencial(a[0],k[0],base)

regressao_linear(x_medidas, y_medidas)

Calcula a regressão linear para um conjunto de medidas.

Parameters:

Name	Type	Description	Default
x_medidas	ndarray	Array contendo as medidas da variável independente.	required
y_medidas	ndarray	Array contendo as medidas da variável dependente.	required

Raises:

Type	Description
ValueError	Se x_medidas e y_medidas não tiverem o mesmo tamanho

Returns:

Name	Type	Description
MPolinomio	MPolinomio	Objeto representando a reta de regressão linear ajustada aos dados.

Source code in LabIFSC2/_regressoes.py

@obrigar_tipos
def regressao_linear(x_medidas:np.ndarray,
                     y_medidas:np.ndarray) -> MPolinomio:
    """
    Calcula a regressão linear para um conjunto de medidas.

    Args:
        x_medidas (np.ndarray): Array contendo as medidas da variável independente.
        y_medidas (np.ndarray): Array contendo as medidas da variável dependente.

    Raises:
        ValueError: Se `x_medidas` e `y_medidas` não tiverem o mesmo tamanho 

    Returns:
        MPolinomio: Objeto representando a reta de regressão linear ajustada aos dados.
    """    
    reta:MPolinomio=regressao_polinomial(x_medidas,y_medidas,1)
    return reta

regressao_polinomial(x_medidas, y_medidas, grau)

Realiza uma regressão polinomial nos dados fornecidos.

Parameters:

Name	Type	Description	Default
x_medidas	ndarray	Array de medidas para a variável independente.	required
y_medidas	ndarray	Array de medidas para a variável dependente.	required
grau	int	Grau do polinômio a ser ajustado.	required

Returns:

Name	Type	Description
MPolinomio	MPolinomio	Um objeto representando o polinômio ajustado com coeficientes como medidas.

Raises:

Type	Description
ValueError	Se x_medidas e y_medidas não tiverem o mesmo tamanho ou se não houver dados
TypeError	Se x_medidas e y_medidas não forem arrays de medidas.

Source code in LabIFSC2/_regressoes.py

@obrigar_tipos
def regressao_polinomial(x_medidas:np.ndarray,y_medidas:np.ndarray,grau:int) -> MPolinomio:
    """
    Realiza uma regressão polinomial nos dados fornecidos.

    Args:
        x_medidas (np.ndarray): Array de medidas para a variável independente.
        y_medidas (np.ndarray): Array de medidas para a variável dependente.
        grau (int): Grau do polinômio a ser ajustado.

    Returns:
        MPolinomio: Um objeto representando o polinômio ajustado com coeficientes como medidas.

    Raises:
        ValueError: Se `x_medidas` e `y_medidas` não tiverem o mesmo tamanho ou se não houver dados 
        suficientes para o grau do polinômio.
        TypeError: Se `x_medidas` e `y_medidas` não forem arrays de medidas.
    """

    if len(x_medidas)!=len(y_medidas):
        raise ValueError("x_dados e y_dados não tem o mesmo tamanho")
    if len(x_medidas)<=grau+1:
        raise ValueError("Não há dados suficientes para um polinômio de grau {grau} (overfitting)")
    if not (isinstance(x_medidas[0],Medida) and isinstance(y_medidas[0],Medida)):
        raise TypeError('x_medidas e y_medidas precisam ser np.ndarray de medidas')
    x_float=np.array([x._nominal.magnitude for x in x_medidas],dtype=float)
    y_float=np.array([y._nominal.magnitude for y in y_medidas],dtype=float)
    p, cov = np.polyfit(x_float, y_float, grau, cov=True)
    erros=np.sqrt(np.diag(cov))
    medidas_coeficientes=[]
    for index in range(len(p)):
        unidade= str((y_medidas[0]._nominal/x_medidas[0]._nominal**(grau-index)).units)
        medidas_coeficientes.append(Medida(p[index],unidade,erros[index]))
    return MPolinomio(np.array(medidas_coeficientes))

regressao_potencia(x_medidas, y_medidas)

y=a*x^n

Realiza uma regressão de potência nos dados fornecidos. Esta função aplica uma transformação logarítmica aos dados de entrada, realiza uma regressão linear nos dados transformados, e então converte os coeficientes da regressão linear de volta para a forma original, resultando em uma lei de potência.

Parameters:

Name	Type	Description	Default
x_medidas	ndarray	Array de medidas da variável independente.	required
y_medidas	ndarray	Array de medidas da variável dependente.	required

Raises:

Type	Description
ValueError	Se x_medidas contiver valores negativos ou zero.
ValueError	Se y_medidas contiver valores negativos ou zero.
ValueError	Se x_medidas e y_medidas não tiverem o mesmo tamanho

Returns:

Name	Type	Description
MLeiDePotencia	MLeiDePotencia	Objeto contendo os coeficientes da lei de potência ajustada.

Source code in LabIFSC2/_regressoes.py

@obrigar_tipos
def regressao_potencia(x_medidas:np.ndarray, y_medidas:np.ndarray) -> MLeiDePotencia:
    """
    y=a*x^n

    Realiza uma regressão de potência nos dados fornecidos.
    Esta função aplica uma transformação logarítmica aos dados de entrada, realiza uma regressão linear nos dados transformados,
    e então converte os coeficientes da regressão linear de volta para a forma original, resultando em uma lei de potência.

    Args:
        x_medidas (np.ndarray): Array de medidas da variável independente.
        y_medidas (np.ndarray): Array de medidas da variável dependente.

    Raises:
        ValueError: Se x_medidas contiver valores negativos ou zero.
        ValueError: Se y_medidas contiver valores negativos ou zero.
        ValueError: Se `x_medidas` e `y_medidas` não tiverem o mesmo tamanho 

    Returns:
        MLeiDePotencia: Objeto contendo os coeficientes da lei de potência ajustada.
    """

    log_y_medidas=_aplicar_funcao_sem_passar_pelo_sistema_de_unidades(y_medidas,log)
    log_x_medidas=_aplicar_funcao_sem_passar_pelo_sistema_de_unidades(x_medidas,log)
    polinomio=regressao_linear(log_x_medidas,log_y_medidas)
    a=_aplicar_funcao_sem_passar_pelo_sistema_de_unidades(np.array([polinomio.b]),exp)[0]
    n=polinomio.a
    a=_forcar_troca_de_unidade(np.array([a]),str((y_medidas[0]._nominal/x_medidas[0]._nominal**n._nominal.magnitude).units))
    n=_forcar_troca_de_unidade(np.array([n]),"dimensionless")
    return MLeiDePotencia(a[0],n[0],y_medidas[0]._nominal)