12 KiB

Raw Blame History

Calculadora MAV - CAS Híbrido

Descripción General

La Calculadora MAV es un Sistema de Álgebra Computacional (CAS) Híbrido que combina la potencia de SymPy con clases especializadas para networking, programación y análisis numérico.

Características Principales

Motor SymPy completo: Todas las funciones de cálculo simbólico
Sintaxis simplificada: Class[args] en lugar de Class("args")
Detección automática de ecuaciones: Sin necesidad de comillas especiales
Resultados interactivos: Plots, matrices y listas clickeables
Clases especializadas: IP4, Hex, Bin, Date, Dec, Chr
Variables SymPy puras: Todas las variables son símbolos automáticamente

Instalación

Método 1: Instalación Automática

python launcher.py --setup

Método 2: Instalación Manual

# Instalar dependencias
pip install sympy matplotlib numpy

# En Linux: instalar tkinter
sudo apt-get install python3-tk

# Ejecutar tests (opcional)
python test_suite.py

# Iniciar aplicación
python launcher.py

Dependencias Requeridas

Python 3.8+
SymPy ≥ 1.12 (motor algebraico)
Matplotlib ≥ 3.7.0 (plotting)
NumPy ≥ 1.24.0 (cálculos numéricos)
Tkinter (interfaz gráfica, incluido con Python)

Dependencias Opcionales

Markdown ≥ 3.4.0 (ayuda mejorada)
pytest ≥ 7.0.0 (testing)

Guía de Uso

Sintaxis Básica

Clases Especializadas (Solo Corchetes)

# Direcciones IP con funcionalidad de red
IP4[192.168.1.100/24]
IP4[10.0.0.1, 8]
IP4[172.16.0.5, 255.255.0.0]

# Números en diferentes bases
Hex[FF]               # Hexadecimal: 0xFF
Bin[1010]             # Binario: 0b1010
Dec[10.5]             # Decimal: 10.5

# Caracteres ASCII
Chr[A]                # Carácter único: 'A' (ASCII 65)
Chr[Hello]            # String: 'Hello'

Métodos de Clases Especializadas

# Métodos de IP4
ip = IP4[192.168.1.100/24]
ip.NetworkAddress[]       # 192.168.1.0/24
ip.BroadcastAddress[]     # 192.168.1.255/24
ip.Nodes()               # 254 (hosts disponibles)

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

Ecuaciones y Álgebra

Detección Automática de Ecuaciones

# Ecuaciones simples (detectadas automáticamente)
x + 2 = 5
3*a + b = 10
y**2 = 16

# Desigualdades
x > 5
a <= 10
b != 0

# Ecuaciones complejas
sin(x) = 1/2
log(y) + 3 = 5

Resolución de Ecuaciones

# Resolver ecuación específica
solve(x**2 + 2*x - 8, x)    # [-4, 2]

# Atajo para resolver variable
x=?                         # Equivale a solve(x)

# Resolver sistema de ecuaciones
x + y = 10
x - y = 2
solve([x + y - 10, x - y - 2], [x, y])  # {x: 6, y: 4}

Variables y Símbolos

Variables SymPy Automáticas

# Todas las variables son símbolos SymPy automáticamente
x + 2*y                 # Expresión simbólica
z = 5                   # z es Symbol('z') con valor 5
w = z**2 + 3           # w es expresión: Symbol('z')**2 + 3

# Evaluación automática cuando es posible
a = 10
b = a + 5              # b = 15 (evaluado)
c = a + x              # c = 10 + x (simbólico)

Funciones Matemáticas

Cálculo Diferencial e Integral

# Derivadas
diff(x**3, x)                    # 3*x**2
diff(sin(x)*cos(x), x)          # -sin(x)**2 + cos(x)**2

# Integrales
integrate(x**2, x)              # x**3/3
integrate(sin(x), (x, 0, pi))   # 2

# Límites
limit(sin(x)/x, x, 0)           # 1

# Series de Taylor
series(exp(x), x, 0, 5)         # 1 + x + x**2/2 + x**3/6 + x**4/24 + O(x**5)

Funciones Trigonométricas

# Funciones básicas
sin(pi/2)              # 1
cos(0)                 # 1
tan(pi/4)              # 1

# Funciones inversas
asin(1)                # pi/2
acos(0)                # pi/2
atan(1)                # pi/4

# Funciones hiperbólicas
sinh(0)                # 0
cosh(0)                # 1
tanh(0)                # 0

Álgebra y Simplificación

