Decimal codificado em binário

Um relógio binário pode usar LEDs para expressar valores binários. Neste relógio, cada coluna de LEDs mostra um numeral decimal codificado binário do tempo sexagesimal tradicional.

Em sistemas eletrônicos e de computação, decimal codificado em binário (BCD) é uma classe de codificações binárias de números decimais em que cada dígito é representado por um número fixo de bits, geralmente quatro ou oito. Às vezes, padrões de bits especiais são usados para um sinal ou outras indicações (por exemplo, erro ou estouro).

Em sistemas orientados a bytes (ou seja, a maioria dos computadores modernos), o termo unpacked BCD geralmente implica um byte completo para cada dígito (muitas vezes incluindo um sinal), enquanto packed BCD normalmente codifica dois dígitos em um único byte, aproveitando o fato de que quatro bits são suficientes para representar o intervalo de 0 a 9. A codificação precisa de 4 bits, no entanto, pode variar por razões técnicas (por exemplo, Excess-3).

Os dez estados que representam um dígito BCD às vezes são chamados de tetrades (pois o nibble normalmente necessário para mantê-los é também conhecido como tétrade) enquanto os estados não usados, não importam, são denominados pseudo-tetrad(e)s [de], pseudodecimais ou dígitos pseudodecimais.

A principal virtude do BCD, em comparação com os sistemas posicionais binários, é sua representação mais precisa e arredondamento de quantidades decimais, bem como sua facilidade de conversão em representações convencionais legíveis por humanos. Suas principais desvantagens são um ligeiro aumento na complexidade dos circuitos necessários para implementar a aritmética básica, bem como um armazenamento ligeiramente menos denso.

O BCD foi usado em muitos dos primeiros computadores decimais e é implementado no conjunto de instruções de máquinas como a série IBM System/360 e seus descendentes, o VAX da Digital Equipment Corporation, o Burroughs B1700 e o Motorola 68000 -série processadores. BCD per se não é tão amplamente usado quanto no passado e está indisponível ou limitado em conjuntos de instruções mais recentes (por exemplo, ARM; x86 no modo longo). No entanto, os formatos de ponto fixo decimal e ponto flutuante decimal ainda são importantes e continuam a ser usados em computação financeira, comercial e industrial, onde a conversão sutil e os erros de arredondamento fracionário inerentes aos formatos binários de ponto flutuante não podem ser tolerados.

Fundo

O BCD aproveita o fato de que qualquer numeral decimal pode ser representado por um padrão de quatro bits. A maneira mais óbvia de codificar dígitos é Natural BCD (NBCD), onde cada dígito decimal é representado por seu valor binário de quatro bits correspondente, conforme mostrado na tabela a seguir. Isso também é chamado de "8421" codificação.

Este regime também pode ser referido como Simples Decimal Binary-Coded (SBCD) ou BCD 8421, e é a codificação mais comum. Outros incluem a chamada codificação "4221" e "7421" - nomeada após a ponderação usada para os bits - e "Excess-3". Por exemplo, o dígito BCD 6, 0110'b em 8421 notação, é 1100'b em 4221 (duas codificações são possíveis), 0110'b em 7421, enquanto em Excess-3 é 1001'b (6+3= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =9- Sim.).

A tabela a seguir representa dígitos decimais de 0 a 9 em vários sistemas de codificação BCD. Nos cabeçalhos, o "8 4 2 1" indica o peso de cada bit. Na quinta coluna ("BCD 8 4 −2 −1"), dois dos pesos são negativos. Os códigos de caracteres ASCII e EBCDIC para os dígitos, que são exemplos de BCD zonado, também são mostrados.

Como a maioria dos computadores lida com dados em bytes de 8 bits, é possível usar um dos seguintes métodos para codificar um número BCD:

• Desempacotado: Cada dígito decimal é codificado em um byte, com quatro bits representando o número e os bits restantes não tendo nenhum significado.
• Embalado: Dois dígitos decimais são codificados em um único byte, com um dígito no nibble menos significativo (bits 0 a 3) e o outro numeral no nibble mais significativo (bits 4 a 7).

