|
||
---|---|---|
.data | ||
.doc | ||
.res | ||
.vscode | ||
app | ||
custom_types | ||
debug_templates | ||
.gitignore | ||
Calc.lnk | ||
calc.py | ||
icon.ico | ||
readme.md | ||
requirements.txt |
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
- Crear archivo en
custom_types/nuevo_type.py
- Definir clase heredando de
ClassBase
oSympyClassBase
- Implementar
get_tokenization_patterns()
(opcional) - Implementar
register_classes_in_module()
- 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
- Auto-descubrimiento: Carga tipos desde
custom_types/
- Registro dinámico: Clases, métodos, helpers y patrones de tokenización
- Tokenización distribuida: Cada clase define sus propios patrones
- Conversión automática: Patrones específicos → objetos tipados
- Evaluación híbrida: Objetos nativos + SymPy cuando es necesario
- 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