ForHosting KIT · Ferramentas para dev

Calculadora adição saturada de inteiros

Some dois inteiros e mantenha o total dentro de uma largura de bits fixa: 100 + 50 numa palavra de 8 bits com sinal dá 127 em vez de dar a volta para um negativo, e a soma exata, 150, aparece ao lado. Grátis no seu navegador.

Grátis
Funciona no seu navegador
Sem cadastro
Seus dados não saem do seu aparelho

Executar grátis Ver a API

Use pelo WebAPIE-mailTelegramApp em breve

Exemplo resolvido

Se você digitar

A: 100
B: 50
Bits: 8

Você obtém

Resultado: 127
Min: -128
Max: 127
Soma exata: 150

A adição inteira saturada limita a soma matemática de dois inteiros aos valores extremos que ainda cabem em uma palavra de largura fixa escolhida, em vez de dar a volta como faz a aritmética modular e a maioria dos tipos inteiros de máquina. Engenheiros que verificam núcleos DSP, fórmulas de dano em jogos, canais de cor e contadores de segurança precisam desse comportamento de limitação com mínimo e máximo exatos e um indicador saturado inequívoco. Estudantes que comparam o estouro por wrapping com a saturação precisam de um oráculo determinístico que nunca invente um resultado modular. Esta calculadora de adição saturada de inteiros aceita as parcelas a e b, uma largura de bits de dois a sessenta e quatro e um indicador opcional de sinal, e devolve o resultado limitado, a soma exata sem limite, o intervalo representável e se ocorreu saturação por overflow ou underflow.

O que a adição saturada significa frente ao overflow por wrapping

A adição inteira comum de largura fixa é modular: quando a soma verdadeira sai do intervalo representável, o resultado da máquina se envolve reduzindo a soma módulo dois elevado à largura, o que pode saltar de um valor positivo grande para um negativo grande ou de pouco abaixo de zero para um positivo grande.

A adição saturada adota outra política preferida por muitos conjuntos de instruções DSP, codecs de mídia e contadores de segurança crítica: se a soma verdadeira for maior que o máximo representável, o resultado torna-se esse máximo; se for menor que o mínimo, o resultado torna-se esse mínimo; caso contrário o resultado é igual à soma verdadeira. Não ocorre wrapping modular.

Para uma largura com sinal de w bits o intervalo fechado vai de menos dois elevado a w menos um até dois elevado a w menos um, menos um — o intervalo clássico em complemento de dois de int8, int16 e int32. Para largura sem sinal w o intervalo vai de zero até dois elevado a w menos um.

Esta calculadora implementa exatamente essa limitação: forma a soma inteira exata de a e b com aritmética BigInt, compara com min e max da largura e da assinatura escolhidas e emite o resultado limitado junto com um booleano saturated e um campo direction com none, overflow ou underflow, para que quem chama possa registrar ou ramificar sem recalcular os limites por conta própria.

Onde a adição saturada é útil

Desenvolvedores embarcados e de DSP usam adição saturada para espelhar o comportamento no estilo ARM QADD, estágios de pipeline de mídia e acumuladores de ponto fixo sem levantar um emulador completo para uma única verificação aritmética. Ferramentas de cor e áudio frequentemente saturam somas de canal ou de amostra em oito ou dezesseis bits ao pré-visualizar modos de mistura antes de comprometer código de shader.

Educadores que ensinam a representação computacional de inteiros precisam de um contraste lado a lado entre wrapping modular e saturação com números reproduzíveis de int8 a int64. Validação com falha não consome saldo. Mantenha as requisições pequenas, fixe result e saturated nos testes e obtenha limitações reproduzíveis para dever de casa, oráculos de CI e workers de borda sem reinventar tabelas de aritmética de largura fixa.

Casos de uso

Verificações de firmware DSP e ponto fixo

Verifique a adição saturada contra limites int8/int16/int32 ao modelar núcleos no estilo QADD ou acumuladores de ponto fixo sem um emulador completo.

Limites de recursos em jogos e simulações

Limite somas de vida, dano ou pontuação a uma largura de bits escolhida para que o overflow sature no máximo em vez de envolver para um valor negativo.

Perguntas frequentes

Como a adição saturada de inteiros difere do overflow normal?

A adição de largura fixa normal se envolve (aritmética modular). A adição saturada limita a soma verdadeira ao mínimo ou máximo representável da largura e do sinal escolhidos, e nunca se envolve.

O que significam saturated e direction?

saturated é true quando o resultado foi limitado. direction é overflow quando a soma excedeu max, underflow quando ficou abaixo de min, e none quando não foi preciso limitar.

a ou b podem ficar fora do intervalo da palavra?

Sim. Os operandos podem ser quaisquer inteiros seguros; só a soma é limitada ao min/max da palavra. Isso combina com o uso comum de calculadoras e ensino ao explorar entradas fora do intervalo.