Como exemplo, codificar o número decimal 91 usando BCD desempacotado resulta no seguinte padrão binário de dois bytes:

Decimal: 9 1
Binário: 0000 1001 0000 0001

No BCD compactado, o mesmo número caberia em um único byte:

Decimal: 9 1
Binário: 1001 0001

Portanto, o intervalo numérico para um byte BCD não compactado é de zero a nove, inclusive, enquanto o intervalo para um byte BCD compactado é de zero a noventa e nove, inclusive.

Para representar números maiores que o intervalo de um único byte, qualquer número de bytes contíguos pode ser usado. Por exemplo, para representar o número decimal 12345 em BCD compactado, usando o formato big-endian, um programa codificaria da seguinte forma:

Decimal: 0 1 2 3 4 5
Binário: 0000 0001 0010 0011 0100 0101

Aqui, o nibble mais significativo do byte mais significativo foi codificado como zero, então o número é armazenado como 012345 (mas as rotinas de formatação podem substituir ou remover zeros). O BCD compactado é mais eficiente no uso de armazenamento do que o BCD descompactado; codificar o mesmo número (com o zero à esquerda) no formato descompactado consumiria o dobro do armazenamento.

As operações de deslocamento e mascaramento são usadas para compactar ou descompactar um dígito BCD compactado. Outras operações bit a bit são usadas para converter um numeral em seu padrão de bit equivalente ou reverter o processo.

BCD compactado

Em BCD compactado (ou simplesmente decimal compactado), cada um dos dois nibbles de cada byte representa um dígito decimal. O BCD compactado está em uso desde pelo menos a década de 1960 e é implementado em todos os hardwares de mainframe IBM desde então. A maioria das implementações são big endian, ou seja, com o dígito mais significativo na metade superior de cada byte e com o byte mais à esquerda (residindo no endereço de memória mais baixo) contendo os dígitos mais significativos do valor decimal compactado. O nibble inferior do byte mais à direita geralmente é usado como sinalizador de sinal, embora algumas representações não assinadas não tenham um sinalizador de sinal. Como exemplo, um valor de 4 bytes consiste em 8 nibbles, em que os 7 nibbles superiores armazenam os dígitos de um valor decimal de 7 dígitos e o nibble mais baixo indica o sinal do valor inteiro decimal.

Os valores de sinal padrão são 1100 (hex C) para positivo (+) e 1101 (D) para negativo (-). Essa convenção vem do campo de zona para caracteres EBCDIC e a representação de overpunch assinada. Outros sinais permitidos são 1010 (A) e 1110 (E) para positivo e 1011 (B) para negativo. Os processadores IBM System/360 usarão os sinais 1010 (A) e 1011 (B) se o bit A estiver definido no PSW, para o padrão ASCII-8 que nunca passou. A maioria das implementações também fornece valores BCD sem sinal com um nibble de sinal de 1111 (F). ILE RPG usa 1111 (F) para positivo e 1101 (D) para negativo. Estes correspondem à zona EBCDIC para dígitos sem um overpunch de sinal. No BCD compactado, o número 127 é representado por 0001 0010 0111 1100 (127C) e -127 é representado por 0001 0010 0111 1101 (127D). Os sistemas Burroughs usaram 1101 (D) para negativo e qualquer outro valor é considerado um valor de sinal positivo (os processadores normalizarão um sinal positivo para 1100 (C)).

Não importa quantos bytes uma palavra tenha, sempre haverá um número par de nibbles porque cada byte tem dois deles. Portanto, uma palavra de n bytes pode conter até (2n)−1 dígitos decimais, que é sempre um número ímpar de dígitos. Um número decimal com d dígitos requer 1/2(d+1) bytes de espaço de armazenamento.

