AREA_POWER = 0.25

    count = sum(i * x for i, x in enumerate(hist))

    return count / total

    value = sum(i * x for i, x in enumerate(hist)) / total
    error = sum(x * (value - i) ** 2 for i, x in enumerate(hist)) / total
    error = error ** 0.5
    return value, error

    r = weighted_average(hist[:256])
    g = weighted_average(hist[256:512])
    b = weighted_average(hist[512:768])
    return (r, g, b)

    r, re = weighted_average(hist[:256])
    g, ge = weighted_average(hist[256:512])
    b, be = weighted_average(hist[512:768])
    e = re * 0.2989 + ge * 0.5870 + be * 0.1140
    return (r, g, b), e

def component_error(hist, value):
    count = sum(x * (value - i) ** 2 for i, x in enumerate(hist))
    total = sum(hist)
    return (count / total) ** 0.5
def error(hist, color):
    r = component_error(hist[:256], color[0])
    g = component_error(hist[256:512], color[1])
    b = component_error(hist[512:768], color[2])
    return r * 0.2989 + g * 0.5870 + b * 0.1140

        self.color = color_from_histogram(hist)
        self.error = error(hist, self.color)

        self.color, self.error = color_from_histogram(hist)

        self.error_numerator = quad.error * quad.area
        self.error_denominator = quad.area

        self.error_sum = quad.error * quad.area

    def total_error(self):
        return self.error_numerator / self.error_denominator

    def average_error(self):
        return self.error_sum / (self.width * self.height)

        score = -quad.error * (quad.area ** 0.125)

        score = -quad.error * (quad.area ** AREA_POWER)

        self.error_numerator -= quad.error * quad.area

        self.error_sum -= quad.error * quad.area

            self.error_numerator += child.error * child.area

            self.error_sum += child.error * child.area

        error = model.total_error()

        error = model.average_error()