Four bit adder: Difference between revisions

 

 

 

 

{|

|+Schematics of the "constructive blocks"

|-

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

|}

 

 

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;

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

<pre>

</pre>

</div>

 

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

 

=={{header|D}}==

 

return (~x & y) | (x & ~y);

}

 

s = xor(a, b);

c = a & b;

}

 

T ps, pc, tc;

 

oc = tc | pc;

}

T zero, tc0, tc1, tc2;

 

}

 

void main() {

 

enum T one = T.max,

T s0, s1, s2, s3, overflow;

 

 

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

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

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

<pre> a3 00000000000000000000000000000000

a2 00000000000000000000000000000000

s0 00000000000000000000000000000000

overflow 11111111111111111111111111111111</pre>

 

=={{header|Fortran}}==

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

implicit none

 

end do

end do

<pre>1100 + 1100 = 11000

1100 + 1101 = 11001

1101 + 0010 = 01111

1101 + 0011 = 10000</pre>

 

=={{header|Go}}==

===Bytes===

 

import "fmt"

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

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

<pre>

1 0 0 1 1

</pre>

===Channels===

Alternative solution is a little more like a simulation.

 

import "fmt"

// Reading a value blocks until a value is available.

type Wire chan bool

}

 

// A source for zero values.

}

 

// And gate.

}

 

// Or gate.

}

 

// Not gate.

}

 

// Split a wire in two.

}

 

// Xor gate, composed of Or, And and Not gates.

}

 

// A half adder, composed of two splits and an And and Xor gate.

}

 

// A full adder, composed of two half adders, and an Or gate.

}

 

// A four bit adder, composed of a zero source, and four full adders.

}

 

func main() {

 

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:

 

bor, band :: Int -> Int -> Int

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:

 

 

 

Then to get all results you could use:

 

Compare this to a regular addition table:

 

===Glossary===

 

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

 

=={{header|LabVIEW}}==

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

 

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

 

ha1_s, ha1_c1, ha2_c1 = [Signal(bool(0)) for i in range(3)]