Manual de instrucciones de Calculas

1

Qué es Calculas

Calculas es una herramienta educativa de cálculo simbólico. Su objetivo es permitir que un estudiante escriba expresiones matemáticas y obtenga resultados exactos, pasos de exploración, gráficos simples y salidas con una presentación clara.

La idea general se parece a un cuaderno de trabajo: escribís una entrada, la ejecutás, aparece una salida y luego podés seguir trabajando en una nueva celda. El estilo está inspirado en los cuadernos tipo Jupyter, pero integrado visualmente al sitio de Pizarrón Verde.

Qué significa CAS

CAS significa Computer Algebra System, es decir, sistema de álgebra computacional. A diferencia de una calculadora común, un CAS puede trabajar con expresiones simbólicas. Por ejemplo, puede transformar $x^2 - 5x + 6$ en $(x - 2)(x - 3)$, derivar $\sin(x^2)$ o resolver una ecuación cuadrática.

En esta etapa, Calculas usa SymPy, una biblioteca de Python especializada en matemática simbólica. Como todavía estamos en una versión local de transición, Python corre dentro del navegador gracias a Pyodide. Más adelante, el mismo enfoque puede migrarse a un backend Python en la nube.

2

Cómo abrir Calculas

Para usar Calculas localmente, abrí el archivo:

calculas/index.html

Al ingresar, vas a ver la página de Calculas con una zona de cuaderno y un mensaje de estado que indica que se está cargando el motor Python + SymPy.

Primera carga

La primera vez puede tardar algunos segundos, porque el navegador necesita descargar Pyodide y SymPy. Durante ese momento conviene esperar a que aparezca un mensaje indicando que el motor ya está listo.

Si abrís la página sin conexión a Internet, es posible que Calculas no cargue el motor. En ese caso, la interfaz puede aparecer, pero no podrá ejecutar los cálculos simbólicos.

3

Tu primer cálculo

Cuando Calculas termine de cargar, escribí en la primera celda:

2 + 3*4

Luego presioná el botón Ejecutar de la celda, o usá el atajo Ctrl + Enter. La salida debería ser:

La multiplicación se escribe con asterisco. Es decir, en esta versión conviene escribir 3*x en lugar de 3x. Más adelante se podrá mejorar el parser para aceptar multiplicación implícita, pero por ahora es mejor escribir las operaciones de forma explícita.

Correcto:
3*x + 2
2*(x + 1)
sin(x)

Evitar por ahora:
3x + 2
2(x + 1)
sen(x)

4

Cómo usar las celdas

Calculas trabaja con celdas. Cada celda tiene una entrada y una salida. En la entrada escribís una operación, una definición o un comando. Al ejecutar la celda, Calculas muestra el resultado debajo.

Al principio aparece una sola celda. Cuando ejecutás la última celda con contenido, Calculas crea automáticamente una celda nueva debajo. Esto permite escribir una secuencia de trabajo ordenada, como si fuera una hoja de cálculo simbólico.

Acción	Qué hace
Ejecutar una celda	Calcula la entrada y muestra la salida.
Volver a una celda anterior	Permite editarla y ejecutarla nuevamente.
Ejecutar todo	Reinicia el entorno y ejecuta las celdas de arriba hacia abajo.
Limpiar salidas	Borra las salidas visibles, pero conserva las entradas.
Reiniciar cuaderno	Vuelve a dejar una celda inicial y reinicia el entorno.

Es importante recordar que el orden de las celdas importa. Si una celda usa una variable definida arriba, esa definición debe haber sido ejecutada antes.

5

Sintaxis básica

Calculas usa una sintaxis parecida a Python y SymPy. Para que el usuario principiante pueda arrancar sin confundirse, conviene tener presentes estas reglas:

Operación	Cómo se escribe	Ejemplo
Suma	`+`	`2 + 5`
Resta	`-`	`7 - 3`
Multiplicación	`*`	`3*x`
División	`/`	`(x + 1)/(x - 1)`
Potencia	`^` o `**`	`x^2`
Raíz cuadrada	`sqrt(...)`	`sqrt(50)`
Seno	`sin(...)`	`sin(pi/2)`
Coseno	`cos(...)`	`cos(pi)`
Logaritmo natural	`log(...)`	`log(E)`

Los símbolos x, y, z, t y n ya están disponibles como variables simbólicas. También están disponibles constantes como pi, E, I y oo.

pi
E
I
oo
sin(pi/2)
exp(1)

6

Aritmética y resultados exactos

