Miguel
/
Calc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Calc/readme.md

476 lines
17 KiB
Markdown
Raw Permalink Blame History

# 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*
Reference in New Issue View Git Blame Copy Permalink