Four bit adder: Difference between revisions

{{task}} [[Category:Electronics]]

 

 

 

 

{|

|+Schematics of the "constructive blocks"

|-

|[[File:xor.png|frameless|Xor gate done with ands, ors and nots]]

|[[File:4bitsadder.png|frameless|A 4-bit adder]]

|}

 

Solutions should try to be as descriptive as possible, making it as easy as possible to identify "connections" between higher-order "blocks".

It is not mandatory to replicate the syntax of higher-order blocks in the atomic "gate" blocks, i.e. basic "gate" operations can be performed as usual bitwise operations, or they can be "wrapped" in a ''block'' in order to expose the same syntax of higher-order blocks, at implementers' choice.

 

To test the implementation, show the sum of two four-bit numbers (in binary).

<div style="clear:both"></div>

 

=={{header|Ada}}==

type Four_Bits is array (1..4) of Boolean;

Full_Adder (A (1), B (1), C (1), Carry);

end Four_Bits_Adder;

A test program with the above definitions

with Ada.Text_IO; use Ada.Text_IO;

 

end loop;

end Test_4_Bit_Adder;

{{out}}

<div style="height: 320px;overflow:scroll">

</pre>

</div>

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

B := 9

N := FourBitAdd(A, B)

Res := Mod(N, 2) Res, N := N >> 1

return, Res

{{out}}

<pre>13 + 9:

=={{header|AutoIt}}==

===Functions===

Func _NOT($_A)

Return (Not $_A) *1

Return $Q4 & $Q3 & $Q2 & $Q1

EndFunc ;==>_4BitAdder

===Example===

Local $CarryOut, $sResult

$sResult = _4BitAdder(0, 0, 1, 1, 0, 1, 1, 1, 0, $CarryOut) ; adds 3 + 7

$sResult = _4BitAdder(1, 0, 1, 1, 1, 0, 0, 0, 0, $CarryOut) ; adds 11 + 8

ConsoleWrite('result: ' & $sResult & ' ==> carry out: ' & $CarryOut & @LF)

{{out}}

<pre>

--[[User:BugFix|BugFix]] ([[User talk:BugFix|talk]]) 17:10, 14 November 2013 (UTC)

 

{{works with|BBC BASIC for Windows}}

PRINT "1100 + 1100 = ";

PROC4bitadd(1,1,0,0, 1,1,0,0, e,d,c,b,a) : PRINT e,d,c,b,a

c& = a& AND NOT b&

d& = b& AND NOT a&

{{out}}

<pre>

1101 + 0010 = 0 1 1 1 1

1101 + 0011 = 1 0 0 0 0

</pre>

 

=={{header|C}}==

 

typedef char pin_t;

return 0;

 

