Four bit adder: Difference between revisions

This design can be realized using four [[wp:Adder_(electronics)#Full_adder|1-bit full adder]]s.

 

 

 

{|

|+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.

 

{{trans|Python}}

 

R (a & !b) | (b & !a)

 

tot[i] = ta[i]

tot[width] = tlast

 

=={{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>

==={{header|Applesoft BASIC}}===

 

110 S$ = "1100 + 1101 = " : GOSUB 400

120 S$ = "1100 + 1110 = " : GOSUB 400

910 D = B AND NOT A

920 C = C OR D

 

==={{header|BBC BASIC}}===

{{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>

 

=={{header|Batch File}}==

@echo off

setlocal enabledelayedexpansion

if %1==1 if %2==1 exit /b 1

exit /b 0

{{out}}

<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|C++}}==

 

=={{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)

)

 

 

===Using Bitwise Operators===

(defn to-binary-seq [^long x]

(map #(- (int %) (int \0))

(is (= (Long/parseLong (apply str (ripple-carry-adder (to-binary-seq 130) (to-binary-seq 250))) 2)

(+ 130 250))))

 

=={{header|COBOL}}==

program-id. test-add.

environment division.

end program add-4b.

 

{{out}}

<pre>

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|Common Lisp}}==

(defun half-adder (a b)

(list (logxor a b) (logand a b)))

 

(main)

output:

<pre>

=={{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|Delphi}}==

{{libheader| System.SysUtils}}

{{Trans|C#}}

program Four_bit_adder;

 

Readln;

end.

{{out}}

<pre>

1111 + 1111 = 1110 c=1

</pre>

=={{header|Elixir}}==

{{works with|Elixir|1.1}}

{{trans|Ruby}}

use Bitwise

@bit_size 4

end

 

 

{{out}}

=={{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>

</pre>

 

type Bit =

| Zero

printfn "0001 + 0111 ="

b4A (Zero, Zero, Zero, One) (Zero, One, One, One) |> printfn "%A"

{{out}}

<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|Icon}} and {{header|Unicon}}==

Based on the algorithms shown in the Fortran entry, but Unicon does not allow pass by reference for immutable types, so a small <code>carry</code> record is used instead.

 

# 4bitadder.icn, emulate a 4 bit adder. Using only and, or, not

#

# cr.c is the overflow carry

return s

 

{{out}}

 

===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.)

 

=={{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

=={{header|Jsish}}==

Based on Javascript entry.

/* 4 bit adder simulation, in Jsish */

function not(a) { return a == 1 ? 0 : 1; }

PASS!: err = bad bit at a[3] of "2"

=!EXPECTEND!=

{{out}}

<pre>prompt$ jsish --U fourBitAdder.jsi

 

'''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}}

 

=={{header|Kotlin}}==

 

val Boolean.I get() = if (this) 1 else 0

for (j in i..minOf(i + 1, 15)) test(i, j)

}

 

{{out}}

 

=={{header|Lambdatalk}}==

{def xor

{lambda {:a :b}

14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

 

=={{header|Lua}}==

function xor (a, b) return (a and not b) or (b and not a) end

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

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

Output:

<pre>SUM OVERFLOW

 

=={{header|M2000 Interpreter}}==

Module FourBitAdder {

Flush

}

FourBitAdder

 

=={{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}}

 

Bools[N: static int] = array[N, bool]

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}}==

halfadd(a,b)=[a&&b,xor(a,b)];

fulladd(a,b,c)=my(t=halfadd(a,c),s=halfadd(t[2],b));[t[1]||s[1],s[2]];

[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.

 

=={{header|Phix}}==

{{out}}

<pre>

0000 + 0000 = 0000 0 (0+0=0)

0000 + 0001 = 0001 0 (0+1=1)

0011 + 0111 = 1010 0 (3+7=10)

1101 + 0000 = 1101 0 (13+0=13)

1101 + 0001 = 1110 0 (13+1=14)

1101 + 0010 = 1111 0 (13+2=15)

</pre>

 

=={{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

 

 

===Translation of C# code===

The well-written C# code on this page can be translated without any modification into a .NET type by PowerShell.

$source = @'

using System;

 

Add-Type -TypeDefinition $source -Language CSharpVersion3

[RosettaCodeTasks.FourBitAdder.ConstructiveBlocks]::Test()

{{Out}}

<pre>

=={{header|Prolog}}==

Using hi/lo symbols to represent binary. As this is a simulation, there is no real "arithmetic" happening.

 

b_not(in(hi), out(lo)) :- !. % not(1) = 0

test_add(in(hi,hi,lo,hi), in(hi,lo,lo,hi), '11 + 9 = 20'),

test_add(in(lo,lo,lo,hi), in(lo,lo,lo,hi), '8 + 8 = 16'),

<pre>?- go.

in(hi,lo,lo,lo) + in(hi,lo,lo,lo) is out(lo,hi,lo,lo) c(lo) (1 + 1 = 2)

 

=={{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|Raku}}==

(formerly Perl 6)

 

sub half-adder ($a, $b) {

is four-bit-adder(1, 0, 1, 0, 1, 0, 1, 0), (0, 1, 0, 1, 0), '5 + 5 == 10';

is four-bit-adder(1, 0, 0, 1, 1, 1, 1, 0)[4], 1, '7 + 9 == overflow';

 

{{out}}

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

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

/* [↓] traipse thru all possibilities.*/

do j=0 for 16

do k=0 for 16

end /*k*/

end /*j*/

 

/*──────────────────────────────────────────────────────────────────────────────────────*/

bit: procedure; parse arg x,y; return substr( reverse( x2b( d2x(x) ) ), y+1, 1)

/*──────────────────────────────────────────────────────────────────────────────────────*/

fullAdder: procedure expose c; parse arg x,y,fc

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre style="height:63ex">

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

{{Full One-Bit-Adder function is made up of XOR OR AND gates}}

 

 

###---------------------------

###------------------------

 

Output:

<pre>

Sum...: 1 00110011001100110011001100110010

 

</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}}

 

=={{header|Rust}}==

// half adder with XOR and AND

// SUM = A XOR B

}

 

 

=={{header|Sather}}==

-- that "sets" it to 0 or 1, while it can be "read"

-- ad libitum. (Tristate logic is not taken into account)

", overflow = " + fba.v.val + "\n";

end;

 

=={{header|Scala}}==

type Nibble=(Boolean, Boolean, Boolean, Boolean)

 

((s3, s2, s1, s0), cOut)

}

 

A test program using the object above.

import FourBitAdder._

def main(args: Array[String]): Unit = {

implicit def intToNibble(i:Int):Nibble=((i>>>3)&1, (i>>>2)&1, (i>>>1)&1, i&1)

def nibbleToString(n:Nibble):String="%d%d%d%d".format(n._1.toInt, n._2.toInt, n._3.toInt, n._4.toInt)

{{out}}

<pre> A B S C

{{trans|Common Lisp}}

 

(import (scheme base)

(scheme write)

(show-eg (list 1 1 1 1) (list 1 1 1 1))

(show-eg (list 1 0 1 0) (list 0 1 0 1))

 

{{out}}

This is full adder that means it takes arbitrary number of bits (think of it as infinite stack of 2 bit adders, which is btw how it's internally made).

I took it from https://github.com/emsi/SedScripts

#!/bin/sed -f

# (C) 2005,2014 by Mariusz Woloszyn :)

}

 

 

Example usage:

 

./binAdder.sed

1111110111

0 0 0 1

111

 

=={{header|Sidef}}==

{{trans|Perl}}

(~a & b) | (a & ~b)

}

a, b, abin.join, bbin.join, c, s, "#{c}#{s}".bin)

}

 

{{out}}

=={{header|Swift}}==

 

 

func halfAdder(_ a: Int, _ b: Int) -> (Int, Int) {

print("\(a) + \(b) = \(fourBitAdder(a, b))")

 

 

{{out}}

=={{header|SystemVerilog}}==

In SystemVerilog we can define a multibit adder as a parameterized module, that instantiates the components:

module Half_Adder( input a, b, output s, c );

assign s = a ^ b;

 

endmodule

 

And then a testbench to test it -- here I use random stimulus with an assertion (it's aften good to separate the stimulus generation from the results-checking):

 

module simTop();

 

endprogram

 

 

{{out}}

=={{header|Tcl}}==

This example shows how you can make little languages in Tcl that describe the problem space.

 

# Create our little language

fulladd a2 b2 c2 s2 c3

fulladd a3 b3 c3 s3 v

 

proc 4add_driver {a b} {

lassign [split $a {}] a3 a2 a1 a0

set a 1011

set b 0110

{{out}}

<pre>

 

=={{header|TorqueScript}}==

{

return (!%a && %b) || (%a && !%b);

%r3 = FullAdd(%a3, %b3, getWord(%r2, 0));

return getWord(%r0,1) SPC getWord(%r1,1) SPC getWord(%r2,1) SPC getWord(%r3,1) SPC getWord(%r3,0);

 

=={{header|Verilog}}==

In Verilog we can also define a multibit adder as a component with multiple instances:

module Half_Adder( output c, s, input a, b );

xor xor01 (s, a, b);

 

endmodule // test_Full_Adder

 

{{out}}

=={{header|VHDL}}==

The following is a direct implementation of the proposed schematic:

USE ieee.std_logic_1164.all;

 

begin

x <= (a and not b) or (b and not a);

 

 

An exhaustive testbench:

USE ieee.std_logic_1164.all;

use ieee.NUMERIC_STD.all;

);

 

 

=={{header|Wren}}==

{{trans|Go}}

 

var ha = Fn.new { |a, b| [xor.call(a, b), a & b] }

}

 

 

{{out}}

 

=={{header|XPL0}}==

 

func Not(A);

Add4Bits(1, 1, 1, 1, 1, 1, 1, 1, @S0, @S1, @S2, @S3, @C); \1111 + 1111 = 11110

BinOut(0, S0, S1, S2, S3, C); CrLf(0);

 

{{out}}

 

=={{header|zkl}}==

{ a.bitAnd(b.bitNot()).bitOr(b.bitAnd(a.bitNot())) }

 

// add(10,9) result should be 1 0 0 1 1 (0x13, 3 carry 1)

(ss:=List()).append(

[as.len()-1 .. 0,-1].reduce('wrap(c,n){

.reverse();

}

{{out}}

<pre>