Por exemplo, uma palavra de 4 bytes (32 bits) pode conter sete dígitos decimais mais um sinal e pode representar valores que variam de ±9.999.999. Assim, o número -1.234.567 tem 7 dígitos de largura e é codificado como:

0001 0010 0011 0100 0101 0110 0111 1101
1 2 3 4 5 6 7 −

Como as strings de caracteres, o primeiro byte do decimal compactado – aquele com os dois dígitos mais significativos – geralmente é armazenado no endereço mais baixo da memória, independentemente do fim da máquina.

Em contraste, um inteiro de complemento de dois binário de 4 bytes pode representar valores de -2.147.483.648 a +2.147.483.647.

Embora o BCD compactado não faça uso otimizado do armazenamento (usando cerca de 20% mais memória do que a notação binária para armazenar os mesmos números), a conversão para ASCII, EBCDIC ou as várias codificações de Unicode é trivial, pois não há operações aritméticas é requerido. Os requisitos extras de armazenamento geralmente são compensados pela necessidade de precisão e compatibilidade com calculadora ou cálculo manual que a aritmética decimal de ponto fixo fornece. Existem embalagens mais densas de BCD que evitam a penalidade de armazenamento e também não precisam de operações aritméticas para conversões comuns.

O BCD compactado é suportado na linguagem de programação COBOL como o "COMPUTATIONAL-3" (uma extensão IBM adotada por muitos outros fornecedores de compiladores) ou "PACKED-DECIMAL" (parte do padrão COBOL de 1985). É suportado em PL/I como "FIXO DECIMAL". Ao lado do IBM System/360 e mainframes compatíveis posteriores, o BCD compactado é implementado no conjunto de instruções nativas dos processadores VAX originais da Digital Equipment Corporation e alguns modelos dos mainframes da série SDS Sigma, e é o formato nativo para os Burroughs Corporation Medium Systems linha de mainframes (descendente da série Electrodata 200 dos anos 1950).

As representações em complemento de dez para números negativos oferecem uma abordagem alternativa para codificar o sinal de números BCD compactados (e outros). Nesse caso, os números positivos sempre têm um dígito mais significativo entre 0 e 4 (inclusive), enquanto os números negativos são representados pelo complemento de 10's do número positivo correspondente. Como resultado, este sistema permite que os números BCD compactados de 32 bits variem de -50.000.000 a +49.999.999, e -1 é representado como 99999999. (Tal como acontece com os números binários em complemento de dois, o intervalo não é simétrico em relação a zero.)

Decimal compactado de ponto fixo

Números decimais de ponto fixo são suportados por algumas linguagens de programação (como COBOL e PL/I). Essas linguagens permitem que o programador especifique um ponto decimal implícito na frente de um dos dígitos. Por exemplo, um valor decimal compactado codificado com os bytes 12 34 56 7C representa o valor de ponto fixo +1.234,567 quando o ponto decimal implícito está localizado entre o quarto e o quinto dígitos:

12 34 56 7C
12 34.56 7+

O ponto decimal não é realmente armazenado na memória, pois o formato de armazenamento BCD compactado não fornece isso. Sua localização é simplesmente conhecida pelo compilador e o código gerado age de acordo com as várias operações aritméticas.

Codificações de maior densidade

Se um dígito decimal requer quatro bits, então três dígitos decimais requerem 12 bits. No entanto, como 2¹⁰ (1.024) é maior que 10³ (1.000), se três dígitos decimais forem codificados juntos, apenas 10 bits serão necessários. Duas dessas codificações são a codificação Chen–Ho e a decimal densamente compactada (DPD). O último tem a vantagem de que os subconjuntos da codificação codificam dois dígitos nos sete bits ideais e um dígito em quatro bits, como no BCD regular.

Decimal zonado

