class SteveObjective(object):
    def calc_ders_range(self, approxes, targets, weights):
        # approxes, targets, weights are indexed containers of floats
        # (containers with only __len__ and __getitem__ defined).
        # weights parameter can be None.
        # Returns list of pairs (der1, der2)
        assert len(approxes) == len(targets)
        if weights is not None:
            assert len(weights) == len(approxes)

        result = []
        for index in range(len(targets)):
            coef = 2 if targets[index] < 4 <= approxes[index] else 1
            der1 = 2 * coef * (targets[index] - approxes[index])
            der2 = - 2 * coef
            result.append((der1, der2))

        return result

class SteveMetric(object):
    def get_final_error(self, error, weight):
        return error / (weight + 1e-38)

    def is_max_optimal(self):
        return True

    def _rmse_asymmetric(self, rating, prediction):
        bad_border = 4

        if rating < bad_border <= prediction:
            penalty_coefficient = 2.0
        else:
            penalty_coefficient = 1.0

        return penalty_coefficient*(rating - prediction)**2

    def evaluate(self, approxes, target, weight):
        # approxes is list of indexed containers
        # (containers with only __len__ and __getitem__ defined), one container
        # per approx dimension. Each container contains floats.
        # weight is one dimensional indexed container.
        # target is float.
        # weight parameter can be None.
        # Returns pair (error, weights sum)

        assert len(approxes) == 1
        assert len(target) == len(approxes[0])

        approx = approxes[0]

        error_sum = 0.0
        weight_sum = 0.0

        for i in range(len(approx)):
            weight_sum += 1
            error_sum += self._rmse_asymmetric(target[i], approxes[0][i])

        return error_sum, weight_sum