import numpy as np
from time import perf_counter


class Eclipse:
    def __init__(self, a: "float", b: "float"):
        c = np.sqrt(a * a - b * b)
        self.a2l, self.b2l = 2 * np.abs(a), 2 * np.abs(b)
        self.f1, self.f2 = (-c, 0), (c, 0)

    @staticmethod
    def __dis(p1: "tuple", p2: "tuple") -> "np.double":
        return np.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)

    def inner_rect_binary(self, *, al: "float" = None, bl: "float" = None) -> "np.double":
        if al is None and bl is None:
            return np.double(0)
        if al is not None:
            al = np.abs(al)
            if al < 1E-5:
                return self.b2l
            if al >= self.a2l - 1E-5:
                return np.double(0)
            start, end, x, y = 0, self.b2l / 2, al / 2, self.b2l / 4
            while True:
                p = (x, y)
                dis = self.__dis(p, self.f1) + self.__dis(p, self.f2)
                if np.abs(dis - self.a2l) < 1E-5:
                    return np.double(2 * y)
                if dis < self.a2l:
                    start = y
                else:
                    end = y
                y = (start + end) / 2
        else:
            bl = np.abs(bl)
            if bl < 1E-5:
                return self.a2l
            if bl >= self.b2l - 1E-5:
                return np.double(0)
            start, end, x, y = 0, self.a2l / 2, self.b2l / 4, bl / 2
            while True:
                p = (x, y)
                dis = self.__dis(p, self.f1) + self.__dis(p, self.f2)
                if np.abs(dis - self.a2l) < 1E-5:
                    return np.double(2 * x)
                if dis < self.a2l:
                    start = x
                else:
                    end = x
                x = (start + end) / 2

    # 50 times faster than <inner_rect_binary>
    def inner_rect_scale(self, *, al: "float" = None, bl: "float" = None) -> "np.double":
        if al is None and bl is None:
            return np.double(0)
        if al is not None:
            if al <= 0:
                return self.b2l
            if al >= self.a2l:
                return np.double(0)
            short = self.b2l / self.a2l * al
            return np.sqrt(self.b2l ** 2 - short ** 2)
        if bl is not None:
            if bl <= 0:
                return self.a2l
            if bl >= self.b2l:
                return np.double(0)
            short = np.sqrt(self.b2l ** 2 - bl ** 2)
            return self.a2l / self.b2l * short


def main():
    egg = Eclipse(125, 87.5)
    ls = np.linspace(0, 250, 100000)
    start = perf_counter()
    for ll in ls:
        egg.inner_rect_scale(al=ll)
        egg.inner_rect_scale(bl=ll)
    end = perf_counter()
    print(end - start)


if __name__ == "__main__":
    main()

"""
status = [Status()] * detector_count  # 初始化count个探测器的状态
Total, Current = 0, 0

def count(distances, number):
    new, end = 0, 0
    for i in range(number):
        neighbors = get_neighbors_of(i)  # 获取当前探测器的邻居
        if detected(distances[i]):  # 当前探测器探测到鸡蛋数据
            if status[i].not_detected() and neighbors.not_detected():
                # 当前探测器上次没有数据，并且邻居也没探测到数据
                new += 1
        else:  # 当前探测器没有鸡蛋数据
            if status[i].detected() and neighbors.is_end():
                # 当前探测器上次有鸡蛋数据，并且邻居已经检测结束
                end += 1
    update_status(distances)  # 将当前数据作为下一次的上一次状态
    Total += new
    current += new - end

    return Total, Current
"""