Algumas implementações, por exemplo, sistemas de mainframe IBM, suportam representações numéricas decimais por zonas. Cada dígito decimal é armazenado em um byte, com os quatro bits inferiores codificando o dígito no formato BCD. Os quatro bits superiores, chamados de "zona" bits, geralmente são definidos para um valor fixo para que o byte contenha um valor de caractere correspondente ao dígito. Os sistemas EBCDIC usam um valor de zona de 1111 (hex F); isso produz bytes no intervalo F0 a F9 (hex), que são os códigos EBCDIC para os caracteres "0" até "9". Da mesma forma, os sistemas ASCII usam um valor de zona de 0011 (hex 3), fornecendo códigos de caracteres de 30 a 39 (hex).

Para valores decimais zonados com sinal, o nibble de zona mais à direita (menos significativo) contém o dígito de sinal, que é o mesmo conjunto de valores usado para números decimais compactados com sinal (veja acima). Assim, um valor decimal zonado codificado como os bytes hexadecimais F1 F2 D3 representa o valor decimal com sinal −123:

F1 F2 D3
1 2 −3

Tabela de conversão decimal zonada EBCDIC

(*) Observação: Esses caracteres variam dependendo da configuração da página de código de caracteres local.

Decimal zonado de ponto fixo

Algumas linguagens (como COBOL e PL/I) suportam diretamente valores decimais com zona de ponto fixo, atribuindo um ponto decimal implícito em algum local entre os dígitos decimais de um número. Por exemplo, dado um valor decimal zonado com sinal de seis bytes com um ponto decimal implícito à direita do quarto dígito, os bytes hexadecimais F1 F2 F7 F9 F5 C0 representam o valor +1.279,50:

F1 F2 F7 F9 F5 C0
1 2 7 9. 5 +0

BCD em computadores

IBM

A IBM usou os termos Binary-Coded Decimal Interchange Code (BCDIC, às vezes chamado apenas de BCD), para códigos alfanuméricos de 6 bits que representavam números, letras maiúsculas e caracteres especiais. Algumas variações de BCDIC alphamerics são usadas na maioria dos primeiros computadores IBM, incluindo o IBM 1620 (introduzido em 1959), série IBM 1400 e membros não-Decimal Architecture da série IBM 700/7000.

A série IBM 1400 são máquinas endereçáveis por caracteres, cada local sendo seis bits rotulados B, A, 8, 4, 2 e 1, mais uma verificação de paridade ímpar bit (C) e um bit de marca de palavra (M). Para codificar dígitos 1 a 9, B e A são zero e o valor do dígito representado pelo padrão de 4 bits BCD em bits 8 a 1. Para a maioria dos outros caracteres, os bits B e A são derivados simplesmente de "12", "11" e " 0" "socos de zona" no código de caractere do cartão perfurado e bits 8 a 1 dos perfuradores 1 a 9. Uma "zona 12" conjunto de perfurações B e A, uma "11 zona" definir B, e uma "zona 0" (um soco 0 combinado com qualquer outro) defina A. Assim, a letra A, que é (12,1) no formato de cartão perfurado, é codificada como (B,A,1). O símbolo da moeda $, (11,8,3) no cartão perfurado, foi codificado na memória como (B,8,2,1). Isso permite que o circuito converta entre o formato de cartão perfurado e o formato de armazenamento interno para ser muito simples, com apenas alguns casos especiais. Um caso especial importante é o dígito 0, representado por um único ponto 0 no cartão e (8,2) na memória principal.

A memória do IBM 1620 é organizada em dígitos endereçáveis de 6 bits, o usual 8, 4, 2, 1 mais F, usado como um bit de sinalização e C, um bit de verificação de paridade ímpar. Os alfaméricos BCD são codificados usando pares de dígitos, com a "zona" no dígito de endereço par e o "dígito" no dígito de endereço ímpar, a "zona" estando relacionado com os "socos de zona" como na série 1400. Hardware de conversão de entrada/saída convertido entre os pares de dígitos internos e os códigos BCD de 6 bits padrão externo.

