toRustCalcMCP

Un puerto en Rust de calc (la calculadora de precisión arbitraria de Landon Curt Noll)

GitHubPrueba este MCPPatrocinado

Documentación

toRustCalcMCP

License Rust Crates.io

Un port a Rust de calc (la calculadora de precisión arbitraria de Landon Curt Noll) que funciona como:

  • rcalc — una calculadora de línea de comandos compatible con calc
  • REPL web — calculadora interactiva basada en navegador
  • Servidor MCP — JSON-RPC 2.0 sobre stdio para integración con LLM/agentes

Tres interfaces, un mismo motor. El núcleo numérico usa aritmética racional exacta (num-rational sobre num-bigint), que es el mismo modelo que calc usa de forma nativa, por lo que 1/3 * 3 es exactamente 1, y 2^256 se calcula hasta el último dígito.

👉 Primeros pasos en 2 minutos — ¿nuevo en rcalc? Empieza aquí. 👉 Instalar como MCP de Claude Desktop — intégralo con Claude Desktop.

Compilación

cargo build --release
# binaries:
#   target/release/toRustCalcMCP   (auto-detects MCP vs CLI)
#   target/release/rcalc           (always the CLI)

Opcionalmente, crea un enlace simbólico: ln -s toRustCalcMCP rcalc — cuando argv[0] es rcalc, toRustCalcMCP se comporta como la calculadora.

Uso de CLI (rcalc)

rcalc '2^100'                 # 1267650600228229401496703205376
rcalc '1/3 + 1/6'            # 0.5
rcalc -m frac '1/3 + 1/6'    # 1/2
rcalc 'gcd(462,1071)'        # 21
rcalc 'fact(30)'            # 265252859812191058636308480000000
rcalc 'sqrt(2)'             # 1.4142135623730950488
rcalc 'isprime(1000003)' 'nextprime(1000003)'   # 1 \n 1000033
echo '3*4' | rcalc -p        # pipe mode
rcalc                        # interactive REPL (Ctrl-D to exit)

Banderas: -p modo tubería, -q silencioso, -m real|frac|int, -v versión, -h ayuda. Varias banderas clásicas de calc (-c -C -d -e -i -O -s -u) se aceptan e ignoran.

Uso del REPL web

cargo build --release
./target/release/rcalc-web
# Open browser: http://localhost:8888

Un REPL moderno basado en navegador con:

  • Evaluación interactiva de expresiones
  • Historial de comandos (flechas ↑/↓)
  • Salida con resaltado de sintaxis
  • Funcionalidad completa de calc (483 nombres integrados)
  • Diseño adaptable para móvil/escritorio

Pruébalo: abre http://localhost:8888 e introduce 2^256 o sin(pi()/6).

Uso de MCP

toRustCalcMCP --mcp     # speak JSON-RPC 2.0 over stdio

Protocolo de inicio → initialize, luego tools/list, luego tools/call. Consulta docs/MCP_TOOL_SCHEMA.json para el esquema autoritativo emitido por el servidor y examples/mcp-config.json para un fragmento de registro de cliente.

Herramientas

herramientapropósitoargumentos clave
calc_evalevaluar una expresiónexpression (obligatorio), mode, digits, epsilon
calc_configobtener/establecer precisión y visualización de la sesiónaction (get/set), mode, digits, epsilon
calc_functionslistar funciones integradasfilter (subcadena opcional)

Los mode/digits/epsilon de calc_eval son anulaciones por llamada; calc_config set los cambia para la sesión.

Lenguaje soportado

  • Operadores: + - * / (exacto), // (división entera), % (módulo), ^/** (potencia), comparaciones == != < <= > >= (producen 1/0), unarios -/+.
  • Variables y asignación: x = 7; x^2.
  • Funciones definidas por el usuario: define f(x) = x^2; f(5) → 25.
  • Flujo de control: if/else, while, bucles for, bloques con {}.
  • Sentencias separadas por ;; el valor de cada una se imprime (comportamiento de calc).
  • Literales numéricos: enteros, racionales a/b, decimales, 1.2e-3, 0x/0b.
  • Listas: list(1,2,3); append(x,4); slice(x,1,3).
  • Números complejos: sqrt(-1) → i; aritmética con +, -, *, /.
  • Literales de cadena: "hello"; strlen(s); index(haystack, needle).
  • 483 nombres integrados (paridad completa con los 350 de calc, menos 15 internos documentados del intérprete, más extensiones) — consulta el estado de implementación más abajo.

