Calculadora MAV - CAS Híbrido

Descripción

Sistema de Álgebra Computacional (CAS) que combina SymPy con clases especializadas para networking, programación y análisis numérico. Incluye sistema de tokenización automática y auto-descubrimiento dinámico de tipos.

Características Principales

• Motor SymPy completo: Cálculo simbólico y numérico integrado
• Tokenización automática: 16#FF, 192.168.1.1 se convierten en objetos tipados automáticamente
• Sistema de tipos auto-descubrible: Auto-registro desde custom_types/ sin modificar código
• Clases base universales: IntBase (números en cualquier base) y FourBytes (patrones x.x.x.x)
• Conversión perezosa a SymPy: Objetos nativos hasta que se necesite álgebra compleja
• Detección automática de ecuaciones: Sin sintaxis especial
• Contexto limpio por evaluación: Cada modificación evalúa todo desde cero, garantizando comportamiento predecible
• Resultados interactivos: Elementos clickeables para plots, matrices y listas
• Autocompletado inteligente: Basado en tipos registrados dinámicamente

Tokenización Automática ⭐ NUEVO

El sistema reconoce automáticamente patrones específicos y los convierte en objetos tipados:

Números en Bases

# Entrada del usuario → Conversión automática
16#FF                 # → IntBase('FF', 16) = 255
2#1010               # → IntBase('1010', 2) = 10  
8#777                # → IntBase('777', 8) = 511
16#x0                # → IntBase('x0', 16) = simbólico

Patrones x.x.x.x

# Entrada del usuario → Conversión automática  
192.168.1.1          # → FourBytes('192.168.1.1')
255.255.0.0          # → FourBytes('255.255.0.0')
10.x.1.y             # → FourBytes('10.x.1.y') = simbólico

Constructores Inteligentes

