power

class Power(OneToOneInversableDerivableTransformer):
    """Transform series by applying power function (meant to be mainly used as sqrt function).

    ```math
        serie^{power}
    ```

    Args:
        power (float): power of the function applied.
    """

    def __init__(self, power: float) -> None:
        self.power = power

    @property
    def parameters(self) -> Dict[str, float]:
        return self.__dict__

    # ------- METHODS -------

    def transform(self, serie: np.ndarray, copy=False) -> np.ndarray:
        serie = super().transform(serie, copy)

        return self._transformer(serie, self.power)

    def inverse_transform(self, serie: np.ndarray, copy=False) -> np.ndarray:
        serie = super().inverse_transform(serie, copy)

        return self._inverse_transformer(serie, self.power)

    def derivative_transform(self, serie: np.ndarray, copy=False) -> np.ndarray:
        serie = super().derivative_transform(serie, copy)

        return self._derivative_transformer(serie, self.power)

    # ------- TRANSFORMERS -------

    @staticmethod
    def _transformer(serie: np.ndarray, power: float) -> np.ndarray:
        if abs(power - 1) < FLOAT_TOLERANCE_THRESHOLD:
            return serie
        with np.errstate(over="raise", divide="raise"):
            return np.power(serie, power)

    @staticmethod
    def _inverse_transformer(serie: np.ndarray, power) -> np.ndarray:
        with np.errstate(over="raise", divide="raise"):
            return np.power(serie, 1 / power)

    @staticmethod
    def _derivative_transformer(serie: np.ndarray, power) -> np.ndarray:
        with np.errstate(over="raise", divide="raise"):
            return power * np.power(serie, power - 1)

    # ------- CHECKERS -------

    def check_params(self, serie: np.ndarray):
        """Check if parameters respect their application scope."""
        if not self.power != 0:
            raise ParameterScopeException(f"power should be different from 0. power: {self.power}.")