=={{header|C sharp|C#}}==

 

{{works with|C sharp|C#|3+}}

using System;

using System.Collections.Generic;

}

 

=={{header|Clojure}}==

(ns rosettacode.adder

(:use clojure.test))

(n-bit-adder [true true true true true true] [true true true true true true])

=> (false true true true true true true)

 

===Second Clojure solution===

 

;; a bit is represented as a boolean (true/false)

)

 

 

=={{header|CoffeeScript}}==

This code models gates as functions. The connection of gates is done via custom logic, which doesn't involve any cheating, but a really good solution would be more constructive, i.e. it would show more of a notion of "connecting" up gates, using some kind of graph data structure.

 

# ATOMIC GATES

not_gate = (bit) ->

adder = n_bit_adder(4)

console.log adder [1, 0, 1, 0], [0, 1, 1, 0]

 

=={{header|D}}==

From the C version. An example of SWAR (SIMD Within A Register) code, that performs 32 (or 64) 4-bit adds in parallel.

 

void fourBitsAdder(T)(in T a0, in T a1, in T a2, in T a3,

writefln(" s0 %032b", s0);

writefln("overflow %032b", overflow);

{{out}}

<pre> a3 00000000000000000000000000000000

overflow 11111111111111111111111111111111</pre>

128 4-bit adds in parallel:

 

void fourBitsAdder(T)(in T a0, in T a1, in T a2, in T a3,

writefln(" s0 %(%08b%)", s0.array);

writefln("overflow %(%08b%)", overflow.array);

{{out}}

<pre> a3 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

overflow 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111</pre>

Compiled by the ldc2 compiler to (where T = ubyte32, 256 adds using AVX2):

pushl %ebp

movl %esp, %ebp

popl %ebp

vzeroupper

 

=={{header|Erlang}}==

Yes, it is misleading to have a "choose your own number of bits" adder in the four_bit_adder module. But it does make it easier to find the module from the Rosettacode task name.

-module( four_bit_adder ).

 

%% xor exists, this is another implementation.

z_xor( A, B ) -> (A band (2+bnot B)) bor ((2+bnot A) band B).

{{out}}

<pre>

28> four_bit_adder:task().

{[0,1,0,1],0}

</pre>

 

=={{header|Forth}}==

: "XOR" over over "NOT" and >r swap "NOT" and r> or ;

: halfadder over over and >r "XOR" r> ;

;

 

{{out}}

<pre>1 1 0 0 0 0 1 1 .add4 01111

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

 

end do

end do

{{out}} (selected)

<pre>1100 + 1100 = 11000

1101 + 0010 = 01111

1101 + 0011 = 10000</pre>

 

=={{header|Go}}==

Go does not have a bit type, so byte is used.

This is the straightforward solution using bytes and functions.

 

import "fmt"

// add 10+9 result should be 1 0 0 1 1

fmt.Println(add4(1, 0, 1, 0, 1, 0, 0, 1))

{{out}}

<pre>

===Channels===

Alternative solution is a little more like a simulation.

 

import "fmt"

B[<-r4], B[<-r3], B[<-r2], B[<-r1], B[<-carry])

}

 

Mini reference:

* "<tt><-channel</tt>" reads a value from a channel. Blocks if its buffer is empty.

* "go function()" creates and runs a go-rountine. It will continue executing concurrently.

 

=={{header|Haskell}}==

Basic gates:

import Data.List (mapAccumR)

 

band = min

bnot :: Int -> Int

Gates built with basic ones:

nand = (bnot.).band

Adder circuits:

fullAdder (c, a, b) = (\(cy,s) -> first (bor cy) $ halfAdder (b, s)) $ halfAdder (c, a)

 

 

Example using adder4

 

=={{header|J}}==

 

===Implementation===

or=: +.

not=: -.

xor=: (and not) or (and not)~

hadd=: and ,"0 xor

 

===Example use===

 

To produce all results:

 

This will produce a 16 by 16 by 5 array, the first axis being the left argument (representing values 0..15), the second axis the right argument and the final axis being the bit indices (carry, 8, 4, 2, 1). In other words, the result is something like:

 

00000 00001 00010 00011 00100 00101 00110 00111 01000 01001 01010 01011 01100 01101 01110 01111

00001 00010 00011 00100 00101 00110 00111 01000 01001 01010 01011 01100 01101 01110 01111 10000

01101 01110 01111 10000 10001 10010 10011 10100 10101 10110 10111 11000 11001 11010 11011 11100

01110 01111 10000 10001 10010 10011 10100 10101 10110 10111 11000 11001 11010 11011 11100 11101

 

Alternatively, the fact that add was designed to operate on lists of bits could have been incorporated into its definition:

 

 

Then to get all results you could use:

 

Compare this to a regular addition table:

(this produces a 10 by 10 array -- the results have no further internal array structure, though of course in the machine implementation integers can be thought of as being represented as fixed width lists of bits.)

 

 

See also: "A Formal Description of System/360” by Adin Falkoff

 

=={{header|Java}}==

 

{

// Basic gate interfaces

}

 

{{out}}

0s and 1s. To enforce this, we'll first create a couple of helper functions.

 

function acceptedBinFormat(bin) {

if (bin == 1 || bin === 0 || bin === '0')

return true;

}

 

===Implementation===

and, finally, the four bit adder.

 

// basic building blocks allowed by the rules are ~, &, and |, we'll fake these

// in a way that makes what they do (at least when you use them) more obvious

return out.join('');

}

===Example Use===

 

all results:

 

// run this in your browsers console

var outer = inner = 16, a, b;

inner = outer;

}

 