Modelo de precisión

Los números son racionales exactos. Los resultados irracionales se aproximan dentro de la epsilon de la sesión (por defecto exacto 1/10^20), igual que calc. Las funciones trascendentes (exp, ln, sin, cos, tan) se calculan con precisión arbitraria mediante series de Taylor y el método de Newton. sqrt, sin, cos, etc. convergen hasta que el término < épsilon. pi/e son constantes de 60 dígitos. Un ~ inicial en la salida en modo real marca una representación inexacta (redondeada/no terminante), como en calc.

Estado de implementación — paridad completa con upstream ✅

El upstream de calc (lcn2/calc func.c) define 350 funciones integradas. Este port registra 483 nombres integrados que cubren 335 de los 350 integrados de upstream (los otros 148 que faltaban desde hace tiempo se añadieron en los lotes de paridad con upstream que se indican más abajo), además de docenas de extensiones y alias más allá de upstream (estadística, hashing, trucos de bits, información del sistema, y más).

Intencionalmente no implementados (15 internos del intérprete)

Estos nombres de upstream son artefactos del intérprete C de calc y no tienen un mapeo significativo a la arquitectura de este port; permanecen sin implementar en lugar de enviar stubs falsos:

access, calc_tty, calclevel, calcpath, custom, dp, estr, inputlevel, memsize, name, param, prompt, protect, saveval, stoponerror

Desviaciones conocidas respecto a upstream

  • Las funciones integradas con parámetros de salida devuelven valores en su lugar: d2dm/d2dms (y la familia g/h) devuelven listas de [deg, min] / [deg, min, sec]; quomod devuelve [q, r]; search/rsearch devuelven un índice o null.
  • Las funciones integradas in-place/lvalue devuelven nuevos valores: modify, copy, swap (las funciones integradas reciben valores, no referencias).
  • base2() se lee como 0 (sin base secundaria); establecerlo da error — el renderizador tiene una única base de salida.
  • free*() son no-ops: no se almacena nada en caché, los valores se calculan bajo demanda.

Características completas del lenguaje

  • ✅ Funciones definidas por el usuario (define name(params) = expr), funciones integradas de orden superior (select/forall/modify llaman a valores de función)
  • ✅ Flujo de control (if/else, while, bucles for)
  • ✅ Variables y ámbito
  • ✅ Listas e indexación (basada en 0, con soporte de índices negativos)
  • ✅ Números complejos con aritmética completa
  • ✅ Literales de cadena y un conjunto completo de funciones de cadena
  • ✅ Conversión de base (2-36, entrada y salida)
  • ✅ Aritmética de precisión arbitraria (racionales exactos; épsilon exacto de 1/10^20)
  • ✅ Carga de archivos (-f filename), funciones integradas de E/S de archivos, REPL, modo tubería

Alcance — Arquitectura y diseño

El upstream de calc tiene ~92,000 líneas de C con ~350 funciones integradas y un lenguaje de scripting completo y Turing-completo. Este port es un núcleo fiel, estructurado para una expansión incremental y aditiva:

  • ✅ Motor numérico de racionales exactos — coincide con el modelo nativo de calc
  • ✅ Lexer/parser completo — maneja la sintaxis completa de expresiones
  • ✅ Evaluador por recorrido de árbol — con funciones definidas por el usuario, flujo de control, ámbito
  • ✅ Registro de funciones integradas — mapa de funciones extensible con catalogación automática
  • ✅ CLI y servidor MCP — dos interfaces, un motor
  • 🔄 Funciones integradas incrementales — cada categoría encaja limpiamente sin rehacer trabajo

La arquitectura es estable; añadir más funciones es sencillo.

Licencia

LGPL-2.1, coincidiendo con el upstream de calc.

Flujo de trabajo de CI de pruebas