Na arquitetura decimal, IBM 7070, IBM 7072 e IBM 7074 alphamerics são codificados usando pares de dígitos (usando código de dois em cinco nos dígitos, não BCD) da palavra de 10 dígitos, com a "zona" no dígito esquerdo e o "dígito" no dígito certo. Hardware de conversão de entrada/saída convertido entre os pares de dígitos internos e os códigos BCD de 6 bits padrão externo.

Com a introdução do System/360, a IBM expandiu alphamerics BCD de 6 bits para EBCDIC de 8 bits, permitindo a adição de muito mais caracteres (por exemplo, letras minúsculas). Um tipo de dados Packed BCD numeric de comprimento variável também é implementado, fornecendo instruções de máquina que executam aritmética diretamente em dados decimais compactados.

No IBM 1130 e 1800, o BCD compactado é suportado no software pelo pacote de sub-rotinas comerciais da IBM.

Atualmente, os dados BCD ainda são muito usados em processadores e bancos de dados IBM, como IBM Db2, mainframes e Power6. Nesses produtos, o BCD geralmente é BCD zonado (como em EBCDIC ou ASCII), BCD compactado (dois dígitos decimais por byte) ou "puro" Codificação BCD (um dígito decimal armazenado como BCD nos quatro bits inferiores de cada byte). Todos eles são usados em registradores de hardware e unidades de processamento e em software. Para converter decimais compactados em descarregamentos de tabela EBCDIC em números legíveis, você pode usar a máscara OUTREC FIELDS do utilitário JCL DFSORT.

Outros computadores

A série VAX-11 da Digital Equipment Corporation inclui instruções que podem executar aritmética diretamente em dados BCD compactados e converter entre dados BCD compactados e outras representações inteiras. O formato BCD compactado do VAX é compatível com o IBM System/360 e os processadores compatíveis posteriores da IBM. As implementações MicroVAX e VAX posteriores eliminaram essa capacidade da CPU, mas mantiveram a compatibilidade de código com máquinas anteriores implementando as instruções ausentes em uma biblioteca de software fornecida pelo sistema operacional. Isso é invocado automaticamente por meio do tratamento de exceções quando as instruções extintas são encontradas, para que os programas que as usam possam ser executados sem modificação nas máquinas mais novas.

A arquitetura Intel x86 oferece suporte a um formato BCD exclusivo de 18 dígitos (dez bytes) que pode ser carregado e armazenado nos registros de ponto flutuante, de onde os cálculos podem ser executados.

A série Motorola 68000 tinha instruções BCD.

Em computadores mais recentes, esses recursos são quase sempre implementados em software, e não no conjunto de instruções da CPU, mas os dados numéricos BCD ainda são extremamente comuns em aplicativos comerciais e financeiros. Existem truques para implementar BCD compactado e operações de adição ou subtração decimais usando sequências curtas, mas difíceis de entender, de lógica paralela de palavras e operações aritméticas binárias. Por exemplo, o código a seguir (escrito em C) calcula uma adição BCD compactada de 8 dígitos sem sinal usando operações binárias de 32 bits:

Não sei. A.C.(Não sei. um, Não sei. b))( Não sei. ), T2; // valores intermediários não assinados de 32 bits ) = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = um + 0x066666; T2 = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ) ^ b); // soma sem transte propagação ) = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ) + b); // soma provisória T2 = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ) ^ T2; // todos os bits de transporte binário T2 = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ~T2 > 0x111110; // apenas o BCD carrega bits T2 = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = (T2 > 2) | (T2 > 3); // correcção retorno ) - Não. T2; // soma de BCD corrigida?

BCD em eletrônica

O BCD é muito comum em sistemas eletrônicos onde um valor numérico deve ser exibido, especialmente em sistemas que consistem apenas em lógica digital e não contêm um microprocessador. Ao empregar BCD, a manipulação de dados numéricos para exibição pode ser bastante simplificada, tratando cada dígito como um único subcircuito separado. Isso corresponde muito mais à realidade física do hardware de exibição - um designer pode optar por usar uma série de exibições de sete segmentos idênticas separadas para construir um circuito de medição, por exemplo. Se a quantidade numérica fosse armazenada e manipulada como binário puro, a interface com tal exibição exigiria circuitos complexos. Portanto, nos casos em que os cálculos são relativamente simples, trabalhar com o BCD pode levar a um sistema geral mais simples do que converter de e para binário. A maioria das calculadoras de bolso faz todos os seus cálculos em BCD.