=={{header|jq}}==

All the operations except fourBitAdder(a,b) assume the inputs are presented as 0 or 1 (i.e. integers).

 

# These allow us to construct 'nand', 'or', and 'xor',

# and so on.

| fullAdder($inA[0]; $inB[0]; $pass.carry) as $pass

| .[0] = $pass.sum

'''Example:'''

{{out}}

$ jq -n -f Four_bit_adder.jq

"1000"

 

=={{header|Julia}}==

 

'''Functions'''

xor{T<:Bool}(a::T, b::T) = (a&~b)|(~a&b)

 

 

Base.bits(n::BitArray{1}) = join(reverse(int(n)), "")

 

'''Main'''

xavail = trues(15,15)

xcnt = 0

bits(s), oflow))

end

 

{{out}}

3 + 1 = 4 => 0011 + 0001 = 0100

6 + 11 = 17 => 0110 + 1011 = 0001*

</pre>

 

[[File:4bit_adder_connector.png]]&nbsp;&nbsp;[[File:4bit_adder_panel.png]]&nbsp;&nbsp;[[File:4bit_adder_diagram.png]]

 

 

 

-- Full adder is two half adders with carry outputs OR'd

function fullAdder (a, b, cIn)

end

-- Carry bits 'ripple' through adders, first returned value is overflow

function fourBitAdder (a3, a2, a1, a0, b3, b2, b1, b0) -- LSB-first

end

-- Take string of noughts and ones, convert to native boolean type

function toBool (bitString)

end

-- Take list of booleans, convert to string of binary digits (variadic)

function toBits (...)

end

-- Little driver function to neaten use of the adder

function add (n1, n2)

end

-- Main procedure (usage examples)

print("SUM", "OVERFLOW\n")

print(add(0101, 1010)) -- 5 + 10 = 15

print(add(0000, 1111)) -- 0 + 15 = 15

Output:

 

0010 false

1111 false

1111 false

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

or[a_, b_] := Min[a, b];

not[a_] := 1 - a;

{s2, c2} = fulladder[a2, b2, c1];

{s3, c3} = fulladder[a3, b3, c2];

Example:

Output:

<pre>{{1, 0, 0, 1}, 1}</pre>

The four bit adder presented can work on matricies of 1's and 0's, which are stored as characters, doubles, or booleans. MATLAB has functions to convert decimal numbers to binary, but these functions convert a decimal number not to binary but a string data type of 1's and 0's. So, this four bit adder is written to be compatible with MATLAB's representation of binary. Also, because this is MATLAB, and you might want to add arrays of 4-bit binary numbers together, this implementation will add two column vectors of 4-bit binary numbers together.

 

 

%Make sure that only 4-Bit numbers are being added. This assumes that

v = num2str(v);

end

 

Sample Usage:

 

S =

 

11

 

=={{header|MUMPS}}==

QUIT (Y&'Z)!('Y&Z)

HALF(W,X)

FOR I=4:-1:1 SET T=$$FULL($E(Y,I),$E(Z,I),C4),$E(S,I)=$P(T,"^",1),C4=$P(T,"^",2)

K I,T

Usage:<pre>USER>S N1="0110",N2="0010",C=0,T=$$FOUR^ADDER(N1,N2,C)

 

=={{header|MyHDL}}==

 

 

