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:
    @overload
    def __init__(self, nominal: float, unidade: str, incerteza: float = 0): ...

    @overload
    def __init__(
        self, nominal: Iterable[float], unidade: str, incerteza: float = 0
    ): ...

    def __init__(
        self, nominal: float | Iterable[float], unidade: str, incerteza: float = 0
    ):
        """
        Inicializa uma instância da classe com valores nominais, unidade e incerteza.

        Args:
            nominal (float | Iterable[float]): Valor nominal ou uma coleção de
            valores nominais.
            unidade (str): Unidade de medida.
            incerteza (float): Incerteza associada ao valor nominal.

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

        if incerteza < 0:
            raise ValueError("Incerteza não pode ser negativa")
        if isinstance(nominal, Iterable):
            nominal = list(nominal)
            if len(nominal) < 2:
                raise ValueError("Lista de medidas deve ter pelo menos 2 elementos")
            mean = np.mean(nominal)

            std = np.std(nominal, ddof=1, mean=mean)
            self._nominal = ureg.Quantity(mean, unidade).to_reduced_units()
            self._incerteza = ureg.Quantity(
                std if std > incerteza else 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: HistogramaType | None = None

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

    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.
            '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) -> HistogramaType:
        if self._histograma is None:
            if self._incerteza.magnitude != 0:
                self._histograma = cast(
                    Quantity[NDArray[np.float64]],
                    (
                        _gerador_monte_carlo.normal(
                            self._nominal.magnitude,
                            self._incerteza.magnitude,
                            size=MCSamples,
                        )
                        * self._nominal.units
                    ),
                )
            else:
                self._histograma = cast(Quantity[float], self._nominal)
        return self._histograma

    def fmt(
        self,
        unidade: str | None = None,
        expoente: int | None = None,
        latex: bool = False,
        separador_decimal: Literal[".", ","] = ",",
    ) -> str:
        """Formata a medida para uma string.

        Args:
            unidade: Unidade usada no resultado. Por padrão, mantém a unidade da
                medida. O valor ``"si"`` converte a medida para unidades do SI.
            expoente: Expoente da potência usada para escalar o valor. Quando
                omitido, valores maiores ou iguais a 10 são normalizados.
            separador_decimal: Caractere usado como separador decimal.
            latex: Indica se o resultado deve usar sintaxe LaTeX.

        Returns:
            Medida formatada para exibição.

        Raises:
            ValueError: Se o separador decimal for inválido.
        """
        match unidade:
            case None:
                nominal, incerteza = self._nominal, self._incerteza
            case str(valor) if valor.lower() == "si":
                nominal = self._nominal.to_base_units()
                incerteza = self._incerteza.to_base_units()
            case str(valor):
                nominal = self._nominal.to(valor)
                incerteza = self._incerteza.to(valor)

        unidade_formatada = f"{nominal.units:~L}" if latex else f"{nominal.units:~P}"
        return _formatar_medida(
            nominal=float(nominal.magnitude),
            incerteza=float(incerteza.magnitude),
            unidade=unidade_formatada,
            expoente=expoente,
            separador_decimal=separador_decimal,
            latex=latex,
        )

    def __str__(self) -> str:
        return self.fmt()

    def __repr__(self) -> str:
        return self.fmt()

    def __array_ufunc__(
        self,
        ufunc: np.ufunc,
        method: Literal["__call__", "reduce", "reduceat", "accumulate", "outer", "at"],
        *inputs: object,
        **kwargs: object,
    ) -> object:
        if method != "__call__" or kwargs:
            return NotImplemented

        nome = ufunc.__name__
        funcao_matematica = nome in FUNCOES_NUMPY_SUPORTADAS
        op_unary = OPERACOES_UFUNC_UNARIAS.get(nome)
        op_binary = OPERACOES_UFUNC_BINARIAS.get(nome)
        has_array = any(isinstance(entrada, np.ndarray) for entrada in inputs)

        match inputs:
            case (Medida() as medida,) if funcao_matematica:
                return montecarlo(ufunc, medida)
            case (Medida() as medida,) if op_unary:
                return op_unary(medida)
            case (l, r) if op_binary and has_array:
                return np.vectorize(op_binary, otypes=[object])(l, r)
            case (l, r) if op_binary:
                return op_binary(l, r)
            case _:
                return NotImplemented

    def __getattr__(self, func_name: str) -> Callable[[], Medida]:
        if func_name not in FUNCOES_NUMPY_SUPORTADAS:
            raise AttributeError
        func = getattr(np, func_name)

        def funcao_recebe_medida() -> Medida:
            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, outro: object) -> 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, outro: object) -> 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, outro: object) -> bool:
        return (
            self._nominal <= outro._nominal
            if isinstance(outro, Medida)
            else NotImplemented
        )

    def __lt__(self, outro: object) -> bool:
        return (
            self._nominal < outro._nominal
            if isinstance(outro, Medida)
            else NotImplemented
        )

    def __ge__(self, outro: object) -> bool:
        return (
            self._nominal >= outro._nominal
            if isinstance(outro, Medida)
            else NotImplemented
        )

    def __gt__(self, outro: object) -> bool:
        return (
            self._nominal > outro._nominal
            if isinstance(outro, Medida)
            else NotImplemented
        )

    def __add__(self: Medida, outro: Medida | float) -> Medida:
        if isinstance(outro, Real):
            nova_medida = Medida(
                self._nominal.magnitude + outro,
                str(self._nominal.units),
                self._incerteza.magnitude,
            )
            if self._histograma is not None:
                nova_medida._histograma = self._histograma + (
                    outro * self._nominal.units
                )
            return nova_medida
        elif isinstance(outro, Medida):
            if self._nominal.is_compatible_with(outro._nominal):
                if self is outro:
                    return 2 * self
                elif self._histograma is None and outro._histograma is None:
                    # Como existe solução analítica da soma entre duas gaussianas
                    # iremos usar esse resultado para otimizar o código
                    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:
                    return montecarlo(lambda x, y: x + y, self, outro)
            else:
                raise ValueError(
                    f"A soma entre {self._nominal.dimensionality} e"
                    f" {outro._nominal.dimensionality} não é possível"
                )
        else:
            return NotImplemented

    def __sub__(self: Medida, outro: Medida | float) -> Medida:
        if self is outro:
            return Medida(0, str(self._nominal.units), 0)
        return self + (-outro)

    def __mul__(self: Medida, outro: Medida | float) -> Medida:
        if self is outro:
            return montecarlo(lambda x: x**2, self)
        if 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: Medida | float) -> Medida:
        if self is outro:
            return Medida(1, "", 0)
        if 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),
                self._incerteza.magnitude / abs(outro),
            )
            if self._histograma is not None:
                resultado._histograma = cast(HistogramaType, self._histograma / outro)
            return resultado
        else:
            return NotImplemented

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

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

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

    def __radd__(self: Medida, outro: Medida | float) -> Medida:
        return self.__add__(outro)

    def __rsub__(self: Medida, outro: Medida | float) -> Medida:
        return (-self) + outro

    def __rmul__(self: Medida, outro: Medida | float) -> Medida:
        return self.__mul__(outro)

    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 = cast(HistogramaType, 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 = cast(HistogramaType, -self._histograma)
        return resultado

    def __pos__(self) -> 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 probabilidade_de_estar_entre(self, a: float, b: float, unidade: str) -> float:
        """
        Calcula a probabilidade de uma medida estar entre dois valores especificados.

        Args:
            a (float): O valor inferior do intervalo.
            b (float): 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)

    def intervalo_de_confiança(
        self: Medida, p: float, unidade: str
    ) -> tuple[float, float]:
        """
        Calcula o intervalo de confiança para a medida.

        Args:
            p (float): Probabilidade associada ao intervalo de confiança (0,1)
            unidade (str): Unidade de medida para o intervalo de confiança.

        Returns:
                tuple: Tupla [limite-inferior, limite-superior].

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

        if not 0 < float(p) < 1:
            raise ValueError("p deve estar entre 0 e 1 (exclusivo)")
        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 analítica
            mu = self._nominal.to(unidade).magnitude
            sigma = self._incerteza.to(unidade).magnitude
            if sigma == 0:
                return (float(mu), float(mu))
            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:
            h_q = cast(Quantity[NDArray[np.float64]], self.histograma)
            magnitudes = np.sort(np.asarray(h_q.to(unidade).magnitude))
            num_elements = len(magnitudes)
            selected_elements = max(1, int(np.ceil(float(p) * num_elements)))
            intervals = (
                magnitudes[selected_elements - 1 :]
                - magnitudes[: num_elements - selected_elements + 1]
            )

            shortest_interval_index = np.argmin(intervals)
            shortest_interval = (
                float(magnitudes[shortest_interval_index]),
                float(magnitudes[shortest_interval_index + selected_elements - 1]),
            )
            return shortest_interval

`init(nominal, unidade, incerteza=0)`

__init__(nominal: float, unidade: str, incerteza: float = 0)

__init__(nominal: Iterable[float], unidade: str, incerteza: float = 0)

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

Parameters:

Name	Type	Description	Default
`nominal`	`float \| Iterable[float]`	Valor nominal ou uma coleção de	required
`unidade`	`str`	Unidade de medida.	required
`incerteza`	`float`	Incerteza associada ao valor nominal.	`0`

Raises:

Type	Description
`ValueError`	Se a incerteza for negativa.
`ValueError`	Se a sequência de medidas tiver menos de 2 elementos.

Source code in LabIFSC2/_medida.py

def __init__(
    self, nominal: float | Iterable[float], unidade: str, incerteza: float = 0
):
    """
    Inicializa uma instância da classe com valores nominais, unidade e incerteza.

    Args:
        nominal (float | Iterable[float]): Valor nominal ou uma coleção de
        valores nominais.
        unidade (str): Unidade de medida.
        incerteza (float): Incerteza associada ao valor nominal.

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

    if incerteza < 0:
        raise ValueError("Incerteza não pode ser negativa")
    if isinstance(nominal, Iterable):
        nominal = list(nominal)
        if len(nominal) < 2:
            raise ValueError("Lista de medidas deve ter pelo menos 2 elementos")
        mean = np.mean(nominal)

        std = np.std(nominal, ddof=1, mean=mean)
        self._nominal = ureg.Quantity(mean, unidade).to_reduced_units()
        self._incerteza = ureg.Quantity(
            std if std > incerteza else 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: HistogramaType | None = None

`fmt(unidade=None, expoente=None, latex=False, separador_decimal=',')`

Formata a medida para uma string.

Parameters:

Name	Type	Description	Default
`unidade`	`str \| None`	Unidade usada no resultado. Por padrão, mantém a unidade da medida. O valor `"si"` converte a medida para unidades do SI.	`None`
`expoente`	`int \| None`	Expoente da potência usada para escalar o valor. Quando omitido, valores maiores ou iguais a 10 são normalizados.	`None`
`separador_decimal`	`Literal['.', ',']`	Caractere usado como separador decimal.	`','`
`latex`	`bool`	Indica se o resultado deve usar sintaxe LaTeX.	`False`

Returns:

Type	Description
`str`	Medida formatada para exibição.

Raises:

Type	Description
`ValueError`	Se o separador decimal for inválido.

Source code in LabIFSC2/_medida.py

def fmt(
    self,
    unidade: str | None = None,
    expoente: int | None = None,
    latex: bool = False,
    separador_decimal: Literal[".", ","] = ",",
) -> str:
    """Formata a medida para uma string.

    Args:
        unidade: Unidade usada no resultado. Por padrão, mantém a unidade da
            medida. O valor ``"si"`` converte a medida para unidades do SI.
        expoente: Expoente da potência usada para escalar o valor. Quando
            omitido, valores maiores ou iguais a 10 são normalizados.
        separador_decimal: Caractere usado como separador decimal.
        latex: Indica se o resultado deve usar sintaxe LaTeX.

    Returns:
        Medida formatada para exibição.

    Raises:
        ValueError: Se o separador decimal for inválido.
    """
    match unidade:
        case None:
            nominal, incerteza = self._nominal, self._incerteza
        case str(valor) if valor.lower() == "si":
            nominal = self._nominal.to_base_units()
            incerteza = self._incerteza.to_base_units()
        case str(valor):
            nominal = self._nominal.to(valor)
            incerteza = self._incerteza.to(valor)

    unidade_formatada = f"{nominal.units:~L}" if latex else f"{nominal.units:~P}"
    return _formatar_medida(
        nominal=float(nominal.magnitude),
        incerteza=float(incerteza.magnitude),
        unidade=unidade_formatada,
        expoente=expoente,
        separador_decimal=separador_decimal,
        latex=latex,
    )

`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.	required

Returns:

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

Source code in LabIFSC2/_medida.py

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.
        '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`	`float`	Probabilidade associada ao intervalo de confiança (0,1)	required
`unidade`	`str`	Unidade de medida para o intervalo de confiança.	required

Returns:

Name	Type	Description
`tuple`	`tuple[float, float]`	Tupla [limite-inferior, limite-superior].

Raises:

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

Source code in LabIFSC2/_medida.py

def intervalo_de_confiança(
    self: Medida, p: float, unidade: str
) -> tuple[float, float]:
    """
    Calcula o intervalo de confiança para a medida.

    Args:
        p (float): Probabilidade associada ao intervalo de confiança (0,1)
        unidade (str): Unidade de medida para o intervalo de confiança.

    Returns:
            tuple: Tupla [limite-inferior, limite-superior].

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

    if not 0 < float(p) < 1:
        raise ValueError("p deve estar entre 0 e 1 (exclusivo)")
    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 analítica
        mu = self._nominal.to(unidade).magnitude
        sigma = self._incerteza.to(unidade).magnitude
        if sigma == 0:
            return (float(mu), float(mu))
        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:
        h_q = cast(Quantity[NDArray[np.float64]], self.histograma)
        magnitudes = np.sort(np.asarray(h_q.to(unidade).magnitude))
        num_elements = len(magnitudes)
        selected_elements = max(1, int(np.ceil(float(p) * num_elements)))
        intervals = (
            magnitudes[selected_elements - 1 :]
            - magnitudes[: num_elements - selected_elements + 1]
        )

        shortest_interval_index = np.argmin(intervals)
        shortest_interval = (
            float(magnitudes[shortest_interval_index]),
            float(magnitudes[shortest_interval_index + selected_elements - 1]),
        )
        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.	required

Returns:

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

Source code in LabIFSC2/_medida.py

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.
        '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`	`float`	O valor inferior do intervalo.	required
`b`	`float`	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

Source code in LabIFSC2/_medida.py

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

    Args:
        a (float): O valor inferior do intervalo.
        b (float): 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)

`alterar_monte_carlo_rng(novo_gerador)`

Altera o gerador aleatório usado nas simulações de Monte Carlo.

Parameters:

Name	Type	Description	Default
`novo_gerador`	`Generator`	Gerador aleatório usado nas próximas simulações.	required

Raises:

Type	Description
`TypeError`	Se o valor não for um `numpy.random.Generator`.

Source code in LabIFSC2/_medida.py

def alterar_monte_carlo_rng(novo_gerador: np.random.Generator) -> None:
    """Altera o gerador aleatório usado nas simulações de Monte Carlo.

    Args:
        novo_gerador: Gerador aleatório usado nas próximas simulações.

    Raises:
        TypeError: Se o valor não for um ``numpy.random.Generator``.
    """
    global _gerador_monte_carlo
    if not isinstance(novo_gerador, np.random.Generator):
        raise TypeError("O gerador deve ser uma instância de numpy.random.Generator")
    _gerador_monte_carlo = novo_gerador

`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	`2`
`sigma_superior`	`(float, opcional)`	O fator sigma superior para	`3`

Returns:

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

Raises:

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

Source code in LabIFSC2/_medida.py

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 - medida2).nominal("si")
    soma_incertezas = medida1.incerteza("si") + medida2.incerteza("si")
    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(valores, unidade, incerteza)`

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

Parameters:

Name	Type	Description	Default
`valores`	`Iterable[float]`	Um iterável de valores nominais.	required
`unidade`	`str`	A unidade de medida.	required
`incerteza`	`float`	A incerteza associada aos valores nominais.	required

Returns:

Type	Description
`NDArray[object_]`	NDArray[np.object_]: Um array de objetos Medida.

Source code in LabIFSC2/_arrays.py

def arrayM(
    valores: Iterable[float], unidade: str, incerteza: float
) -> NDArray[np.object_]:
    """
    Cria um array de objetos Medida a partir de valores nominais, unidade e incerteza.

    Args:
        valores (Iterable[float]): Um iterável de valores nominais.
        unidade (str): A unidade de medida.
        incerteza (float): A incerteza associada aos valores nominais.

    Returns:
        NDArray[np.object_]: Um array de objetos Medida.
    """
    resultados: list[Medida] = []
    for nominal in valores:
        if not isinstance(nominal, Real):
            raise TypeError("Os valores do array não são números reais")
        resultados.append(Medida(nominal, unidade, incerteza))
    return np.array(resultados, dtype=Medida)

`curva_max(medidas, unidade_y, sigmas=2)`

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

Para usar com um ajuste, passe o resultado de ajuste(x_array) como argumento.

Parameters:

Name	Type	Description	Default
`medidas`	`Iterable[Medida]`	Iterável de objetos Medida.	required
`unidade_y`	`str`	Unidade da variável dependente.	required
`sigmas`	`float`	Número de sigmas para a curva máxima.	`2`

Returns:

Type	Description
`NDArray[float64]`	NDArray[np.float64]: Array de valores da curva máxima.

Source code in LabIFSC2/_arrays.py

def curva_max(
    medidas: Iterable[Medida], unidade_y: str, sigmas: float = 2
) -> NDArray[np.float64]:
    """
    Calcula a curva máxima de uma série de medidas.

    Para usar com um ajuste, passe o resultado de ``ajuste(x_array)`` como argumento.

    Args:
        medidas (Iterable[Medida]): Iterável de objetos Medida.
        unidade_y (str): Unidade da variável dependente.
        sigmas (float): Número de sigmas para a curva máxima.

    Returns:
        NDArray[np.float64]: Array de valores da curva máxima.
    """
    if sigmas <= 0:
        raise ValueError("O número de sigmas deve ser positivo")
    return nominais(medidas, unidade_y) + sigmas * incertezas(medidas, unidade_y)

`curva_min(medidas, unidade_y, sigmas=2)`

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

Para usar com um ajuste, passe o resultado de ajuste(x_array) como argumento.

Parameters:

Name	Type	Description	Default
`medidas`	`Iterable[Medida]`	Iterável de objetos Medida.	required
`unidade_y`	`str`	Unidade da variável dependente.	required
`sigmas`	`float`	Número de sigmas para a curva mínima.	`2`

Returns:

Type	Description
`NDArray[float64]`	NDArray[np.float64]: Array de valores da curva mínima.

Source code in LabIFSC2/_arrays.py

def curva_min(
    medidas: Iterable[Medida], unidade_y: str, sigmas: float = 2
) -> NDArray[np.float64]:
    """
    Calcula a curva mínima de uma série de medidas.

    Para usar com um ajuste, passe o resultado de ``ajuste(x_array)`` como argumento.

    Args:
        medidas (Iterable[Medida]): Iterável de objetos Medida.
        unidade_y (str): Unidade da variável dependente.
        sigmas (float): Número de sigmas para a curva mínima.

    Returns:
        NDArray[np.float64]: Array de valores da curva mínima.
    """
    if sigmas <= 0:
        raise ValueError("O número de sigmas deve ser positivo")
    return nominais(medidas, unidade_y) - sigmas * incertezas(medidas, unidade_y)

`incertezas(medidas, unidade)`

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

Parameters:

Name	Type	Description	Default
`medidas`	`Iterable[Medida]`	Iterável de objetos Medida.	required
`unidade`	`str`	Unidade para a conversão das incertezas. Use 'si'	required

Returns:

Type	Description
`NDArray[float64]`	NDArray[np.float64]: Array de incertezas convertidas para a unidade escolhida.

Raises:

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

Source code in LabIFSC2/_arrays.py

def incertezas(medidas: Iterable[Medida], unidade: str) -> NDArray[np.float64]:
    """
    Converte um iterável de objetos Medida para um array de
    incertezas em uma unidade especificada.

    Args:
        medidas (Iterable[Medida]): Iterável de objetos Medida.
        unidade (str): Unidade para a conversão das incertezas. Use 'si'
        para unidades do Sistema Internacional.

    Returns:
        NDArray[np.float64]: Array de incertezas convertidas para a unidade escolhida.

    Raises:
        TypeError: Se algum dos valores não for um objeto Medida.
    """
    try:
        return np.array(
            [medida.incerteza(unidade) for medida in medidas],
            dtype=float,
        )
    except AttributeError as e:
        raise TypeError("Os valores do array não são Medidas") from e

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

Gera um array de Medidas com valores igualmente espaçados, seguindo as convenções da função np.linpsace do NumPy.

Parameters:

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

Returns:

Type	Description
`NDArray[object_]`	NDArray[np.object_]: Um array de objetos Medida com valores igualmente espaçados

Source code in LabIFSC2/_arrays.py

def linspaceM(
    a: float, b: float, n: int, unidade: str, incertezas: float
) -> NDArray[np.object_]:
    """Gera um array de Medidas com valores igualmente espaçados, seguindo as convenções
    da função np.linpsace do NumPy.

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

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

`nominais(medidas, unidade)`

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

Parameters:

Name	Type	Description	Default
`medidas`	`Iterable[Medida]`	Iterável de objetos Medida.	required
`unidade`	`str`	Unidade para a conversão dos valores nominais. Use 'si'	required

Returns:

Type	Description
`NDArray[float64]`	NDArray[np.float64]: Array de valores nominais convertidos
`NDArray[float64]`	para a unidade especificada.

Raises:

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

Source code in LabIFSC2/_arrays.py

def nominais(medidas: Iterable[Medida], unidade: str) -> NDArray[np.float64]:
    """
    Converte um iterável de objetos Medida para um array de valores
    nominais em uma unidade especificada.

    Args:
        medidas (Iterable[Medida]): Iterável de objetos Medida.
        unidade (str): Unidade para a conversão dos valores nominais. Use 'si'
        para unidades do Sistema Internacional.

    Returns:
        NDArray[np.float64]: Array de valores nominais convertidos
        para a unidade especificada.

    Raises:
        TypeError: Se algum dos valores não for um objeto Medida.
    """
    try:
        return np.array(
            [medida.nominal(unidade) for medida in medidas],
            dtype=float,
        )
    except AttributeError as e:
        raise TypeError("Os valores do array não são Medidas") from e

`AjustePolinomial`

Resultado de um ajuste polinomial genérico da forma: y = coef[0] + coef[1]x + coef[2]x^2 + ... + coef[n]*x^n

Source code in LabIFSC2/_regressoes.py

class AjustePolinomial:
    """
    Resultado de um ajuste polinomial genérico da forma:
    y = coef[0] + coef[1]*x + coef[2]*x^2 + ... + coef[n]*x^n
    """

    def __init__(self, coeficientes: Iterable[Medida]) -> None:
        self.coef = list(coeficientes)
        self.grau = len(self.coef) - 1

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

    def __repr__(self) -> str:
        return f"AjustePolinomial(grau={self.grau}, coeficientes={self.coef})"

    @overload
    def __call__(  # type: ignore[overload-overlap]
        self, medidas: Medida
    ) -> Medida: ...

    @overload
    def __call__(self, medidas: Iterable[Medida]) -> NDArray[np.object_]: ...

    def __call__(
        self, medidas: Medida | Iterable[Medida]
    ) -> Medida | NDArray[np.object_]:
        zero = self.coef[0] - self.coef[0]
        if isinstance(medidas, Medida):
            return sum(
                [coef * (medidas**i) for i, coef in enumerate(self.coef)], start=zero
            )
        else:
            return np.array(
                [
                    sum(
                        [coef * (medida**i) for i, coef in enumerate(self.coef)],
                        start=zero,
                    )
                    for medida in medidas
                ],
                dtype=object,
            )

`regressao_exponencial(x_medidas, y_medidas, base=np.e)`

Realiza uma regressão exponencial nos dados fornecidos.

Ajusta uma curva da forma y = amplitude * base^(expoente * x). A linearização é feita via log_base(y) = log_base(amplitude) + expoente * x.

Parameters:

Name	Type	Description	Default
`x_medidas`	`Iterable[Medida]`	Coleção de medidas da variável independente.	required
`y_medidas`	`Iterable[Medida]`	Coleção de medidas da variável	required
`base`	`(float, opcional)`	Base da exponencial usada, o padrão é	`e`

Returns:

Name	Type	Description
`AjusteExponencial`	`AjusteExponencial`	Objeto contendo amplitude e
	`AjusteExponencial`	expoente da regressão exponencial.

Raises:

Type	Description
`TypeError`	Se x_medidas ou y_medidas não forem coleções de Medida.
`ValueError`	Se base < 1.
`ValueError`	Se y_medidas contiver valores não-positivos.
`ValueError`	Se x_medidas e y_medidas não tiverem o mesmo tamanho.

Source code in LabIFSC2/_regressoes.py

def regressao_exponencial(
    x_medidas: Iterable[Medida], y_medidas: Iterable[Medida], base: float = np.e
) -> AjusteExponencial:
    """
    Realiza uma regressão exponencial nos dados fornecidos.

    Ajusta uma curva da forma y = amplitude * base^(expoente * x).
    A linearização é feita via log_base(y) = log_base(amplitude) + expoente * x.

    Args:
        x_medidas (Iterable[Medida]): Coleção de medidas da variável independente.
        y_medidas (Iterable[Medida]): Coleção de medidas da variável
        dependente (todos positivos).
        base (float, opcional): Base da exponencial usada, o padrão é
        o número de Euler (e).

    Returns:
        AjusteExponencial: Objeto contendo amplitude e
        expoente da regressão exponencial.

    Raises:
        TypeError: Se x_medidas ou y_medidas não forem coleções de Medida.
        ValueError: Se base < 1.
        ValueError: Se y_medidas contiver valores não-positivos.
        ValueError: Se x_medidas e y_medidas não tiverem o mesmo tamanho.
    """
    x_medidas, y_medidas = _validate_medidas_and_convert_to_list(
        x_medidas, y_medidas, positivos_y=True
    )
    if base < 1:
        raise ValueError("Base precisa ser maior que 1")
    unidade_x_si = _obter_unidade_si(x_medidas[0])
    unidade_y_si = _obter_unidade_si(y_medidas[0])
    p, erros = _polyfit_com_medidas_e_lineralização(
        x_medidas, y_medidas, 1, "si", "si", log_y=True, base=base
    )
    unidade_expoente = _obter_unidade_si(1 / Medida(1.0, unidade_x_si))
    k = Medida(float(p[1]), unidade_expoente, float(erros[1]))

    intercept_medida = Medida(float(p[0]), "", float(erros[0]))
    a_medida = base**intercept_medida
    scale_y = Medida(1.0, unidade_y_si)
    a = a_medida * scale_y
    return AjusteExponencial(a, k)

`regressao_linear(x_medidas, y_medidas)`

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

Ajusta uma reta da forma y = a*x + b.

Parameters:

Name	Type	Description	Default
`x_medidas`	`Iterable[Medida]`	Coleção contendo as medidas da	required
`y_medidas`	`Iterable[Medida]`	Coleção contendo as medidas da	required

Returns:

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

Raises:

Type	Description
`TypeError`	Se x_medidas ou y_medidas não forem coleções de Medida.
`ValueError`	Se x_medidas e y_medidas não tiverem o mesmo tamanho.

Source code in LabIFSC2/_regressoes.py

def regressao_linear(
    x_medidas: Iterable[Medida], y_medidas: Iterable[Medida]
) -> AjustePolinomial:
    """
    Calcula a regressão linear para um conjunto de medidas.

    Ajusta uma reta da forma y = a*x + b.

    Args:
        x_medidas (Iterable[Medida]): Coleção contendo as medidas da
        variável independente.
        y_medidas (Iterable[Medida]): Coleção contendo as medidas da
        variável dependente.

    Returns:
        AjustePolinomial: Objeto representando a reta de regressão linear
        ajustada aos dados.

    Raises:
        TypeError: Se x_medidas ou y_medidas não forem coleções de Medida.
        ValueError: Se x_medidas e y_medidas não tiverem o mesmo tamanho.
    """
    return regressao_polinomial(x_medidas, y_medidas, 1)

`regressao_polinomial(x_medidas, y_medidas, grau)`

Realiza uma regressão polinomial nos dados fornecidos.

A regressão ajusta um polinômio de grau grau da forma: y = coef[0] + coef[1]x + ... + coef[grau]x^grau

Parameters:

Name	Type	Description	Default
`x_medidas`	`Iterable[Medida]`	Coleção de medidas para a variável independente.	required
`y_medidas`	`Iterable[Medida]`	Coleção de medidas para a variável dependente.	required
`grau`	`int`	Grau do polinômio a ser ajustado.	required

Returns:

Name	Type	Description
`AjustePolinomial`	`AjustePolinomial`	Objeto representando o polinômio
	`AjustePolinomial`	ajustado com coeficientes como Medidas.

Raises:

Type	Description
`TypeError`	Se x_medidas ou y_medidas não forem coleções de Medida.
`ValueError`	Se x_medidas e y_medidas não tiverem o mesmo tamanho.
`ValueError`	Se não houver dados suficientes (overfitting).

Source code in LabIFSC2/_regressoes.py

def regressao_polinomial(
    x_medidas: Iterable[Medida], y_medidas: Iterable[Medida], grau: int
) -> AjustePolinomial:
    """
    Realiza uma regressão polinomial nos dados fornecidos.

    A regressão ajusta um polinômio de grau ``grau`` da forma:
    y = coef[0] + coef[1]*x + ... + coef[grau]*x^grau

    Args:
        x_medidas (Iterable[Medida]): Coleção de medidas para a variável independente.
        y_medidas (Iterable[Medida]): Coleção de medidas para a variável dependente.
        grau (int): Grau do polinômio a ser ajustado.

    Returns:
        AjustePolinomial: Objeto representando o polinômio
        ajustado com coeficientes como Medidas.

    Raises:
        TypeError: Se x_medidas ou y_medidas não forem coleções de Medida.
        ValueError: Se x_medidas e y_medidas não tiverem o mesmo tamanho.
        ValueError: Se não houver dados suficientes (overfitting).
    """
    x_medidas, y_medidas = _validate_medidas_and_convert_to_list(x_medidas, y_medidas)
    if len(x_medidas) <= grau + 1:
        raise ValueError(
            f"Não há dados suficientes para um polinômio de grau {grau} (overfitting)"
        )
    p, erros = _polyfit_com_medidas_e_lineralização(
        x_medidas, y_medidas, grau, "si", "si"
    )
    unidade_x_si = _obter_unidade_si(x_medidas[0])
    unidade_y_si = _obter_unidade_si(y_medidas[0])
    coefs: list[Medida] = []
    for i in range(grau + 1):
        unidade_coef = _obter_unidade_si(
            Medida(1.0, unidade_y_si) / Medida(1.0, unidade_x_si) ** i
        )
        coefs.append(Medida(float(p[i]), unidade_coef, float(erros[i])))

    return AjustePolinomial(coefs)

`regressao_potencia(x_medidas, y_medidas, x0=None)`

Realiza uma regressão de lei de potência nos dados fornecidos.

Ajusta uma curva da forma y = amplitude * (x / x0)^potencia. A linearização é feita via log(y) = log(amplitude) + potencia * log(x/x0).

Parameters:

Name	Type	Description	Default
`x_medidas`	`Iterable[Medida]`	Coleção de medidas da variável	required
`y_medidas`	`Iterable[Medida]`	Coleção de medidas da variável	required
`x0`	`(Medida, opcional)`	Escala de referência para x. Se None,	`None`

Returns:

Name	Type	Description
`AjusteLeiDePotencia`	`AjusteLeiDePotencia`	Objeto contendo amplitude, potência
	`AjusteLeiDePotencia`	e a escala x0 da regressão.

Raises:

Type	Description
`TypeError`	Se x_medidas ou y_medidas não forem coleções de Medida.
`ValueError`	Se x_medidas ou y_medidas contiverem valores não-positivos.
`ValueError`	Se x_medidas e y_medidas não tiverem o mesmo tamanho.

Source code in LabIFSC2/_regressoes.py

def regressao_potencia(
    x_medidas: Iterable[Medida], y_medidas: Iterable[Medida], x0: Medida | None = None
) -> AjusteLeiDePotencia:
    """
    Realiza uma regressão de lei de potência nos dados fornecidos.

    Ajusta uma curva da forma y = amplitude * (x / x0)^potencia.
    A linearização é feita via log(y) = log(amplitude) + potencia * log(x/x0).

    Args:
        x_medidas (Iterable[Medida]): Coleção de medidas da variável
        independente (todos positivos).
        y_medidas (Iterable[Medida]): Coleção de medidas da variável
        dependente (todos positivos).
        x0 (Medida, opcional): Escala de referência para x. Se None,
        é adotado 1.0 na unidade SI de x.

    Returns:
        AjusteLeiDePotencia: Objeto contendo amplitude, potência
        e a escala x0 da regressão.

    Raises:
        TypeError: Se x_medidas ou y_medidas não forem coleções de Medida.
        ValueError: Se x_medidas ou y_medidas contiverem valores não-positivos.
        ValueError: Se x_medidas e y_medidas não tiverem o mesmo tamanho.
    """
    x_medidas, y_medidas = _validate_medidas_and_convert_to_list(
        x_medidas, y_medidas, positivos_x=True, positivos_y=True
    )
    unidade_x_si = _obter_unidade_si(x_medidas[0])
    unidade_y_si = _obter_unidade_si(y_medidas[0])
    if x0 is None:
        x0 = Medida(1.0, unidade_x_si)
    x_scaled_medidas = [x / x0 for x in x_medidas]
    p, erros = _polyfit_com_medidas_e_lineralização(
        x_scaled_medidas, y_medidas, 1, "", "si", log_x=True, log_y=True, base=np.e
    )
    n = Medida(float(p[1]), "", float(erros[1]))
    intercept_medida = Medida(float(p[0]), "", float(erros[0]))
    a_medida = intercept_medida.exp()
    scale_y = Medida(1.0, unidade_y_si)
    a = a_medida * scale_y

    return AjusteLeiDePotencia(a, n, x0)

API Completa

Medida

__init__(nominal, unidade, incerteza=0)

fmt(unidade=None, expoente=None, latex=False, separador_decimal=',')

incerteza(unidade)

intervalo_de_confiança(p, unidade)

nominal(unidade)

probabilidade_de_estar_entre(a, b, unidade)

alterar_monte_carlo_rng(novo_gerador)

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

arrayM(valores, unidade, incerteza)

curva_max(medidas, unidade_y, sigmas=2)

curva_min(medidas, unidade_y, sigmas=2)

incertezas(medidas, unidade)

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

nominais(medidas, unidade)

AjustePolinomial

regressao_exponencial(x_medidas, y_medidas, base=np.e)

regressao_linear(x_medidas, y_medidas)

regressao_polinomial(x_medidas, y_medidas, grau)

regressao_potencia(x_medidas, y_medidas, x0=None)

`Medida`

`init(nominal, unidade, incerteza=0)`

`fmt(unidade=None, expoente=None, latex=False, separador_decimal=',')`

`incerteza(unidade)`

`intervalo_de_confiança(p, unidade)`

`nominal(unidade)`

`probabilidade_de_estar_entre(a, b, unidade)`

`alterar_monte_carlo_rng(novo_gerador)`

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

`arrayM(valores, unidade, incerteza)`

`curva_max(medidas, unidade_y, sigmas=2)`

`curva_min(medidas, unidade_y, sigmas=2)`

`incertezas(medidas, unidade)`

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

`nominais(medidas, unidade)`

`AjustePolinomial`

`regressao_exponencial(x_medidas, y_medidas, base=np.e)`

`regressao_linear(x_medidas, y_medidas)`

`regressao_polinomial(x_medidas, y_medidas, grau)`

`regressao_potencia(x_medidas, y_medidas, x0=None)`