O mesmo argumento se aplica quando o hardware desse tipo usa um microcontrolador embutido ou outro processador pequeno. Freqüentemente, representar números internamente no formato BCD resulta em código menor, já que uma conversão de ou para representação binária pode ser cara em tais processadores limitados. Para essas aplicações, alguns processadores pequenos apresentam modos aritméticos dedicados, que auxiliam na escrita de rotinas que manipulam quantidades BCD.

Operações com BCD

Adição

É possível realizar a adição adicionando primeiro em binário e depois convertendo para BCD. A conversão da soma simples de dois dígitos pode ser feita adicionando 6 (ou seja, 16 − 10) quando o resultado de cinco bits da adição de um par de dígitos tiver um valor maior que 9. A razão para adicionar 6 é que existem 16 possíveis valores BCD de 4 bits (desde 2⁴ = 16), mas apenas 10 valores são válidos (0000 a 1001). Por exemplo:

1001 + 1000 = 10001
9 + 8 = 17

10001 é a representação binária, não decimal, do resultado desejado, mas o 1 mais significativo (o "carry") não cabe em um número binário de 4 bits. Tanto em BCD quanto em decimal, não pode existir valor maior que 9 (1001) por dígito. Para corrigir isso, 6 (0110) é adicionado ao total e o resultado é tratado como dois nibbles:

10001 + 0110 = 00010111 => 0001 0111
17 + 6 = 23 1 7

Os dois nibbles do resultado, 0001 e 0111, correspondem aos dígitos "1" e "7". Isso produz "17" em BCD, que é o resultado correto.

Esta técnica pode ser estendida para adicionar vários dígitos adicionando grupos da direita para a esquerda, propagando o segundo dígito como um carry, sempre comparando o resultado de 5 bits de cada soma de par de dígitos com 9. Algumas CPUs fornecem meio -carry sinalizador para facilitar os ajustes aritméticos BCD após operações binárias de adição e subtração. O Intel 8080, o Zilog Z80 e as CPUs da família x86 fornecem o opcode DAA (Decimal Adjust Accumulator).

Subtração

A subtração é feita adicionando o complemento de dez do subtraendo ao minuendo. Para representar o sinal de um número em BCD, o número 0000 é usado para representar um número positivo e 1001 é usado para representar um número negativo. As 14 combinações restantes são sinais inválidos. Para ilustrar a subtração BCD com sinal, considere o seguinte problema: 357 − 432.

Em BCD com sinal, 357 é 0000 0011 0101 0111. O complemento de dez de 432 pode ser obtido tomando o complemento de nove de 432 e adicionando um. Portanto, 999 − 432 = 567 e 567 + 1 = 568. Precedendo 568 em BCD pelo código de sinal negativo, o número −432 pode ser representado. Portanto, -432 em BCD com sinal é 1001 0101 0110 1000.

Agora que ambos os números estão representados em BCD com sinal, eles podem ser somados:

 0000 0011 0101 0111
0 3 5 7
+ 1001 0101 0110 1000
 9 5 6 8= 1001 1000 1011 1111
9 8 11 15

Como BCD é uma forma de representação decimal, várias das somas de dígitos acima são inválidas. Caso exista uma entrada inválida (qualquer dígito BCD maior que 1001), 6 é adicionado para gerar um bit de transporte e fazer com que a soma se torne uma entrada válida. Portanto, adicionar 6 às entradas inválidas resulta no seguinte:

 1001 1000 1011 1111
9 8 11 15
+ 0000 0000 0110 0110
 0 0= 1001 1001 0010 0101
