469 lines
12 KiB
Markdown
469 lines
12 KiB
Markdown
# 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
|
||
```bash
|
||
python launcher.py --setup
|
||
```
|
||
|
||
### Método 2: Instalación Manual
|
||
```bash
|
||
# 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)
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```bash
|
||
# Error: ModuleNotFoundError: No module named 'sympy'
|
||
pip install sympy matplotlib numpy
|
||
|
||
# Linux: tkinter no disponible
|
||
sudo apt-get install python3-tk
|
||
```
|
||
|
||
#### Errores de Sintaxis
|
||
```python
|
||
# Incorrecto: sintaxis antigua
|
||
IP4("192.168.1.1/24")
|
||
|
||
# Correcto: nueva sintaxis
|
||
IP4[192.168.1.1/24]
|
||
```
|
||
|
||
#### Problemas de Variables
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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
|
||
```python
|
||
# 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* |