SymPy intenta conservar resultados exactos siempre que sea posible. Por ejemplo:

sqrt(50)

puede devolver una forma simplificada exacta, como $5\sqrt{2}$.

Para fracciones exactas, es recomendable usar Rational:

Rational(1, 3) + Rational(1, 6)

Esto devuelve $\frac{1}{2}$ en lugar de una aproximación decimal.

Si querés una aproximación decimal, podés usar N(...) o sp.N(...) cuando esté disponible en el entorno:

sp.N(sqrt(2))
sp.N(pi, 20)

7

Variables y respuesta anterior

Podés definir variables asignando valores con el signo igual:

a = 5
b = 2
a + b

También podés definir expresiones simbólicas:

p = x^2 - 5*x + 6
factor(p)

La respuesta anterior se puede reutilizar con ans. Por ejemplo:

expand((x + 1)^2)
factor(ans)

Consejo

Usá nombres claros para tus objetos matemáticos. Por ejemplo: polinomio, expr, A, B, f. Evitá redefinir símbolos básicos como x si todavía los vas a usar como variables simbólicas.

8

Funciones definidas por el usuario

Una de las formas más útiles de trabajar es definir funciones. En Calculas podés escribir:

f(x) = x^2 + 2*x + 1

Luego podés evaluarla:

f(3)

También podés derivarla o integrarla:

diff(f(x), x)
integrate(f(x), x)

También se pueden definir funciones de más de una variable:

g(x, y) = x^2 + y^2
g(3, 4)

Este tipo de definición es especialmente útil para preparar contenidos de cálculo de una variable, cálculo multivariable, álgebra y física.

9

Álgebra simbólica

Calculas permite hacer operaciones algebraicas básicas y algunas más avanzadas usando SymPy.

Comando	Uso	Ejemplo
`expand`	Desarrolla productos y potencias.	`expand((x+2)*(x-3))`
`factor`	Factoriza expresiones.	`factor(x^2 - 5*x + 6)`
`simplify`	Simplifica expresiones.	`simplify((x^2 - 1)/(x - 1))`
`cancel`	Cancela factores comunes en expresiones racionales.	`cancel((x^2 - 1)/(x - 1))`
`together`	Une fracciones en una sola.	`together(1/x + 1/(x+1))`
`apart`	Descompone en fracciones parciales.	`apart(1/(x^2 - 1), x)`
`collect`	Agrupa términos según una variable.	`collect(x^2 + ax + 2x, x)`

Ejemplo guiado

Supongamos que querés estudiar el polinomio $x^2 - 5x + 6$.

p = x^2 - 5*x + 6
factor(p)
solve(p, x)

Primero lo guardás con el nombre p, luego lo factorizás, y finalmente buscás sus raíces.

10

Resolver ecuaciones

Para resolver ecuaciones se usa solve. En algunos casos podés escribir directamente una expresión igualada a cero:

solve(x^2 - 5*x + 6, x)

Eso busca los valores de x que hacen que la expresión sea igual a cero.

También podés escribir una ecuación explícita:

solve(x^2 = 9, x)

Calculas intenta transformar ese signo igual en una ecuación de SymPy.

Otra forma, más cercana a SymPy, es usar Eq:

solve(Eq(x^2, 9), x)

Sistemas de ecuaciones

Para sistemas sencillos, se puede usar una lista de ecuaciones:

solve([x + y - 5, x - y - 1], [x, y])

La salida dará los valores de las variables que satisfacen el sistema.

11

Derivadas, integrales, límites y series

Calculas permite trabajar con comandos fundamentales de cálculo.

Derivadas

diff(x^3 + 2*x^2 - 5*x + 1, x)
diff(sin(x^2), x)
diff(exp(3*x), x)

Integrales indefinidas

integrate(x^2 + 1, x)
integrate(sin(x), x)
integrate(exp(3*x), x)

Integrales definidas

integrate(x^2, (x, 0, 1))
integrate(sin(x), (x, 0, pi))

Límites

limit(sin(x)/x, x, 0)
limit((1 + 1/x)^x, x, oo)
limit(1/x, x, 0, dir='+')

Series

series(exp(x), x, 0, 6)
series(sin(x), x, 0, 7)

Idea pedagógica

Una buena forma de usar Calculas para estudiar es comparar una cuenta hecha a mano con el resultado de SymPy. Por ejemplo, primero derivá $x^3 + 2x^2$ en papel y luego verificá con diff(x^3 + 2*x^2, x).

12

Matrices

