scale

class Scale(OneToOneInversableDerivableTransformer):
    """Transform series by a scaling by a value.

    ```math
        \\frac{serie}{value}
    ```

    Args:
        value (float): Scaling value.
    """

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

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

    @property
    def is_linear(self) -> bool:
        return True

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

    def fit(self, serie: np.ndarray, y=None):
        if self.value == 0:
            self.value = 1

        return super().fit(serie, y)

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

        return self._transformer(serie, self.value)

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

        return self._inverse_transformer(serie, self.value)

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

        return self._derivative_transformer(serie, self.value)

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

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

    @staticmethod
    def _inverse_transformer(serie: np.ndarray, value) -> np.ndarray:
        return serie * value

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

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

    def check_params(self, serie: np.ndarray):
        """Check if parameters respect their application scope."""
        if not self.value != 0:
            raise ParameterScopeException("The parameter 'value' should be different than 0")
        if not self.value != np.inf and self.value != -np.inf:
            raise ParameterScopeException(
                f"The parameter 'value' should be different than infinite. value: {self.value}"
            )