"""

 

 

 

@always_comb # define asynchronous logic

 

@always_comb

 

@always_comb

 

 

nota, notb, annotb, bnnota = [Signal(bool(0)) for i in range(4)]

# name sub-components, and their interconnect

return inv0, inv1, and2a, and2b, or2a

 

""" carry,sum is the sum of in_a, in_b """

return and2a, xor2a

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|Nim}}==

{{trans|Python}}

 

let a = ha(ci, a)

let b = ha(a[0], b)

 

for i in 0..3:

let r = fa(a[i], b[i], if i > 0: co[i-1] else: false)

result[4] = co[3]

 

var n = n

for i in 0..result.high:

n = n shr 1

 

result += (if x: 1 else: 0) shl i

 

for a in 0..7:

for b in 0..7:

 

=={{header|OCaml}}==

(* File blocks.ml

 

(eval add4_io 4 4 (Array.map Int64.of_int [| a; b |])) in

v.(0), v.(1);;

 

Testing

 

# open Blocks;;

 

# plus 0 0;;

- : int * int = (0, 0)

 

An extension : n-bit adder, for n <= 64 (n could be greater, but we use Int64 for I/O)

 

(* general adder (n bits with n <= 64) *)

let gen_adder n = block_array serial [|

(eval (gadd_io n) n n (Array.map Int64.of_int [| a; b |])) in

v.(0), v.(1);;

 

And a test

 

# gen_plus 7 100 100;;

- : int * int = (72, 1)

# gen_plus 8 100 100;;

- : int * int = (200, 0)

 

=={{header|PARI/GP}}==

add4(a3,a2,a1,a0,b3,b2,b1,b0)={

my(s0,s1,s2,s3);

[s3[1],s3[2],s2[2],s1[2],s0[2]]

};

 

=={{header|Perl}}==

sub bin2dec { oct "0b".shift }

sub bin2bits { reverse split(//, substr(shift,0,shift)); }

$a, $b, $abin, $bbin, $c, $s, bin2dec($c.$s);

}

 

Output matches the [[Four bit adder#Ruby|Ruby]] output.

 

{{out}}

 

=={{header|PicoLisp}}==

(cons

(and A B)

(cdr Fa3)

(cdr Fa2)

{{out}}

<pre>: (4bitsAdder NIL NIL NIL T NIL NIL NIL T)

 

=={{header|PL/I}}==

/* 4-BIT ADDER */

 

 

END TEST;

=={{header|PowerShell}}==

===Using Bytes as Inputs===

{

$out1 = $a -band ( -bnot $b )

FourBitAdder 0xC 0xB

 

=={{header|PureBasic}}==

;Output values from the constructive building blocks is done using pointers (i.e. '*').

 

Input()

CloseConsole()

{{out}}

<pre>0110 + 1110 = 0100 overflow 1</pre>

between the normal Python values and those of the simulation.

 

def ha(a, b): return xor(a, b), a and b # sum, carry

 

if __name__ == '__main__':

 

=={{header|Racket}}==

 

(define (adder-and a b)

(cons v 4s))))

 

 

=={{header|REXX}}==

 

REXX programming syntax:

::::* the &nbsp; &nbsp; '''|''' &nbsp; &nbsp; &nbsp; symbol is a logical '''OR'''.

::::* the &nbsp; &nbsp; '''&amp;''' &nbsp; &nbsp; symbol is a logical '''AND'''.

do j=0 for 16

do k=0 for 16

end /*k*/

end /*j*/

 

aaaa + bbbb = c, sum [c=carry]

════ ════ ══════

════ ════ ══════

aaaa + bbbb = c, sum [c=carry]

</pre>

 

=={{header|Ruby}}==

def four_bit_adder(a, b)

a_bits = binary_string_to_bits(a,4)

[a, b, bin_a, bin_b, carry, sum, (carry + sum).to_i(2)]

end

 

{{out}}

15 + 14 = 1111 + 1110 = 1 1101 = 29

15 + 15 = 1111 + 1111 = 1 1110 = 30</pre>