toRustCalcMCP

Um port em Rust da calculadora calc (calculadora de precisão arbitrária de Landon Curt Noll)

Documentação

toRustCalcMCP

Um port em Rust de calc (a calculadora de precisão arbitrária de Landon Curt Noll) que funciona como:

rcalc — uma calculadora de linha de comando compatível com calc
Web REPL — calculadora interativa baseada no navegador
servidor MCP — JSON-RPC 2.0 via stdio para integração com LLM/agentes

Três interfaces, um mesmo motor. O núcleo numérico usa aritmética racional exata (num-rational sobre num-bigint), que é o mesmo modelo que o calc usa nativamente — portanto, 1/3 * 3 é exatamente 1, e 2^256 é calculado até o último dígito.

👉 Comece em 2 minutos — novo no rcalc? Comece por aqui. 👉 Instale como MCP do Claude Desktop — integre com o Claude Desktop.

Build (compilação)

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

Opcionalmente, crie um symlink: ln -s toRustCalcMCP rcalc — quando argv[0] é rcalc, toRustCalcMCP se comporta como a calculadora.

Uso via 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)

Flags: -p modo pipe, -q silencioso, -m real|frac|int, -v versão, -h ajuda. Várias flags clássicas do calc (-c -C -d -e -i -O -s -u) são aceitas e ignoradas.

Uso do Web REPL

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

Um REPL moderno baseado em navegador com:

Avaliação interativa de expressões
Histórico de comandos (setas ↑/↓)
Saída com realce de sintaxe
Funcionalidade completa do calc (483 nomes de builtins)
Design responsivo para celular/desktop

Experimente: abra http://localhost:8888 e digite 2^256 ou sin(pi()/6).

Uso via MCP

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

Handshake → initialize, depois tools/list, depois tools/call. Consulte docs/MCP_TOOL_SCHEMA.json para o esquema autoritativo emitido pelo servidor e examples/mcp-config.json para um trecho de registro do cliente.

Ferramentas

ferramenta	finalidade	argumentos-chave
`calc_eval`	avaliar uma expressão	`expression` (obrigatório), `mode`, `digits`, `epsilon`
`calc_config`	obter/definir precisão e exibição da sessão	`action` (`get`/`set`), `mode`, `digits`, `epsilon`
`calc_functions`	listar builtins	`filter` (substring opcional)

Os mode/digits/epsilon de calc_eval são substituições por chamada; calc_config set os altera para toda a sessão.

Linguagem suportada

Operadores: + - * / (exato), // (divisão inteira), % (módulo), ^/** (potência), comparações == != < <= > >= (produzem 1/0), unário -/+.
Variáveis e atribuição: x = 7; x^2.
Funções definidas pelo usuário: define f(x) = x^2; f(5) → 25.
Fluxo de controle: if/else, while, loops for, blocos com {}.
Instruções separadas por ;; o valor de cada uma é impresso (comportamento do calc).
Literais numéricos: inteiros, racionais a/b, decimais, 1.2e-3, 0x/0b.
Listas: list(1,2,3); append(x,4); slice(x,1,3).
Números complexos: sqrt(-1) → i; aritmética com +, -, *, /.
Literais de string: "hello"; strlen(s); index(haystack, needle).
483 nomes de builtins (paridade total com os 350 do calc, menos 15 internals documentados do interpretador, mais extensões) — veja o status de implementação abaixo.

Modelo de precisão

Os números são racionais exatos. Resultados irracionais são aproximados dentro do epsilon da sessão (padrão exato 1/10^20), exatamente como no calc. Transcendentais (exp, ln, sin, cos, tan) são calculados em precisão arbitrária via séries de Taylor e método de Newton. sqrt, sin, cos, etc. convergem até termo < epsilon. pi/e são constantes de 60 dígitos. Um ~ inicial na saída do modo real marca uma renderização inexata (arredondada/não terminante), como no calc.

Status de implementação — paridade total com o upstream ✅

O upstream do calc (lcn2/calc func.c) define 350 builtins. Este port registra 483 nomes de builtins cobrindo 335 dos 350 builtins do upstream (os outros 148 que estavam ausentes há muito tempo foram adicionados nos lotes de paridade com o upstream abaixo), além de dezenas de extensões e aliases adicionais (estatística, hashing, truques de bits, informações do sistema e mais).

Intencionalmente não implementados (15 internals do interpretador)

Esses nomes do upstream são artefatos do interpretador C do calc e não têm mapeamento significativo para a arquitetura deste port; eles permanecem não implementados em vez de fornecer stubs falsos:

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

Desvios conhecidos do upstream

Builtins com parâmetro de saída retornam valores: d2dm/d2dms (e a família g/h) retornam listas [deg, min] / [deg, min, sec]; quomod retorna [q, r]; search/rsearch retornam um índice ou null.
Builtins in-place/lvalue retornam novos valores: modify, copy, swap (os builtins recebem valores, não referências).
base2() lê como 0 (sem base secundária); defini-lo gera erro — o renderizador tem uma única base de saída.
free*() são no-ops: nada é armazenado em cache, os valores são calculados sob demanda.

Recursos completos da linguagem

✅ Funções definidas pelo usuário (define name(params) = expr), builtins de ordem superior (select/forall/modify chamam valores de função)
✅ Fluxo de controle (if/else, while, loops for)
✅ Variáveis e escopo
✅ Listas e indexação (base 0, índices negativos suportados)
✅ Números complexos com aritmética completa
✅ Literais de string e um conjunto completo de funções de string
✅ Conversão de base (2-36, entrada e saída)
✅ Aritmética de precisão arbitrária (racionais exatos; epsilon exato 1/10^20)
✅ Carregamento de arquivos (-f filename), builtins de I/O de arquivo, REPL, modo pipe

Escopo — Arquitetura e Design

O upstream do calc tem ~92.000 linhas de C, com ~350 builtins e uma linguagem de script completa e Turing-completa. Este port é um núcleo fiel, estruturado para expansão incremental e aditiva:

✅ Motor numérico de racionais exatos — corresponde ao modelo nativo do calc
✅ Lexer/parser completo — trata toda a sintaxe de expressões
✅ Avaliador por percurso de árvore — com funções definidas pelo usuário, fluxo de controle, escopo
✅ Registro de builtins — mapa de funções extensível com autocatálogo
✅ CLI e servidor MCP — dois front-ends, um motor
🔄 Builtins incrementais — cada categoria se encaixa sem retrabalho

A arquitetura é estável; adicionar mais funções é direto.

Licença

LGPL-2.1, correspondente ao upstream do calc.

toRustCalcMCP

Documentação

toRustCalcMCP

Build (compilação)

Uso via CLI (rcalc)

Uso do Web REPL

Uso via MCP

Ferramentas

Linguagem suportada

Modelo de precisão

Status de implementação — paridade total com o upstream ✅

Intencionalmente não implementados (15 internals do interpretador)

Desvios conhecidos do upstream

Recursos completos da linguagem

Escopo — Arquitetura e Design

Licença

Fluxo de trabalho de CI de teste

Uso via CLI (`rcalc`)