9 9 2 5 2 9 9 9 9 9 2 2 9 9 9 9 2 9 9 9 9 9 9 9 2 2 9 9 9 9 9 2 9 9 9 9 9 9 9 9 9 9 2 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 2 9 9 9 9 9 9 9 9 2 9 9 9 9 9 9 9 9 9 9 9 9 2 9 9 9 2 9 9 9 9 2 9 9 9 9 9 9 9 9 2 9 9 9 9 9 9 9 9 9 9 9 9 2 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 2 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 2 9 2 9 9 9 9 9 2 9 9 9 9 2 9 2 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 2 9 9 9 9 9 9 9 9 9 9 9 9 2 2 2 9 9 9 9 9 9 2 9 2 9 2 2 2 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9

Assim, o resultado da subtração é 1001 1001 0010 0101 (−925). Para confirmar o resultado, observe que o primeiro dígito é 9, que significa negativo. Isso parece estar correto, pois 357 − 432 deve resultar em um número negativo. Os nibbles restantes são BCD, então 1001 0010 0101 é 925. O complemento de dez de 925 é 1000 − 925 = 75, então a resposta calculada é −75.

Se houver um número diferente de nibbles sendo somados (como 1053 − 2), o número com menos dígitos deve primeiro ser prefixado com zeros antes de tomar o complemento de dez ou subtrair. Assim, com 1053 − 2, 2 teria que primeiro ser representado como 0002 em BCD, e o complemento de dez de 0002 teria que ser calculado.

Comparação com binário puro

Vantagens

