#
# PYTHON • MyCompiler
#
# Estudo de Isolinhas
# https://[Log in to view URL]
# Estudo de Isolinhas
# 
# 2026 Outubro Ter, 20
# 2026 Outubro Sex, 30
#
# by 
# j
# 

import numpy as np
import matplotlib.pyplot as plt
import colorsys

# Resolução ideal para ver as linhas bem definidas
MAXRESOLUTION = 72

def beta_dirichlet_numpy(Z, max_terms=150):
    
    beta = np.zeros_like(Z, dtype=complex)
   
    for k in range(max_terms):
        
        beta += (4**(-Z)) * ( (1 / (k + (1/4) )**Z) - (1 / (k + (3/4) )**Z) )
    
    return beta

def beta_dirichlet_numpy2(Z, max_terms=150):
    """Calcula a função Beta de Dirichlet de forma vetorizada no NumPy."""
    beta = np.zeros_like(Z, dtype=complex)
    for k in range(max_terms):
        beta += ((-1)**k) / ((2*k + 1)**Z)
    return beta

def Graphriemann():
    
    plt.style.use('dark_background')
    
    xMIN, xMAX = -3, +3
    yMIN, yMAX = -3, +3
    
    # 1. Geração do plano complexo
    x = np.linspace(xMIN, xMAX, MAXRESOLUTION)
    y = np.linspace(yMIN, yMAX, MAXRESOLUTION)
    X, Y = np.meshgrid(x, y)
    Z = X + 1j * Y
    
    # 2. Cálculo da Função
    Beta_Completo = beta_dirichlet_numpy(Z)
    
    # Extração de Magnitude e Fase para as isolinhas
    Módulo = np.abs(Beta_Completo)
    Fase = np.angle(Beta_Completo)
    
    # 3. Mapeamento HLS para a imagem de fundo
    H = (Fase + np.pi) / (2 * np.pi)
    L = 1.0 - 1.0 / (1.0 + Módulo**0.1)
    
    RGB = np.zeros((MAXRESOLUTION, MAXRESOLUTION, 3))
    for i in range(MAXRESOLUTION):
        for j in range(MAXRESOLUTION):
            RGB[i, j] = colorsys.hls_to_rgb(H[i, j], L[i, j], 1.0)
            
    # 4. Renderização do Gráfico
    plt.figure(figsize=(9, 9))
    
    # Desenha o fundo colorido
    plt.imshow(RGB, extent=[xMIN, xMAX, yMIN, yMAX], origin='lower', alpha=0.9)
    
    # 
    # Adicionando Isolinhas
    #
    # Isolinhas de Módulo 
    # Linhas pretas para os níveis
    # de magnitude
    # Usamos uma escala logarítmica 
    # ou níveis bem distribuídos para 
    # o relevo
    # 
    
    niveis_modulo = [0.2, 0.5, 0.8, 1.2, 1.8, 2.5, 3.5]
    contorno_mod = plt.contour(X, Y, Módulo, levels=niveis_modulo, 
                              colors='black', linewidths=0.8, alpha=0.6)
    
    # 
    # Adiciona pequenas etiquetas numéricas
    # nas linhas de módulo
    #
    
    plt.clabel(contorno_mod, inline=True, fmt='%.1f', fontsize=8, colors='black')

    #
    # Isolinhas de Fase 
    # Linhas brancas pontilhadas indicando 
    # a mudança de ângulo
    # 
    # Define 8 direções principais de ângulos 
    # (de -pi a pi)
    # 
    
    niveis_fase = np.linspace(-np.pi, np.pi, 9)[:-1]
    plt.contour(X, Y, Fase, levels=niveis_fase, 
                colors='white', linestyles='dashed', linewidths=0.5, alpha=0.4)
        
    # Configurações visuais finais
    plt.title('Beta Dirichlet $\\beta(s)$ com Isolinhas de Módulo e Fase')
    plt.xlabel('Re(s)')
    plt.ylabel('Im(s)')
    plt.grid(True, color='white', alpha=0.1, linestyle=':')
    plt.axis('on')
    plt.show()

Graphriemann()