Quais larguras de bits são aceitas?

Qualquer largura de 2 a 64 bits. Por padrão a palavra tem sinal, como de −128 a 127 em 8 bits; sem sinal, o intervalo começa em zero e vai até dois elevado à largura, menos um.

Por que limitar em vez de deixar a soma dar a volta?

Porque um resultado que dá a volta pode saltar de um valor positivo grande para um negativo grande, uma surpresa ruim em áudio, canais de cor ou contadores de segurança. Limitar segura o resultado no extremo mais próximo, como fazem muitos conjuntos de instruções de DSP e codecs de mídia.

Ferramentas relacionadas

Para desenvolvedores — acesso via API

Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.

Endpoint

POSThttps://api.kit.forhosting.com/dev/saturating-add

Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.

Chame do seu código

curl -X POST https://api.kit.forhosting.com/dev/saturating-add \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"a":100,"b":50,"bits":8}'

const res = await fetch("https://api.kit.forhosting.com/dev/saturating-add", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "a": 100,
    "b": 50,
    "bits": 8
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/saturating-add",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "a": 100,
    "b": 50,
    "bits": 8
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/saturating-add", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"a":100,"b":50,"bits":8}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"a":100,"b":50,"bits":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/saturating-add", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Exemplo de requisição

{
  "a": 100,
  "b": 50,
  "bits": 8
}

Exemplo de resposta

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.saturating_add",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.

Preço

por chamadaUS$ 0,002

Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.

Erros

HTTP	Código	O que significa
`401`	`unauthorized`	Token ausente ou inválido. Confira o header Authorization.
`402`	`insufficient_balance`	Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo.
`404`	`unknown_type`	Esse tipo de tarefa não existe. Confira o campo type no catálogo.
`429`	`rate_limited`	Muitas requisições em pouco tempo. Espere um instante e tente de novo.

Notas técnicas

Contrato de entrada, formato da resposta e comportamento de erro

O campo opcional signed tem padrão true para uma palavra com sinal em complemento de dois; defina signed como false para um intervalo sem sinal que começa em zero. Cadeias no estilo booleano como true, false, yes, no, signed e unsigned são aceitas por conveniência. Combine a resposta com seus próprios testes unitários que fixem os caminhos saturado e não saturado para que regressões na lógica de limitação não entrem em um modelo de firmware ou em uma planilha de balanceamento de jogo. Envie por POST um corpo JSON com os campos obrigatórios a e b como inteiros finitos (números JSON ou cadeias de dígitos com sinal inicial opcional) cujo valor absoluto permaneça dentro de Number.MAX_SAFE_INTEGER, e bits como inteiro de dois a sessenta e quatro. Campos ausentes, não inteiros, bits fora de dois a sessenta e quatro e valores não booleanos de signed falham com invalid_input indicando o problema; essas falhas não são cobradas. Em caso de sucesso o corpo ecoa a, b, bits e signed; informa min e max da palavra; informa sum_exact como a soma matemática sem limite; informa result como o valor limitado; define saturated como true quando houve limitação; e define direction como none, overflow ou underflow. Valores que excedem os inteiros seguros de JavaScript nos extremos do intervalo ou na soma exata são emitidos como cadeias decimais para que o JSON permaneça exato. Exemplo: a igual a cem, b igual a cinquenta, bits igual a oito, signed true produz min menos cento e vinte e oito, max cento e vinte e sete, sum_exact cento e cinquenta, result cento e vinte e sete, saturated true e direction overflow — o caso clássico de adição saturada int8.

Onde uma API de adição saturada de inteiros se paga

Autores de jogos e simulações limitam soma de vida, dano e contadores de recursos para que o overflow nunca envolva uma barra quase cheia em um valor negativo ou quase zero; uma calculadora pública e uma API tornam essas regras de limitação revisáveis na documentação de projeto. Como a implementação é parse de nível A puro, cada chamada bem-sucedida custa o preço base publicado US$ 0,002 sem tokens de modelo e sem rede de saída.

Casos de integração

Demonstrações em sala: overflow versus saturação

Mostre aos alunos a diferença entre wrapping modular e limitação saturada com min, max, sum_exact e result determinísticos para qualquer largura 2–64.

Perguntas técnicas

Quais larguras de bits e modos com sinal são suportados?

bits deve ser um inteiro de 2 a 64. signed tem padrão true (intervalo em complemento de dois). Defina signed false para o intervalo sem sinal [0, 2^bits−1].

Quanto custa a calculadora de adição saturada de inteiros?

A ferramenta no navegador é gratuita. Pedidos API usam saldo KIT pré-pago a US$ 0,002 por chamada bem-sucedida; entrada inválida não é cobrada.

Ver a documentação completa do KIT →

Executar grátis