# Simplificación
simplify((x**2 - 1)/(x - 1))    # x + 1
expand((x + 1)**3)              # x**3 + 3*x**2 + 3*x + 1
factor(x**2 - 1)                # (x - 1)*(x + 1)

# Manipulación de expresiones
collect(x**2 + 2*x + x**2, x)   # 2*x**2 + 2*x
cancel((x**2 - 1)/(x - 1))      # x + 1

Álgebra Lineal

Matrices

# Crear matrices
M = Matrix([[1, 2], [3, 4]])
N = Matrix([[5, 6], [7, 8]])

# Operaciones básicas
M + N                  # Suma de matrices
M * N                  # Multiplicación
M**2                   # Potencia

# Propiedades (clickeables en interfaz)
det(M)                 # Determinante: -2
inv(M)                 # Matriz inversa
M.transpose()          # Transpuesta

Plotting Interactivo

Plots 2D

# Plot básico
plot(sin(x), (x, -2*pi, 2*pi))

# Múltiples funciones
plot(sin(x), cos(x), (x, 0, 2*pi))

# Plot con clases especializadas
plot(Hex[x]/256, (x, 0, 255))

Plots 3D

# Superficie 3D
plot3d(x**2 + y**2, (x, -5, 5), (y, -5, 5))

# Con funciones trigonométricas
plot3d(sin(x)*cos(y), (x, 0, 2*pi), (y, 0, 2*pi))

Resultados Interactivos

Elementos Clickeables

📊 Ver Plot: Abre ventana matplotlib para plots
📋 Ver Matriz: Muestra matriz formateada con operaciones
📋 Ver Lista: Expande listas largas
🔍 Ver Detalles: Información completa de objetos

Ejemplo de Uso

# Estos resultados serán clickeables en la interfaz
Matrix([[1, 2, 3], [4, 5, 6]])     # 📋 Ver Matriz 2×3
plot(x**2, (x, -10, 10))           # 📊 Ver Plot
solve(x**3 - 6*x**2 + 11*x - 6, x) # 📋 Ver Soluciones

Casos de Uso Avanzados

Análisis de Redes

# Definir red
network = IP4[192.168.0.0/24]
host = IP4[192.168.0.100/24]

# Análisis
network.Nodes()              # 254 hosts disponibles
host.NetworkAddress[]        # 192.168.0.0/24
host.BroadcastAddress[]      # 192.168.0.255/24

# Cálculos con variables
base_ip = IP4[10.0.x.0/24]
solve(base_ip.Nodes() == 254, x)  # Encuentra x para 254 hosts

Programación y Conversiones

# Conversiones entre bases
hex_val = Hex[FF]           # 255 en decimal
bin_val = Bin[hex_val]      # Convertir a binario
chr_val = Chr[hex_val]      # Carácter ASCII

# Análisis de caracteres
text = Chr[Hello World]
ascii_values = text.value   # Lista de valores ASCII

# Operaciones bit a bit (con SymPy)
a = Hex[F0]
b = Hex[0F]
a | b                       # OR bit a bit
a & b                       # AND bit a bit
a ^ b                       # XOR bit a bit

Análisis Matemático Completo

# Definir función compleja
f = sin(x) * exp(-x**2/2)

# Análisis completo
df_dx = diff(f, x)                    # Derivada
critical_points = solve(df_dx, x)     # Puntos críticos
integral = integrate(f, (x, -oo, oo)) # Integral impropia

# Visualización
plot(f, df_dx, (x, -3, 3))          # Plot función y derivada

# Serie de Taylor en punto específico
taylor_series = series(f, x, 0, 6)   # Serie alrededor de x=0

Resolución de Sistemas Complejos

# Sistema de ecuaciones no lineales
x**2 + y**2 = 25
x*y = 12

# Resolver
solutions = solve([x**2 + y**2 - 25, x*y - 12], [x, y])

# Análisis paramétrico
# Ecuación con parámetro
a*x**2 + b*x + c = 0

# Resolver para diferentes valores
a_val = 1
b_val = 2
c_val = -3
solve(a_val*x**2 + b_val*x + c_val, x)

Interfaz de Usuario

Paneles

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

Menús

Archivo: Nuevo, Cargar, Guardar
Editar: Limpiar, operaciones de texto
CAS: Mostrar variables/ecuaciones, resolver sistema
Ayuda: Guías, sintaxis, funciones SymPy

Atajos de Teclado

Ctrl+S: Guardar archivo
Ctrl+O: Abrir archivo
Ctrl+N: Nueva sesión
F1: Ayuda rápida

