#
# PYTHON • MyCompiler
# complexgraph
# https://[Log in to view URL]
# complex graph
# 
# 2026 Junho Ter, 2
# by 
# j
# 

import matplotlib.pyplot as plt

import numpy as np

from numpy import pi
from numpy import angle
from numpy import sin
from numpy import cos
from numpy import log

from scipy.special import zeta
from scipy.special import bernoulli

import math
import colorsys

MAXRESOLUTION = 400

def ff(f,z):
    
    match f:
        
        case 0:

            s = z**2
            t = "z^2"
            
        case 1:

            s = z**3
            t = "z^3"

        case 2:

            s = z**2 + z**3
            t = "z^2 + z^3"

        case 3:
            
            s = sin(z**2 + z**3)
            t = "sin(z^2 + z^3)"
            
        case 4:

            s = sin(z**2 + z**3)/cos(abs(z**3)/2)
            t = "sin(z^2 + z^3)/cos(abs(z^3)/2)"
            
        case 5:

            s = sin(z**2)/(sin(0.2*z)+cos(0.3*z))
            t = "(sin(z^2)*cos(z^3))/(sin(0.2z)+cos(0.3z))"
            
        case 6:
            
            s = sin(2*z**2)/(sin(0.2*z)-cos(0.3*z))
            t = "sin(2z^2)/(sin(0.2z)-cos(0.3z))"

    tupla = (s,t)
    
    return tupla

def complexgraph(f):
    
    #
    # Parametrizações
    #
    
    plt.style.use('dark_background')
    
    xRESOLUTION = MAXRESOLUTION
    yRESOLUTION = MAXRESOLUTION
    
    H   = np.zeros((xRESOLUTION, yRESOLUTION))
    S   = np.zeros((xRESOLUTION, yRESOLUTION))
    L   = np.zeros((xRESOLUTION, yRESOLUTION))
    RGB = np.zeros((xRESOLUTION, yRESOLUTION, 3))
    
    xMIN = -2.00
    yMIN = -2.00
    xMAX = +2.00
    yMAX = +2.00

    #
    # Preparação
    #
    
    deltaX = (xMAX - xMIN) / xRESOLUTION
    deltaY = (yMAX - yMIN) / yRESOLUTION

    #
    # Varredura Principal
    #
    
    for idx in range(xRESOLUTION):
        
        x = xMIN + idx * deltaX
        
        for idy in range(yRESOLUTION):
            
            y = yMIN + idy * deltaY
            
            #
            # Cálculo da Função Complexa
            #
            
            try:
                
                s    = ff(f,complex(x,y))[0]
                nome = ff(f,complex(x,y))[1]
                
            except:
                
                s = 0j
                
            #
            # Cálculo parâmetros cores HLS
            #
            
            H[idx, idy] = (angle(s) + pi) / (2 * pi)
            L[idx, idy] = 1.0 - 1.0 / (1.0 + abs(s)**0.5)
            S[idx, idy] = 1.0

    #
    # Converte cada pixel individualmente 
    # de HLS para RGB 
    # usando a biblioteca colorsys
    #
    
    for i in range(xRESOLUTION):
        
        for j in range(yRESOLUTION):
        
            RGB[i, j] = colorsys.hls_to_rgb(H[i, j], L[i, j], S[i, j]) 

    #
    # Gera o gráfico
    # 

    tit = "$f(z) = " + nome + "$"
    plt.imshow(RGB.swapaxes(0, 1), extent=[xMIN, xMAX, yMIN, yMAX], origin='lower')

    plt.title(tit)
    plt.xlabel("Re(s)")
    plt.ylabel("Im(s)")
    
    plt.axis('on')
    plt.show()

complexgraph(6)