• Muitos valores não integrais, como o decimal 0.2, têm uma representação infinita de valor de lugar em binário (.001100110011...) mas têm um valor de lugar finito em decimal codificado binário (0.0010). Consequentemente, um sistema baseado em representações decimais codificadas por binários de frações decimais evita erros representando e calculando tais valores. Isso é útil em cálculos financeiros.
• Falar por um poder de 10 é simples.
• Arredondamento em um limite de dígitos decimais é mais simples. A adição e subtração no decimal não exigem arredondamento.
• O alinhamento de dois números decimais (por exemplo 1.3 + 27.08) é uma mudança simples e exata.
• A conversão para um formulário de caracteres ou para exibição (por exemplo, para um formato baseado em texto, como XML, ou para gerar sinais para um display de sete segmentos) é um mapeamento simples por dígito, e pode ser feito em linear (O(n) tempo. Conversão de binário puro envolve lógica relativamente complexa que abrange dígitos, e para grandes números, nenhum algoritmo de conversão de tempo linear é conhecido (ver Sistema numeral binário § Conversão para e de outros sistemas numerais).

Desvantagens

• Algumas operações são mais complexas para implementar. Os adeptos exigem uma lógica extra para fazer com que eles envolvam e gerem um transporte mais cedo. 15 a 20 por cento mais circuitos é necessário para BCD adicionar em comparação com binário puro. Multiplicação requer o uso de algoritmos que são um pouco mais complexos do que mudança-mask-add (uma multiplicação binária, exigindo turnos binários e adições ou o equivalente, por dígito ou grupo de dígitos é necessário).
• BCD padrão requer quatro bits por dígito, aproximadamente 20 por cento mais espaço do que uma codificação binária (a relação de 4 bits para logar₂10 bits é 1.204). Quando embalado para que três dígitos sejam codificados em dez bits, a sobrecarga de armazenamento é muito reduzida, à custa de uma codificação que não é vinculada com os limites byte de 8 bits comuns no hardware existente, resultando em implementações mais lentas nesses sistemas.
• As implementações práticas existentes do BCD são tipicamente mais lentas do que as operações em representações binárias, especialmente em sistemas embarcados, devido ao suporte limitado do processador para operações BCD nativas.

Variações de representação

Existem várias implementações de BCD que empregam outras representações para números. As calculadoras programáveis fabricadas pela Texas Instruments, Hewlett-Packard e outras geralmente empregam um formato BCD de ponto flutuante, geralmente com dois ou três dígitos para o expoente (decimal). Os bits extras do dígito de sinal podem ser usados para indicar valores numéricos especiais, como infinito, subfluxo/estouro e erro (um display piscando).

Variações assinadas

Os valores decimais com sinal podem ser representados de várias maneiras. A linguagem de programação COBOL, por exemplo, suporta cinco formatos decimais zonados, cada um codificando o sinal numérico de uma maneira diferente:

Telefonia decimal codificado em binário (TBCD)

3GPP desenvolveu TBCD, uma expansão para BCD onde as combinações de bits restantes (não utilizadas) são usadas para adicionar caracteres de telefonia específicos, com dígitos semelhantes aos encontrados no design original dos teclados de telefone.

O documento 3GPP mencionado define TBCD-STRING com nibbles trocados em cada byte. Bits, octetos e dígitos indexados a partir de 1, bits à direita, dígitos e octetos à esquerda.

bits 8765 de octet n dígito de codificação 2n

bits 4321 de octet n dígito de codificação 2(n – 1) + 1

Significando o número 1234, se tornaria 21 43 em TBCD.

Codificações alternativas

Se os erros na representação e na computação forem mais importantes do que a velocidade de conversão de e para a exibição, uma representação binária em escala pode ser usada, que armazena um número decimal como um inteiro codificado em binário e um expoente decimal com sinal codificado em binário. Por exemplo, 0,2 pode ser representado como 2×10^-1.

Esta representação permite multiplicação e divisão rápidas, mas pode requerer deslocamento por uma potência de 10 durante a adição e subtração para alinhar os pontos decimais. É apropriado para aplicativos com um número fixo de casas decimais que não requerem esse ajuste - especialmente aplicativos financeiros em que 2 ou 4 dígitos após o ponto decimal geralmente são suficientes. Na verdade, isso é quase uma forma de aritmética de ponto fixo, uma vez que a posição do ponto de base está implícita.

As codificações Hertz e Chen–Ho fornecem transformações booleanas para converter grupos de três dígitos codificados em BCD de e para valores de 10 bits que podem ser codificados com eficiência em hardware com apenas atrasos de 2 ou 3 portas. Decimal densamente compactado (DPD) é um esquema semelhante usado para a maior parte do significando, exceto o dígito inicial, para uma das duas codificações decimais alternativas especificadas no padrão de ponto flutuante IEEE 754-2008.

Aplicativo

O BIOS em muitos computadores pessoais armazena a data e a hora em BCD porque o chip de relógio em tempo real MC6818 usado na placa-mãe original do IBM PC AT forneceu a hora codificada em BCD. Este formulário é facilmente convertido em ASCII para exibição.

A família de computadores Atari de 8 bits usava o BCD para implementar algoritmos de ponto flutuante. O processador MOS 6502 possui um modo BCD que afeta as instruções de adição e subtração. O software fornecido pelo fabricante do computador de mão Psion Organizer 1 também usou inteiramente o BCD para implementar o ponto flutuante; modelos Psion posteriores usaram exclusivamente binário.

Os primeiros modelos do PlayStation 3 armazenavam a data e a hora em BCD. Isso levou a uma interrupção mundial do console em 1º de março de 2010. Os dois últimos dígitos do ano armazenados como BCD foram mal interpretados como 16, causando um erro na data da unidade, tornando a maioria das funções inoperáveis. Isso tem sido referido como o problema do ano de 2010.

História jurídica

No caso de 1972 Gottschalk v. Benson, a Suprema Corte dos Estados Unidos anulou a decisão de um tribunal inferior que permitia uma patente para converter números codificados em BCD para binários em um computador. A decisão observou que uma patente "prevaleceria totalmente a fórmula matemática e, na prática, seria uma patente do próprio algoritmo". Este foi um julgamento histórico que determinou a patenteabilidade de software e algoritmos.