Menú Contextual (Clic Derecho)

Panel Entrada: Cortar, Copiar, Pegar, Insertar ejemplo
Panel Salida: Copiar todo, Limpiar salida

Configuración y Personalización

Archivos de Configuración

hybrid_calc_settings.json: Configuración de ventana y UI
hybrid_calc_history.txt: Historial de sesión anterior

Variables de Entorno

PYTHONPATH: Asegurar que módulos sean encontrados
MPLBACKEND: Backend de matplotlib (ej: TkAgg)

Resolución de Problemas

Errores Comunes

Dependencias Faltantes

# Error: ModuleNotFoundError: No module named 'sympy'
pip install sympy matplotlib numpy

# Linux: tkinter no disponible
sudo apt-get install python3-tk

Errores de Sintaxis

# Incorrecto: sintaxis antigua
IP4("192.168.1.1/24")

# Correcto: nueva sintaxis
IP4[192.168.1.1/24]

Problemas de Variables

# Las variables son símbolos automáticamente
x = 5        # x es Symbol('x') con valor 5, no variable Python
y = x + 2    # y es Symbol('x') + 2, evaluado como 7

# Para variables Python tradicionales, usar eval explícito:
@eval: python_var = 5  # Sintaxis especial (si implementada)

Performance

Optimizaciones

Las líneas anteriores se cachean (no se re-evalúan)
Parsing de corchetes se cachea para expresiones repetidas
evalf() es lazy (solo cuando se muestra resultado)

Límites Conocidos

Sistemas de ecuaciones muy grandes pueden ser lentos
Plots 3D complejos requieren tiempo de renderizado
Matrices muy grandes pueden consumir memoria

Desarrollo y Extensión

Estructura del Proyecto

calculadora-mav-cas/
├── launcher.py              # Launcher principal
├── setup.py                 # Script de instalación
├── test_suite.py           # Tests unitarios
├── requirements.txt        # Dependencias
├── bracket_parser.py       # Parser de sintaxis
├── hybrid_base_types.py    # Clases especializadas
├── hybrid_evaluation_engine.py  # Motor CAS
├── interactive_results.py  # Resultados clickeables
└── hybrid_calc_app.py      # Aplicación principal

Agregar Nuevas Clases

# En hybrid_base_types.py
class HybridNewType(HybridCalcType):
    def __new__(cls, value_input):
        obj = HybridCalcType.__new__(cls)
        return obj
    
    def __init__(self, value_input):
        # Procesar entrada
        super().__init__(processed_value, original_str)
    
    def specialized_method(self):
        # Funcionalidad específica
        pass

Extender Parser

# En bracket_parser.py
class BracketParser:
    BRACKET_CLASSES = {'IP4', 'Hex', 'Bin', 'Date', 'Dec', 'Chr', 'NewType'}

Changelog

Versión 2.0 (CAS Híbrido)

✅ Motor SymPy completo como base
✅ Sintaxis con corchetes únicamente
✅ Detección automática de ecuaciones
✅ Variables SymPy puras
✅ Resultados interactivos clickeables
✅ Sistema de plotting integrado
✅ Arquitectura modular extensible

Diferencias vs Versión 1.0

Característica	v1.0	v2.0
Motor	Python eval/exec	SymPy completo
Sintaxis	`Class("args")`	`Class[args]`
Ecuaciones	`"x + 2 = 5"`	`x + 2 = 5` (automático)
Variables	Python mixto	SymPy puro
Resultados	Texto plano	Interactivos clickeables
Funciones	Básicas math	SymPy completo

FAQ

¿Puedo usar la sintaxis antigua?

No. La v2.0 usa exclusivamente sintaxis con corchetes para consistencia y simplicidad.

¿Cómo evalúo código Python tradicional?

Todas las operaciones se manejan con SymPy. Para casos especiales, se puede implementar sintaxis @eval: en futuras versiones.

¿Los resultados son exactos?

Sí. SymPy maneja aritmética exacta por defecto. Use .evalf() para aproximaciones decimales.

¿Puedo crear plots personalizados?

Sí. Los resultados de plot() son clickeables y abren matplotlib completo con opciones de personalización.

¿Cómo reportar bugs?

Ejecute python test_suite.py para diagnosticar problemas y reporte cualquier test que falle.

Calculadora MAV - CAS Híbrido v2.0
Desarrollado para cálculo matemático avanzado con soporte especializado

12 KiB Raw Blame History Unescape Escape