# 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
```python
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
```python
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:
```python
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
```python
x + 2 = 5           # Detectado automáticamente
y**2 - 4 = 0        # Agregado al sistema
sin(x) = 1/2        # Ecuaciones trigonométricas
```

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

## Funciones Matemáticas

### Cálculo
```python
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
```python
simplify(expr)      # Simplificación
expand((x+1)**3)    # Expansión
factor(x**2-1)      # Factorización
solve([eq1, eq2], [x, y])  # Sistemas
```

### Matrices
```python
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

```python
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:
```python
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
```python
# 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
```python
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
```python
Hex[FF].toDecimal()           # 255
Dec[66].toChr()               # Chr('B')
```

### Análisis Matemático
```python
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
```python
# 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*