class mandelblot:
    import matplotlib.pyplot as plt, numpy as np, math
    def __init__(self, n:int=2, pixel:int=200, xy_range=[[-2.1, 0.5], [-1.2, 1.2]], count_type:int=0, is_add=True):
        self.n = n
        self.xy_range = xy_range
        self.count_type = count_type
        self.is_add = is_add
        xs = self.np.linspace(xy_range[1][0], xy_range[1][1], pixel+1)
        ys = self.np.linspace(xy_range[0][0], xy_range[0][1], pixel+1)
        self.xy = [[self.calc(r, i) for i in xs] for r in ys]
        self.xs = [xs for y in ys]
        self.ys = [[y for _ in ys] for y in ys]

    def combination(self, a, b):
        result = 1
        for i in range(b):
            result *= (a-i)/(b-i)
        return result

    def i_separate(self, k):
        result = self.math.sin(self.math.radians(k*90 + 45))
        if(result < 0):
            return -1
        elif (result > 0):
            return 1
        return 0

    def comp_binomial(self, r, i, n):
        real, imagine, add = 0., 0., 0.
        for k in range(n+1):
            if(k % 2 == 0):
                num = self.combination(n, k)*(i**k)*(r**(n-k))*self.i_separate(k)
                real += num
                add += self.absol(num)
            else:
                imagine += self.combination(n, k)*(i**k)*(r**(n-k))*self.i_separate(k)
        #print(real, imagine)
        return real, imagine, add

    def absol(self, n):
        return n if(n >= 0) else -n

    def calc(self, r, i, lim=1e6, for_range=2**7):
        new_r, new_i, add = 0., 0., 0.
        for count in range(for_range):
            try:
                new_r, new_i, add = self.comp_binomial(new_r + r, new_i + i, self.n)
            except :
                return self.scale(count)
            if(self.is_add):
                if(add >= lim):
                    return self.count_scale(count)
            else:
                if(new_r >= lim):
                    return self.count_scale(count)
        return -1

    def count_scale(self, n):
        """
        count_typeの説明
        0 : 発散速度をそのまま反映 <- 基本
        1 : 発散速度を２乗 <- 集合の正確さが高くなる
        2 : tanh(円周率/発散速度) <- 発散速度の分布が見やすい。
        3 : 発散の有無のみを反映（発散すれば1, しなければ-1）
        """
        if(self.count_type == 0):
            return n
        elif(self.count_type == 1):
            return n**2
        elif (self.count_type == 2):
            if(n == 0):
                return 0
            else:
                return self.math.tanh(self.math.pi/n)
        elif (self.count_type == 3):
            return 1 if(n > 0) else -1
        else:
            return n
        
    def s_g_scale(self, s_g):
        s = s_g[0][1] - s_g[0][0]
        g = s_g[1][1] - s_g[1][0]
        return s, g

    def plot(self, size=10, save=False, axis=True, buff=""):
        s, g = self.s_g_scale(self.xy_range)
        fig = self.plt.figure(figsize=(size*s, size*g))
        self.plt.pcolor(self.ys, self.xs, self.xy)
        if not(axis):
            self.plt.axis("off")
        self.plt.show()
        if(save):
            fig.savefig("mandelblot"+buff+".jpg")