# Los constructores aceptan objetos tokenizados automáticamente
IP4(192.168.1.1, 24)              # FourBytes tokenizado automáticamente
IP4(10.1.1.1, 255.255.0.0)        # Ambos FourBytes automáticamente
Hex(16#FF)                         # IntBase tokenizado automáticamente
Hex(192.168.1.1)                   # Conversión FourBytes → Hex

Tipos Especializados

Clases Base Universales ⭐ NUEVO

IntBase - Números Universales

# Aritmética que mantiene la base original:
a = 16#FF                    # → IntBase('FF', 16)
b = 16#10                    # → IntBase('10', 16)
result = a + b               # → IntBase('10F', 16) [271 en decimal]

# Operaciones mixtas:
c = 16#A0 + 32               # → IntBase('C0', 16) [192 en decimal]
d = 2#1010 * 3               # → IntBase('11110', 2) [30 en decimal]

# Conversiones:
a.to_base(2)                 # → IntBase('11111111', 2)
a.to_decimal()               # → 255

FourBytes - Patrones x.x.x.x Universales

# Aritmética de direcciones IP:
ip1 = 192.168.1.1            # → FourBytes automático
ip2 = ip1 + 5                # → FourBytes('192.168.1.6')
next_net = 10.0.0.0 + 256    # → FourBytes('10.0.1.0')

# Conversiones automáticas:
ip = 192.168.1.1             # → FourBytes
ip_hex = ip.ToHex()          # → "16#C0.16#A8.16#1.16#1"
ip_bin = ip.ToBinary()       # → "2#11000000.2#10101000.2#1.2#1"

# Aritmética simbólica:
network = 10.x.0.0           # → FourBytes simbólico
network.substitute(x=5)      # → FourBytes('10.5.0.0')

Redes y Direcciones IP

# Constructores automáticos con tokenización:
IP4(192.168.1.100, 24)              # FourBytes + CIDR
IP4(10.0.0.1, 255.255.248.0)        # FourBytes + máscara FourBytes
IP4(172.16.0.5, 16#ffffff00)        # FourBytes + máscara IntBase

# Métodos de red:
ip = IP4(192.168.1.100, 24)
ip.NetworkAddress()                  # → IP4(192.168.1.0, 24)
ip.BroadcastAddress()                # → IP4(192.168.1.255, 24) 
ip.Nodes()                           # → 254 hosts disponibles
ip.next_ip()                         # → IP4(192.168.1.101, 24)

# Máscaras inteligentes:
IP4Mask(24)                          # → CIDR
IP4Mask(255.255.255.0)               # → Dotted decimal (tokenizado)
IP4Mask(16#ffffff00)                 # → Desde hex (tokenizado)

Sistemas Numéricos Especializados

# Conversiones automáticas desde clases base:
Hex(16#FF)               # IntBase → Hex
Bin(2#1010)              # IntBase → Bin  
Dec(255)                 # → Decimal
Chr(65)                  # → Chr('A')

# Conversiones desde FourBytes:
Hex(192.168.1.1)         # FourBytes → Hex (32-bit)
Bin(192.168.1.1)         # FourBytes → Bin por elementos

Métodos Disponibles

Los tipos incluyen métodos específicos accesibles con autocompletado:

# IntBase universal:
val = 16#FF
val.to_base(2)           # Conversión a otra base
val.substitute(x=15)     # Sustitución simbólica
val.to_sympy()           # Conversión explícita a SymPy

# FourBytes universal:
addr = 192.168.1.1
addr.ToHex()             # → "16#C0.16#A8.16#1.16#1"
addr.substitute(x=5)     # Para casos simbólicos
addr.is_valid_ip_range() # Validación de rango IP

# IP4 especializado:
ip = IP4(192.168.1.100, 24)
ip.NetworkAddress()      # Dirección de red
ip.add_hosts(10)         # Suma hosts
ip.in_same_network(other_ip)  # Comparación de redes

Sistema de Ecuaciones

Detección Automática

x + 2 = 5           # Detectado automáticamente
y**2 - 4 = 0        # Agregado al sistema
sin(x) = 1/2        # Ecuaciones trigonométricas

# Con objetos tokenizados:
16#x0 + 16#10 = 256      # Ecuación con IntBase
10.x.1.1 + 255 = 10.x.2.0  # Ecuación con FourBytes

Resolución

solve(x**2 + 2*x - 8, x)         # Resolver ecuación específica
x=?                              # Atajo para solve(x)

# Con objetos especializados:
solve(16#x0 + 16#10 - 256, x)    # → x = 240 (en decimal)
network = 10.x.0.0
solve(network + 256 == 10.5.0.0, x)  # → x = 5

Funciones Matemáticas

Cálculo

# Con objetos nativos (conversión automática cuando es necesario):
diff(16#x0, x)                   # → 16*log(16)
integrate(sin(16#x), x)          # Conversión a SymPy automática
limit(192.168.x.1 / x, x, 0)    # Con FourBytes simbólico

Álgebra

simplify(expr)                   # Simplificación
expand((16#x + 1)**3)           # Expansión con IntBase
factor(x**2 - 16#100)           # Factorización mixta
solve([eq1, eq2], [x, y])       # Sistemas

Matrices

Matrix([[16#FF, 2#1010], [192.168.1.1, 255.255.0.0]])  # Con objetos tokenizados
det(M)                           # Determinante
inv(M)                           # Inversa

Resultados Interactivos

Los siguientes resultados son clickeables en la interfaz:

• 📊 Ver Plot: Abre matplotlib para gráficas
• 📋 Ver Matriz: Vista expandida con operaciones
• 📋 Ver Lista: Contenido completo de listas largas
• 🔍 Ver Detalles: Información completa de objetos

Plotting

# Con objetos nativos (conversión automática):
plot(sin(16#x), (x, 0, 255))             # IntBase en plot
plot(192.168.x.1, (x, 0, 255))           # FourBytes simbólico
plot3d(x**2 + y**2, (x, -5, 5), (y, -5, 5))  # Plot 3D tradicional

Variables y Símbolos

Todas las variables son símbolos SymPy automáticamente:

x = 5        # x es Symbol('x') con valor 5
y = x + 2    # y es 7 (evaluado)
z = x + a    # z es Symbol('x') + Symbol('a') (simbólico)

# Con objetos tokenizados:
ip_base = 192.168.x.0     # FourBytes simbólico
hex_val = 16#x0           # IntBase simbólico

Comportamiento de Contexto Limpio

Principio fundamental: Cada vez que modifica cualquier línea, la aplicación reevalúa todo desde cero.

Ventajas

• Predecible: El primer x en cualquier secuencia siempre es un símbolo puro
• Sin sorpresas: No hay variables "fantasma" de evaluaciones anteriores
• Contextual: Las variables solo existen si están definidas en líneas anteriores
• Determinista: Misma entrada → mismo resultado, siempre

Ejemplo

# Al escribir esta secuencia línea por línea:
x        # → Symbol('x') puro (sin valor)
x=1      # → Asigna x=1
y+x      # → y + 1 (usa x=1 definido arriba)
x=x+1    # → Incrementa x a 2
x        # → Muestra 2

# Con tokenización automática:
ip = 192.168.1.1     # → FourBytes('192.168.1.1')
ip + 5               # → FourBytes('192.168.1.6')

Interfaz de Usuario

Paneles

• Izquierdo: Entrada de código
• Derecho: Resultados con colores y elementos interactivos

Autocompletado Dinámico

• Escribir . después de cualquier objeto muestra métodos disponibles
• Sistema auto-descubre métodos desde tipos registrados dinámicamente
• Funciona con objetos SymPy, IntBase, FourBytes y tipos personalizados
• Soporte para objetos tokenizados automáticamente

Menús

• Archivo: Nuevo, Cargar, Guardar
• Editar: Limpiar entrada/salida, Limpiar historial
• Configuración: Modos simbólicos, Recargar tipos personalizados
• Tipos: Información de tipos, Sintaxis de tipos ⭐ NUEVO
• Ayuda: Guías y referencia

Nota: Se han eliminado las opciones relacionadas con limpiar variables/ecuaciones ya que el contexto se limpia automáticamente en cada evaluación.

Sistema de Tipos Auto-Descubrible ⭐ ACTUALIZADO

Auto-Descubrimiento Completo

• Tipos fundamentales: IntBase y FourBytes en custom_types/
• Tipos especializados: Todos los tipos en el directorio unificado
• Tokenización distribuida: Cada clase define sus propios patrones
• Precedencia automática: Patrones más específicos tienen mayor prioridad
• Parser genérico: Sin hardcoding de tipos específicos

Arquitectura Modular

custom_types/
├── intbase_type.py      # IntBase + tokenización + registro
├── fourbytes_type.py    # FourBytes + tokenización + registro
├── hex_type.py          # Hex (usa IntBase)
├── bin_type.py          # Bin (usa IntBase)  
├── dec_type.py          # Dec
├── chr_type.py          # Chr
├── ip4_type.py          # IP4 + IP4Mask (usa FourBytes)
└── latex_type.py        # LaTeX

Información de Tipos

Use Menú Tipos → Información de tipos para ver:

• Clases registradas disponibles
• Patrones de tokenización activos
• Precedencia de conversión
• Métodos de cada tipo

Recarga Dinámica

Menú Tipos → Recargar tipos para desarrollo en tiempo real.

Casos de Uso ⭐ ACTUALIZADOS

Análisis de Redes con Tokenización

# Tokenización automática en acción:
network = 192.168.0.0           # → FourBytes automático
mask = 255.255.255.0            # → FourBytes automático  
ip = IP4(network, mask)         # Constructor inteligente

# Aritmética de redes:
first_host = network + 1        # → FourBytes('192.168.0.1')
last_host = network + 254       # → FourBytes('192.168.0.254')

# Análisis con variables:
base = 10.x.0.0                 # → FourBytes simbólico
solve(base + 256 == 10.5.0.0, x)  # → x = 5

Conversiones Automáticas entre Bases

# IntBase universal:
hex_val = 16#FF                 # → IntBase('FF', 16)
bin_val = hex_val.to_base(2)    # → IntBase('11111111', 2)
oct_val = hex_val.to_base(8)    # → IntBase('377', 8)

# Aritmética preservando base:
result = 16#FF + 16#10          # → IntBase('10F', 16)
mixed = 16#A0 + 32              # → IntBase('C0', 16)

# FourBytes a otras representaciones:
ip = 192.168.1.1                # → FourBytes automático
ip_hex = ip.ToHex()             # → "16#C0.16#A8.16#1.16#1"
ip_binary = ip.ToBinary()       # → "2#11000000.2#10101000.2#1.2#1"

Análisis Matemático con Objetos Nativos

# Funciones con objetos tokenizados:
f = sin(16#x0) * exp(-x**2/2)   # IntBase en función
df_dx = diff(f, x)              # Derivada (conversión automática)
critical_points = solve(df_dx, x)  # Puntos críticos

# Visualización:
plot(f, df_dx, (x, -3, 3))     # Plot función y derivada

# Con FourBytes simbólico:
network_func = 10.x.1.0 + sin(x)
plot(network_func, (x, 0, 255)) 

Álgebra Simbólica Avanzada

# Sistemas con objetos nativos:
ip1 = 192.168.x.1               # FourBytes simbólico
ip2 = 10.y.1.1                  # FourBytes simbólico

# Ecuaciones con conversión automática:
solve([ip1 + 255 == 192.168.5.0, ip2 - 10.0.1.1 == 0], [x, y])
# → {x: 4, y: 0}

# Análisis de rangos:
hex_range = 16#x0               # IntBase simbólico
constraints = [hex_range >= 16#A0, hex_range <= 16#FF]
solve(constraints, x)           # → Rango válido para x

Extensibilidad ⭐ ACTUALIZADA

Crear Nuevos Tipos con Tokenización

1. Crear archivo en custom_types/nuevo_type.py
2. Definir clase heredando de ClassBase o SympyClassBase
3. Implementar get_tokenization_patterns() (opcional)
4. Implementar register_classes_in_module()
5. El sistema detecta automáticamente el nuevo tipo

Ejemplo Completo con Tokenización

# custom_types/mac_type.py
from class_base import ClassBase
import re

class MACAddress(ClassBase):
    def __init__(self, mac_string):
        # Procesar dirección MAC
        super().__init__(processed_value, mac_string)
    
    @staticmethod
    def get_tokenization_patterns():
        """Define patrones de tokenización automática"""
        return [
            {
                'pattern': r'\b([0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2})\b',
                'replacement': lambda match: f'MACAddress("{match.group(1)}")',
                'priority': 6,
                'description': 'MAC con dos puntos: AA:BB:CC:DD:EE:FF'
            }
        ]
    
    @staticmethod
    def Helper(input_str):
        if re.search(r'([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}', input_str):
            return "Direcciones MAC: AA:BB:CC:DD:EE:FF"
        return None
    
    @staticmethod  
    def PopupFunctionList():
        return [
            ("to_vendor", "Busca fabricante por OUI"),
            ("is_unicast", "Verifica si es unicast"),
            ("to_binary", "Convierte a representación binaria")
        ]

def register_classes_in_module():
    return [
        ("MACAddress", MACAddress, "ClassBase", {
            "add_lowercase": True,
            "supports_brackets": False,  # Usa tokenización
            "has_tokenization": True,
            "description": "Direcciones MAC con auto-detección"
        })
    ]

Uso Automático del Nuevo Tipo

# Después de agregar mac_type.py:
# AA:BB:CC:DD:EE:FF se convierte automáticamente en MACAddress("AA:BB:CC:DD:EE:FF")
mac = AA:BB:CC:DD:EE:FF         # Tokenización automática
vendor = mac.to_vendor()        # Métodos disponibles automáticamente

Resolución de Problemas

Errores Comunes

• Dependencias faltantes: Ejecutar pip install sympy matplotlib numpy
• tkinter en Linux: sudo apt-get install python3-tk
• Conversión prematura a SymPy: Algunos objetos se convierten antes de tiempo (en desarrollo)

Performance

• Tokenización automática es muy eficiente
• Expresiones complejas pueden ser lentas en SymPy
• Objetos nativos son más rápidos que conversiones SymPy
• Plots 3D requieren tiempo de renderizado

Debugging del Sistema de Tipos

• Los logs se guardan en logs/
• Usar Menú Tipos → Información para verificar tipos cargados y patrones activos
• Verificar custom_types/ para tipos personalizados
• Debug de tokenización: activar modo debug en el parser

Arquitectura ⭐ ACTUALIZADA

Componentes Principales

• type_registry.py: Sistema de auto-descubrimiento completo
• custom_types/: Directorio unificado de todos los tipos
• tl_bracket_parser.py: Tokenizador universal distribuido
• main_evaluation.py: Motor CAS híbrido integrado
• tl_popup.py: Resultados interactivos
• main_calc_app.py: Aplicación principal

Flujo de Ejecución ⭐ ACTUALIZADO

1. Auto-descubrimiento: Carga tipos desde custom_types/
2. Registro dinámico: Clases, métodos, helpers y patrones de tokenización
3. Tokenización distribuida: Cada clase define sus propios patrones
4. Conversión automática: Patrones específicos → objetos tipados
5. Evaluación híbrida: Objetos nativos + SymPy cuando es necesario
6. Resultados interactivos: Presentación con elementos clickeables

Precedencia de Tokenización

# Orden automático por especificidad:
IntBase:    priority = 5   # Muy específico: 16#FF
MAC:        priority = 6   # Específico: AA:BB:CC:DD:EE:FF  
FourBytes:  priority = 10  # General: x.x.x.x

---

Calculadora MAV - CAS Híbrido v2.1
Sistema extensible con tokenización automática para cálculo matemático y análisis especializado