Binary coded decimal: Difference between revisions

Line 18:

The 6502 is a bit different in that it has a special operating mode where all addition and subtraction is handled as binary-coded decimal. Like the 68000, this must be invoked ahead of time, rather than using the Intel method of doing the math normally and then correcting it after the fact. (This special operating mode won't work on the aforementioned Ricoh 2A03, which performs math in "normal" mode even if the decimal flag is set.)

<~~lang~~ 6502asm>sed ;set decimal flag; now all math is BCD

<syntaxhighlight lang=6502asm>sed ;set decimal flag; now all math is BCD

lda #$19

clc

Line 46:

jsr PrintHex

jsr NewLine

rts ;return to basic</~~lang~~>

rts ;return to basic</syntaxhighlight>

<pre>20

Line 53:

=={{header|68000 Assembly}}==

The 68000 has special mathematics commands for binary-coded decimal. However, they only work at byte length, and cannot use immediate operands. Even adding by 1 this way requires you to load 1 into a register first.

<~~lang~~ 68000devpac> MOVEQ #$19,D0

<syntaxhighlight lang=68000devpac> MOVEQ #$19,D0

MOVEQ #1,D1

MOVEQ #0,D2

Line 77:

JSR PrintHex

jmp *</~~lang~~>

jmp *</syntaxhighlight>

<pre>20

Line 84:

=={{header|ALGOL 68}}==

Algol 68 does not have BCD as standard. This sample implements 2-digit unsigned packed decimal numbers, similar to the [[#PL/M|PL/M]] sample. The 2-digit numbers are then used to provide addition/subtraction of larger numbers.

<~~lang~~ algol68>BEGIN # implements packed BCD arithmetic #

<syntaxhighlight lang=algol68>BEGIN # implements packed BCD arithmetic #

INT x99 = ( 9 * 16 ) + 9; # maximum unsigned 2-digit BCD value #

# structure to hold BCD values #

Line 204:

OD

END</~~lang~~>

END</syntaxhighlight>

<pre>

Line 235:

=={{header|ALGOL W}}==

<~~lang~~ pascal>begin % implements packed BCD arithmetic %

<syntaxhighlight lang=pascal>begin % implements packed BCD arithmetic %

integer X99; % maximum unsigned 2-digit BCD value %

% structure to hold BCD values %

Line 370:

end

end.</~~lang~~>

end.</syntaxhighlight>

<pre>

Line 401:

=={{header|Forth}}==

This code implements direct BCD arithmetic using notes from Douglas Jones from the University of Iowa: https://homepage.cs.uiowa.edu/~jones/bcd/bcd.html#packed

<~~lang~~ Forth>

\ add two 15 digit bcd numbers

\

Line 419:

: bcd- bcdneg bcd+ ;

</syntaxhighlight>

</lang>

<pre>

Line 435:

Here, we represent hexadecimal numbers using J's constant notation, and to demonstrate bcd we generate results in that representation:

<~~lang~~ J> bcd=: &.((10 #. 16 #.inv ". ::]) :. ('16b',16 hfd@#. 10 #.inv ]))

<syntaxhighlight lang=J> bcd=: &.((10 #. 16 #.inv ". ::]) :. ('16b',16 hfd@#. 10 #.inv ]))

16b19 +bcd 1

16b20

Line 443:

16b100

(16b99 +bcd 1) -bcd 1

16b99</~~lang~~>

16b99</syntaxhighlight>

Note that we're actually using a hex representation as an intermediate result here. Technically, though, sticking with built in arithmetic and formatting as decimal, but gluing the '16b' prefix onto the formatted result would have been more efficient. And that says a lot about bcd representation. (The value of bcd is not efficiency, but how it handles edge cases. Consider the [https://en.wikipedia.org/wiki/IEEE_754#Decimal decimal IEEE 754] format as an example where this might be considered significant. There are other ways to achieve those edge cases -- bcd happens to be relevant when building the mechanisms into hardware.)

Line 449:

For reference, here are decimal and binary representations of the above numbers:

<~~lang~~ J> (":,_16{.' '-.~'2b',":@#:) 16b19

<syntaxhighlight lang=J> (":,_16{.' '-.~'2b',":@#:) 16b19

25 2b11001

(":,_16{.' '-.~'2b',":@#:) 16b20

Line 463:

2b11001

25

NB. ...</~~lang~~>

NB. ...</syntaxhighlight>

=={{header|Julia}}==

Handles negative and floating point numbers (but avoid BigFloats due to very long decimal places from binary to decimal conversion).

<~~lang~~ ruby>const nibs = [0b0, 0b1, 0b10, 0b11, 0b100, 0b101, 0b110, 0b111, 0b1000, 0b1001]

<syntaxhighlight lang=ruby>const nibs = [0b0, 0b1, 0b10, 0b11, 0b100, 0b101, 0b110, 0b111, 0b1000, 0b1001]

"""

Line 561:

println("BCD 99 ($(bcd_encode(99)[1])) + BCD 1 ($(bcd_encode(1))[1]) = BCD 100 " *

"($(bcd_encode(bcd_decode(bcd_encode(99)...) + bcd_decode(bcd_encode(1)...))))")

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

<pre>

1 encoded is (UInt8[0x01], 1), decoded is 1

Line 581:

==={{header|Free Pascal}}===

There exist a special unit for BCD, even with fractions.Obvious for Delphi compatibility.

<~~lang~~ pascal>program CheckBCD;

<syntaxhighlight lang=pascal>program CheckBCD;

// See https://wiki.freepascal.org/BcdUnit

{$IFDEF FPC} {$MODE objFPC}{$ELSE} {$APPTYPE CONSOLE} {$ENDIF}

Line 611:

BcdMultiply(Bcd0,Bcd0,BcdOut);

writeln(BcdToStr(Bcd0),'*',BcdToStr(Bcd0),' =',BcdToStr(BcdOut));

end.</~~lang~~>

end.</syntaxhighlight>

<pre>19+1 =20

Line 623:

The FPU maths is all as normal (decimal), it is only the load and store that convert from/to BCD.

While I supply everything in decimal, you could easily return and pass around the likes of acc and res.

without javascript_semantics -- (not a chance!)

requires("1.0.2") -- #ilASM{fbld, fbstp} added

Line 666:

test(30,-1)

test(99,+1)

<pre>

Line 678:

The aaa, aas, aam, and aad instructions are also available.

Same output as above, of course

without javascript_semantics -- (not a chance!)

requires("1.0.2") -- #ilASM{aaa, etc} added

Line 705:

test2(#30,'-')

test2(#99,'+')

=== hll bit fiddling ===

With routines to convert between decimal and bcd, same output as above, of course.

No attempt has been made to support fractions or negative numbers...

with javascript_semantics -- (no requires() needed here)

function bcd_decode(integer bcd)

Line 766:

test3(30,'-')

test3(99,'+')

=={{header|PL/M}}==

Line 772:

The 8080 PL/M compiler supports packed BCD by wrapping the 8080/Z80 DAA instruction with the DEC built in function, demonstrated here. Unfortunately, I couldn't get the first use of DEC to yeild the correct result without first doing a shift operation. Not sure if this is a bug in the program, the compiler or the 8080 emulator or that I'm misunderstanding something...

This is basically {{Trans|Z80 Assembly}}

<~~lang~~ pli>100H: /* DEMONSTRATE PL/M'S BCD HANDLING */

<syntaxhighlight lang=pli>100H: /* DEMONSTRATE PL/M'S BCD HANDLING */

BDOS: PROCEDURE( FN, ARG ); /* CP/M BDOS SYSTEM CALL */

Line 804:

CALL PR$BCD( B ); CALL PR$BCD( A ); CALL PR$NL;

EOF</~~lang~~>

EOF</syntaxhighlight>

<pre>

Line 813:

A more complex example, showing how the DEC function can be used to perform unsigned BCD addition and subtraction on arbitrary length BCD numbers.

<~~lang~~ pli>100H: /* DEMONSTRATE PL/M'S BCD HANDLING */

<syntaxhighlight lang=pli>100H: /* DEMONSTRATE PL/M'S BCD HANDLING */

BDOS: PROCEDURE( FN, ARG ); /* CP/M BDOS SYSTEM CALL */

Line 888:

EOF

</syntaxhighlight>

</lang>

<pre>

Line 915:

=={{header|Rust}}==

Based on the Forth implementation re: how to implement BCD arithmetic in software. Uses operator overloading for new BCD type.

<~~lang~~ Rust>

#[derive(Copy, Clone)]

pub struct Bcd64 {

Line 961:

assert_eq!((Bcd64{ bits: 0x99 } + one).bits, 0x100);

}

</syntaxhighlight>

</lang>

For the output, use "cargo test" to run the unit test for this module.

Line 983:

In what follows, the hex prefix '0x' is simply a way of representing BCD literals and has nothing to do with hexadecimal as such.

<~~lang~~ ecmascript>import "./check" for Check

<syntaxhighlight lang=ecmascript>import "./check" for Check

import "./math" for Int

import "./str" for Str

Line 1,061:

}

if (packed) System.print()

}</~~lang~~>

}</syntaxhighlight>

Line 1,077:

The <code>DAA</code> function will convert an 8-bit hexadecimal value to BCD after an addition or subtraction is performed. The algorithm used is actually quite complex, but the Z80's dedicated hardware for it makes it all happen in 4 clock cycles, tied with the fastest instructions the CPU can perform.

<~~lang~~ z80>

PrintChar equ &BB5A ;Amstrad CPC kernel's print routine

org &1000

Line 1,127:

add a,&F0

adc a,&40

jp PrintChar</~~lang~~>

jp PrintChar</syntaxhighlight>

<pre>20