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

```python
# 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:
```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)

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

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