Para crear matrices, se usa Matrix. Las filas se escriben como listas dentro de una lista principal.

A = Matrix([[1, 2], [3, 4]])
A

Con una matriz definida, podés calcular:

A.det()
A.inv()
A.T
A.rref()
A.eigenvals()

También podés operar con matrices:

B = Matrix([[0, 1], [1, 0]])
A + B
A*B

Atención

La sintaxis de matrices es sensible a corchetes y comas. Si falta un corchete o una coma, aparecerá un error de sintaxis.

13

Gráficos simples

Calculas incluye un comando básico de gráficos:

plot(expresion, variable, minimo, maximo)

Por ejemplo:

plot(x^2 - 4, x, -5, 5)
plot(sin(x), x, -6.28, 6.28)
plot(exp(-x^2), x, -3, 3)

El motor interpreta la expresión usando SymPy y luego JavaScript dibuja los puntos en la página. Es un graficador pensado para exploración rápida.

Si una función tiene asíntotas o discontinuidades, puede convenir graficar por partes:

plot(1/x, x, -5, -0.2)
plot(1/x, x, 0.2, 5)

14

Guardar y cargar el cuaderno

El botón Guardar localmente guarda las entradas de las celdas en el navegador mediante localStorage. Esto no crea un archivo descargable y tampoco sube información a Internet.

El botón Cargar guardado recupera las entradas guardadas. Después de cargar, conviene usar Ejecutar todo para volver a reconstruir el estado matemático del cuaderno.

Qué se guarda

Se guardan principalmente las entradas de las celdas. Las salidas se pueden regenerar ejecutando el cuaderno. Esta estrategia evita guardar resultados desactualizados.

15

Errores frecuentes y cómo resolverlos

Problema	Causa probable	Solución
El motor no carga	No hay conexión o el CDN está bloqueado.	Verificar conexión a Internet y recargar la página.
Error de sintaxis	Faltan paréntesis, corchetes o comas.	Revisar la expresión con cuidado.
`3x` no funciona	Falta el signo de multiplicación.	Escribir `3*x`.
`sen(x)` no funciona	El comando esperado es en inglés.	Usar `sin(x)`.
Una variable no existe	No fue definida o no se ejecutó la celda anterior.	Ejecutar la celda donde se define, o usar Ejecutar todo.
Una celda anterior cambió pero las posteriores no	Las salidas posteriores no se recalculan automáticamente.	Ejecutar nuevamente las celdas siguientes.

En general, cuando algo no funciona, conviene simplificar la entrada y probar por partes. Por ejemplo, antes de resolver una expresión muy larga, verificá que cada parte se escriba correctamente.

16

Práctica guiada para empezar

La siguiente secuencia sirve para probar las principales capacidades actuales de Calculas.

Bloque 1: álgebra básica

p = x^2 - 5*x + 6
factor(p)
expand((x - 2)*(x - 3))
solve(p, x)

Bloque 2: funciones

f(x) = x^2 + 2*x + 1
f(3)
diff(f(x), x)
integrate(f(x), x)

Bloque 3: límites

limit(sin(x)/x, x, 0)
limit((1 + 1/x)^x, x, oo)

Bloque 4: matrices

A = Matrix([[1, 2], [3, 4]])
A.det()
A.inv()

Bloque 5: gráficos

plot(x^2 - 4, x, -5, 5)
plot(sin(x), x, -6.28, 6.28)

Al terminar, probá volver a una celda anterior, modificarla y ejecutarla otra vez. Esa es una de las ventajas principales del formato de cuaderno.

17

Limitaciones actuales

Esta versión ya representa un avance importante porque usa SymPy, pero todavía es una versión de transición. Por ahora conviene tener presentes estas limitaciones:

Necesita conexión a Internet para cargar Pyodide y SymPy desde CDN.
El cálculo corre dentro del navegador, por lo que puede ser más lento que un backend Python dedicado.
El parser todavía no acepta todas las formas naturales de escritura matemática.
Conviene escribir multiplicaciones explícitas, por ejemplo 3*x en lugar de 3x.
Los comandos están principalmente en inglés, siguiendo la convención de SymPy.
El graficador es básico y está pensado para exploración inicial.
Todavía no hay usuarios, sesiones en la nube, exportación avanzada ni archivos de proyecto.
No está pensado para ejecutar Python general del usuario, sino comandos matemáticos controlados.

La dirección futura más recomendable es mantener esta versión local con Pyodide para desarrollo y pruebas, y más adelante migrar el motor a un backend Python + SymPy en la nube.

Abrir Calculas