Calculadora Algebraica Hibrida
Go to file
Miguel aaddfbc3fa Actualización de la interfaz de la calculadora híbrida con ajustes en la geometría de la ventana y el sistema de autocompletado. Se añade una nueva opción para copiar información de depuración al portapapeles, mejorando la accesibilidad de datos. Se optimiza el historial de cálculos y se realizan mejoras en la gestión de variables simbólicas en el motor algebraico. 2025-06-11 11:07:07 +02:00
.doc Primera version con pyside 2025-06-07 23:48:14 +02:00
.vscode Refactorizacion de nombres de scripts 2025-06-02 17:04:34 +02:00
custom_types Implementación de un método para generar contenido LaTeX completo en el panel, mejorando la representación de resultados y asignaciones. Se optimiza el manejo de expresiones y se añaden mejoras en el parseo de ecuaciones. Se actualiza el historial de cálculos eliminando contenido obsoleto. 2025-06-11 10:40:11 +02:00
debug_templates Mejorado para que la API de Debug sea solo un wrap y no necesite actualizacion 2025-06-05 18:27:56 +02:00
.gitignore Mejorado del Motor algebraico 2025-06-06 11:45:04 +02:00
CORRECCIONES_APLICADAS.md No funcionando el panel Latex 2025-06-09 21:56:16 +02:00
MaVCalcv2.lnk No funcionando el panel Latex 2025-06-09 21:56:16 +02:00
README_MEJORAS_PYSIDE6.md No funcionando el panel Latex 2025-06-09 21:56:16 +02:00
README_PYSIDE6.md Primera version con pyside 2025-06-07 23:48:14 +02:00
RENDERIZADO_LATEX.md Actualización del panel LaTeX con integración de pywebview para un renderizado más robusto. Se añade soporte para JavaScript y se optimiza la generación de HTML para diferentes tipos de webview. Se mejora la gestión de ecuaciones y se implementan nuevos estilos para una mejor visualización. Se ajustan configuraciones de la interfaz y se mejora la lógica de actualización del contenido. 2025-06-07 23:16:14 +02:00
RESUMEN_AUTOCOMPLETADO_COMPLETO.md No funcionando el panel Latex 2025-06-09 21:56:16 +02:00
calc.py Implementación de un sistema de logging para mejorar la gestión de advertencias y errores en la aplicación. Se establece un límite para la cantidad de archivos de log generados y se optimiza la configuración de la ventana. Se ajusta el manejo de la evaluación y el autocompletado, mejorando la experiencia del usuario. 2025-06-04 21:38:40 +02:00
class_base.py """ 2025-06-02 20:18:10 +02:00
hybrid_calc_history.txt Actualización de la interfaz de la calculadora híbrida con ajustes en la geometría de la ventana y el sistema de autocompletado. Se añade una nueva opción para copiar información de depuración al portapapeles, mejorando la accesibilidad de datos. Se optimiza el historial de cálculos y se realizan mejoras en la gestión de variables simbólicas en el motor algebraico. 2025-06-11 11:07:07 +02:00
hybrid_calc_history_pyside6.txt No funcionando el panel Latex 2025-06-09 21:56:16 +02:00
hybrid_calc_settings.json Actualización de la interfaz de la calculadora híbrida con ajustes en la geometría de la ventana y el sistema de autocompletado. Se añade una nueva opción para copiar información de depuración al portapapeles, mejorando la accesibilidad de datos. Se optimiza el historial de cálculos y se realizan mejoras en la gestión de variables simbólicas en el motor algebraico. 2025-06-11 11:07:07 +02:00
icon.ico Version con Plot funcionando 2025-06-01 17:20:22 +02:00
icon.png Refactorizacion de nombres de scripts 2025-06-02 17:04:34 +02:00
latex_debug.html No funcionando el panel Latex 2025-06-09 21:56:16 +02:00
launch_pyside6.py Primera version con pyside 2025-06-07 23:48:14 +02:00
main_calc_app.py Actualización del panel LaTeX con integración de pywebview para un renderizado más robusto. Se añade soporte para JavaScript y se optimiza la generación de HTML para diferentes tipos de webview. Se mejora la gestión de ecuaciones y se implementan nuevos estilos para una mejor visualización. Se ajustan configuraciones de la interfaz y se mejora la lógica de actualización del contenido. 2025-06-07 23:16:14 +02:00
main_calc_app_pyside6.py Actualización de la interfaz de la calculadora híbrida con ajustes en la geometría de la ventana y el sistema de autocompletado. Se añade una nueva opción para copiar información de depuración al portapapeles, mejorando la accesibilidad de datos. Se optimiza el historial de cálculos y se realizan mejoras en la gestión de variables simbólicas en el motor algebraico. 2025-06-11 11:07:07 +02:00
main_evaluation_puro.py Actualización de la interfaz de la calculadora híbrida con ajustes en la geometría de la ventana y el sistema de autocompletado. Se añade una nueva opción para copiar información de depuración al portapapeles, mejorando la accesibilidad de datos. Se optimiza el historial de cálculos y se realizan mejoras en la gestión de variables simbólicas en el motor algebraico. 2025-06-11 11:07:07 +02:00
readme.md Limpieza y actualizacion de documentos 2025-06-05 17:59:33 +02:00
requirements.txt Primera version con pyside 2025-06-07 23:48:14 +02:00
simple_debug.py mejorado de solve para equaciones con varias variables 2025-06-06 15:05:56 +02:00
sympy_Base.py Actualización del sistema de tokenización y refactorización de clases base. Se implementa un nuevo enfoque de tokenización distribuida que permite la carga dinámica de clases desde el registro, mejorando la modularidad y escalabilidad del sistema. Se eliminan dependencias de clases codificadas y se optimizan las funciones de evaluación y análisis de expresiones. Se ajustan las configuraciones de la ventana y se mejora la gestión de errores y advertencias en el motor de evaluación. 2025-06-05 17:26:23 +02:00
sympy_helper.py Actualización de la configuración de la ventana y ajustes en la posición de los elementos. Se añade soporte para la conversión a LaTeX en varias partes del código, incluyendo nuevas funcionalidades en el motor de evaluación y en la clase de herramientas de Sympy. Se mejora la gestión dinámica de clases de corchetes, eliminando dependencias de clases codificadas y optimizando la recarga de clases. También se incorpora la opción de registrar versiones en minúscula de las clases en el registro de tipos. 2025-06-02 23:05:54 +02:00
test_final.py Mejora del panel LaTeX y ajustes en la configuración de la interfaz. Se implementa un sistema para verificar la disponibilidad de MathJax y se optimiza la gestión de ecuaciones pendientes. Se actualizan estilos y se ajusta la geometría de la ventana. Se añade un wrapper para la función 'solve' que convierte cadenas a símbolos automáticamente, mejorando la resolución de ecuaciones. 2025-06-11 10:19:14 +02:00
tl_bracket_parser.py Actualización del sistema de tokenización y refactorización de clases base. Se implementa un nuevo enfoque de tokenización distribuida que permite la carga dinámica de clases desde el registro, mejorando la modularidad y escalabilidad del sistema. Se eliminan dependencias de clases codificadas y se optimizan las funciones de evaluación y análisis de expresiones. Se ajustan las configuraciones de la ventana y se mejora la gestión de errores y advertencias en el motor de evaluación. 2025-06-05 17:26:23 +02:00
tl_popup.py Eliminación del archivo de historial de cálculos y ajustes en la configuración de la interfaz. Se mejora la gestión de resultados interactivos, incluyendo la actualización del panel de entrada al editar expresiones. Se optimizan los tags de salida para una mejor visualización de resultados y se implementa un nuevo sistema de redibujo para gráficos interactivos. 2025-06-06 16:32:25 +02:00
tl_popup_pyside6.py No funcionando el panel Latex 2025-06-09 21:56:16 +02:00
type_registry.py Refactorización del motor de evaluación para utilizar un sistema algebraico puro. Se actualizan las configuraciones de la interfaz y se simplifican las funciones de evaluación. Se añaden patrones de tokenización en el registro de tipos y se mejora la gestión de errores en el motor. Se eliminan configuraciones obsoletas y se optimiza el menú de herramientas. 2025-06-06 07:00:00 +02:00

readme.md

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