(Learner1D) add possibility to use the direct neighbors in the loss about adaptive HOT 2 CLOSED

from bisect import bisect_left

import adaptive
adaptive.notebook_extension()
import numpy as np

from adaptive.learner.learner1D import default_loss
from adaptive.learner.learnerND import volume


def simple_runner(learner, goal):
    while not goal(learner):
        x = learner.ask(1)[0][0]
        y = learner.function(x)
        learner.tell(x, y)

        # Hack to also update the losses of neigbouring intervals
        sorted_data = sorted(learner.data)
        index = bisect_left(sorted_data, x)
        xs = [sorted_data[i] for i in range(index-1, index+3)
              if 0 <= i < len(sorted_data)]
        if len(xs) > 2:
            for i in range(len(xs)-1):
                ival = xs[i], xs[i+1]
                learner._update_interpolated_loss_in_interval(*ival)

def loss_of_multi_interval(xs, function_values):
    pts = [(x, function_values[x]) for x in xs]
    N = len(pts) - 2
    return sum(volume(pts[i:i+3]) for i in range(N)) / N

def triangle_loss(interval, scale, function_values):
    _default_loss = default_loss(interval, scale, function_values)
    x_left, x_right = interval
    data = sorted(function_values)
    index = bisect_left(data, x_left)
    xs = [data[i] for i in range(index-1, index+3) if 0 <= i < len(data)]
    dx = x_right - x_left
    if len(xs) <= 2:
        return dx
    else:
        triangle_loss = loss_of_multi_interval(xs, function_values)
        return triangle_loss**0.5 + 0.02 * _default_loss + 0.02 * dx

def f5(x):
    return np.exp(-(x-0.3)**2/0.1**3)

learner = adaptive.Learner1D(f5, (-1, 1), loss_per_interval=triangle_loss)
simple_runner(learner, goal=lambda l: l.npoints > 1000)

learner.plot()