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 tipos dinámico con auto-descubrimiento.

Características Principales

• Motor SymPy completo: Cálculo simbólico y numérico integrado
• Sistema de tipos dinámico: Auto-descubrimiento desde custom_types/
• Sintaxis simplificada: Tipo[args] en lugar de Tipo("args")
• 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

Tipos Especializados

Redes y Direcciones IP

IP4[192.168.1.100/24]
IP4[10.0.0.1, 8]
IP4[172.16.0.5, 255.255.0.0]
IP4Mask[24]
IP4Mask[255.255.255.0]

Sistemas Numéricos

Hex[FF]              # Hexadecimal
Bin[1010]            # Binario  
Dec[255]             # Decimal
Chr[A]               # Caracteres ASCII

Métodos Disponibles

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

ip = IP4[192.168.1.100/24]
ip.NetworkAddress[]    # Dirección de red
ip.Nodes()            # Hosts disponibles
Hex[FF].toDecimal()   # Conversiones

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

Resolución

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

Funciones Matemáticas

Cálculo

diff(x**3, x)                    # Derivadas
integrate(sin(x), (x, 0, pi))   # Integrales
limit(sin(x)/x, x, 0)           # Límites
series(exp(x), x, 0, 5)         # Series

Álgebra

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

Matrices

Matrix([[1, 2], [3, 4]])    # Crear matriz
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

plot(sin(x), (x, -2*pi, 2*pi))           # Plot 2D
plot3d(x**2 + y**2, (x, -5, 5), (y, -5, 5))  # Plot 3D

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)

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

Importante: Cada modificación reconstruye el contexto desde la línea 1 hacia abajo.

Carga de Historial

• Al abrir la aplicación, se carga el historial anterior y se evalúa una vez para mostrar resultados
• A partir de ese momento, cada modificación limpia el contexto y reevalúa todo desde cero
• El historial se guarda automáticamente al cerrar la aplicación

Interfaz de Usuario

Paneles

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

Autocompletado

• Escribir . después de cualquier objeto muestra métodos disponibles
• El sistema usa tipos registrados dinámicamente
• Funciona con objetos SymPy y tipos personalizados

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
• 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 Dinámico

Auto-descubrimiento

Los tipos se cargan automáticamente desde custom_types/:

• Archivos *_type.py son detectados automáticamente
• Cada archivo define clases y función register_classes_in_module()
• Sistema modular y extensible sin modificar código central

Información de Tipos

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

• Clases registradas disponibles
• Sintaxis de corchetes soportada
• Métodos de cada tipo

Recargar Tipos

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

Casos de Uso

Análisis de Redes

network = IP4[192.168.0.0/24]
host = IP4[192.168.0.100/24]
network.Nodes()                # Hosts disponibles
host.NetworkAddress[]          # Dirección de red

Conversiones Numéricas

Hex[FF].toDecimal()           # 255
Dec[66].toChr()               # Chr('B')

Análisis Matemático

f = sin(x) * exp(-x**2/2)
df_dx = diff(f, x)            # Derivada
critical_points = solve(df_dx, x)  # Puntos críticos
plot(f, df_dx, (x, -3, 3))   # Visualización

Extensibilidad

Crear Nuevos Tipos

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

Ejemplo de Estructura

# custom_types/ejemplo_type.py
from sympy_Base import SympyClassBase

class Class_Ejemplo(SympyClassBase):
    def __init__(self, value):
        super().__init__(processed_value, original_str)
    
    @staticmethod
    def Helper(input_str):
        return "Ayuda para Ejemplo"
    
    @staticmethod  
    def PopupFunctionList():
        return [("metodo", "Descripción del método")]

def register_classes_in_module():
    return [("Ejemplo", Class_Ejemplo, "SympyClassBase", {})]

Resolución de Problemas

Errores Comunes

• Dependencias faltantes: Ejecutar pip install sympy matplotlib numpy
• tkinter en Linux: sudo apt-get install python3-tk
• Sintaxis: Usar Tipo[args] no Tipo("args")

Performance

• Expresiones complejas pueden ser lentas en SymPy
• Plots 3D requieren tiempo de renderizado
• Matrices grandes consumen memoria

Debugging

• Los logs se guardan en logs/
• Usar Menú Tipos → Información para verificar tipos cargados
• Verificar custom_types/ para tipos personalizados

Arquitectura

Componentes Principales

• type_registry.py: Sistema de auto-descubrimiento
• main_evaluation.py: Motor CAS híbrido
• tl_bracket_parser.py: Parser de sintaxis con corchetes
• tl_popup.py: Resultados interactivos
• main_calc_app.py: Aplicación principal

Flujo de Ejecución

1. Auto-descubrimiento de tipos en custom_types/
2. Registro dinámico de clases y métodos
3. Parser convierte sintaxis con corchetes
4. Motor SymPy evalúa expresiones
5. Resultados se presentan interactivamente

---

Calculadora MAV - CAS Híbrido
Sistema extensible para cálculo matemático y análisis especializado