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