2016 Update
This commit is contained in:
Tina Müller
parent
948b86eafa
commit
dcf5d15da3
7965 changed files with 139854 additions and 31002 deletions
|
|
@ -1,4 +1,6 @@
|
|||
The aim of this task is to "''simulate''" a four-bit adder "chip".
|
||||
;Task:
|
||||
"''Simulate''" a four-bit adder "chip".
|
||||
|
||||
This "chip" can be realized using four [[wp:Adder_(electronics)#Full_adder|1-bit full adder]]s.
|
||||
Each of these 1-bit full adders can be built with two [[wp:Adder_(electronics)#Half_adder|half adder]]s and an ''or'' [[wp:Logic gate|gate]]. Finally a half adder can be made using a ''xor'' gate and an ''and'' gate.
|
||||
The ''xor'' gate can be made using two ''not''s, two ''and''s and one ''or''.
|
||||
|
|
@ -26,3 +28,4 @@ It is not mandatory to replicate the syntax of higher-order blocks in the atomic
|
|||
|
||||
To test the implementation, show the sum of two four-bit numbers (in binary).
|
||||
<div style="clear:both"></div>
|
||||
<br><br>
|
||||
|
|
|
|||
107
Task/Four-bit-adder/COBOL/four-bit-adder.cobol
Normal file
107
Task/Four-bit-adder/COBOL/four-bit-adder.cobol
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
program-id. test-add.
|
||||
environment division.
|
||||
configuration section.
|
||||
special-names.
|
||||
class bin is "0" "1".
|
||||
data division.
|
||||
working-storage section.
|
||||
1 parms.
|
||||
2 a-in pic 9999.
|
||||
2 b-in pic 9999.
|
||||
2 r-out pic 9999.
|
||||
2 c-out pic 9.
|
||||
procedure division.
|
||||
display "Enter 'A' value (4-bits binary): "
|
||||
with no advancing
|
||||
accept a-in
|
||||
if a-in (1:) not bin
|
||||
display "A is not binary"
|
||||
stop run
|
||||
end-if
|
||||
display "Enter 'B' value (4-bits binary): "
|
||||
with no advancing
|
||||
accept b-in
|
||||
if b-in (1:) not bin
|
||||
display "B is not binary"
|
||||
stop run
|
||||
end-if
|
||||
call "add-4b" using parms
|
||||
display "Carry " c-out " result " r-out
|
||||
stop run
|
||||
.
|
||||
end program test-add.
|
||||
|
||||
program-id. add-4b.
|
||||
data division.
|
||||
working-storage section.
|
||||
1 wk binary.
|
||||
2 i pic 9(4).
|
||||
2 occurs 5.
|
||||
3 a-reg pic 9.
|
||||
3 b-reg pic 9.
|
||||
3 c-reg pic 9.
|
||||
3 r-reg pic 9.
|
||||
2 a pic 9.
|
||||
2 b pic 9.
|
||||
2 c pic 9.
|
||||
2 a-not pic 9.
|
||||
2 b-not pic 9.
|
||||
2 c-not pic 9.
|
||||
2 ha-1s pic 9.
|
||||
2 ha-1c pic 9.
|
||||
2 ha-1s-not pic 9.
|
||||
2 ha-1c-not pic 9.
|
||||
2 ha-2s pic 9.
|
||||
2 ha-2c pic 9.
|
||||
2 fa-s pic 9.
|
||||
2 fa-c pic 9.
|
||||
linkage section.
|
||||
1 parms.
|
||||
2 a-in pic 9999.
|
||||
2 b-in pic 9999.
|
||||
2 r-out pic 9999.
|
||||
2 c-out pic 9.
|
||||
procedure division using parms.
|
||||
initialize wk
|
||||
perform varying i from 1 by 1
|
||||
until i > 4
|
||||
move a-in (5 - i:1) to a-reg (i)
|
||||
move b-in (5 - i:1) to b-reg (i)
|
||||
end-perform
|
||||
perform simulate-adder varying i from 1 by 1
|
||||
until i > 4
|
||||
move c-reg (5) to c-out
|
||||
perform varying i from 1 by 1
|
||||
until i > 4
|
||||
move r-reg (i) to r-out (5 - i:1)
|
||||
end-perform
|
||||
exit program
|
||||
.
|
||||
|
||||
simulate-adder section.
|
||||
move a-reg (i) to a
|
||||
move b-reg (i) to b
|
||||
move c-reg (i) to c
|
||||
add a -1 giving a-not
|
||||
add b -1 giving b-not
|
||||
add c -1 giving c-not
|
||||
|
||||
compute ha-1s = function max (
|
||||
function min ( a b-not )
|
||||
function min ( b a-not ) )
|
||||
compute ha-1c = function min ( a b )
|
||||
add ha-1s -1 giving ha-1s-not
|
||||
add ha-1c -1 giving ha-1c-not
|
||||
|
||||
compute ha-2s = function max (
|
||||
function min ( c ha-1s-not )
|
||||
function min ( ha-1s c-not ) )
|
||||
compute ha-2c = function min ( c ha-1c )
|
||||
|
||||
compute fa-s = ha-2s
|
||||
compute fa-c = function max ( ha-1c ha-2c )
|
||||
|
||||
move fa-s to r-reg (i)
|
||||
move fa-c to c-reg (i + 1)
|
||||
.
|
||||
end program add-4b.
|
||||
47
Task/Four-bit-adder/Elixir/four-bit-adder.elixir
Normal file
47
Task/Four-bit-adder/Elixir/four-bit-adder.elixir
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
defmodule RC do
|
||||
use Bitwise
|
||||
@bit_size 4
|
||||
|
||||
def four_bit_adder(a, b) do # returns pair {sum, carry}
|
||||
a_bits = binary_string_to_bits(a)
|
||||
b_bits = binary_string_to_bits(b)
|
||||
Enum.zip(a_bits, b_bits)
|
||||
|> List.foldr({[], 0}, fn {a_bit, b_bit}, {acc, carry} ->
|
||||
{s, c} = full_adder(a_bit, b_bit, carry)
|
||||
{[s | acc], c}
|
||||
end)
|
||||
end
|
||||
|
||||
defp full_adder(a, b, c0) do
|
||||
{s, c} = half_adder(c0, a)
|
||||
{s, c1} = half_adder(s, b)
|
||||
{s, bor(c, c1)} # returns pair {sum, carry}
|
||||
end
|
||||
|
||||
defp half_adder(a, b) do
|
||||
{bxor(a, b), band(a, b)} # returns pair {sum, carry}
|
||||
end
|
||||
|
||||
def int_to_binary_string(n) do
|
||||
Integer.to_string(n,2) |> String.rjust(@bit_size, ?0)
|
||||
end
|
||||
|
||||
defp binary_string_to_bits(s) do
|
||||
String.codepoints(s) |> Enum.map(fn bit -> String.to_integer(bit) end)
|
||||
end
|
||||
|
||||
def task do
|
||||
IO.puts " A B A B C S sum"
|
||||
Enum.each(0..15, fn a ->
|
||||
bin_a = int_to_binary_string(a)
|
||||
Enum.each(0..15, fn b ->
|
||||
bin_b = int_to_binary_string(b)
|
||||
{sum, carry} = four_bit_adder(bin_a, bin_b)
|
||||
:io.format "~2w + ~2w = ~s + ~s = ~w ~s = ~2w~n",
|
||||
[a, b, bin_a, bin_b, carry, Enum.join(sum), Integer.undigits([carry | sum], 2)]
|
||||
end)
|
||||
end)
|
||||
end
|
||||
end
|
||||
|
||||
RC.task
|
||||
|
|
@ -1,64 +1,52 @@
|
|||
-- Build XOR from AND, OR and NOT
|
||||
function xor (a, b)
|
||||
return (a and not b) or (b and not a)
|
||||
end
|
||||
function xor (a, b) return (a and not b) or (b and not a) end
|
||||
|
||||
-- Can make half adder now XOR exists
|
||||
function halfAdder (a, b)
|
||||
local sum, carry
|
||||
sum = xor(a, b)
|
||||
carry = a and b
|
||||
return sum, carry
|
||||
end
|
||||
function halfAdder (a, b) return xor(a, b), a and b end
|
||||
|
||||
-- Full adder is two half adders with carry outputs OR'd
|
||||
function fullAdder (a, b, cIn)
|
||||
local ha0s, ha0c = halfAdder(cIn, a)
|
||||
local ha1s, ha1c = halfAdder(ha0s, b)
|
||||
local cOut, s = ha0c or ha1c, ha1s
|
||||
return cOut, s
|
||||
local ha0s, ha0c = halfAdder(cIn, a)
|
||||
local ha1s, ha1c = halfAdder(ha0s, b)
|
||||
local cOut, s = ha0c or ha1c, ha1s
|
||||
return cOut, s
|
||||
end
|
||||
|
||||
-- Carry bits 'ripple' through adders, first returned value is overflow
|
||||
function fourBitAdder (a3, a2, a1, a0, b3, b2, b1, b0) -- LSB-first
|
||||
local fa0c, fa0s = fullAdder(a0, b0, false)
|
||||
local fa1c, fa1s = fullAdder(a1, b1, fa0c)
|
||||
local fa2c, fa2s = fullAdder(a2, b2, fa1c)
|
||||
local fa3c, fa3s = fullAdder(a3, b3, fa2c)
|
||||
return fa3c, fa3s, fa2s, fa1s, fa0s -- Return as MSB-first
|
||||
local fa0c, fa0s = fullAdder(a0, b0, false)
|
||||
local fa1c, fa1s = fullAdder(a1, b1, fa0c)
|
||||
local fa2c, fa2s = fullAdder(a2, b2, fa1c)
|
||||
local fa3c, fa3s = fullAdder(a3, b3, fa2c)
|
||||
return fa3c, fa3s, fa2s, fa1s, fa0s -- Return as MSB-first
|
||||
end
|
||||
|
||||
-- Take string of noughts and ones, convert to native boolean type
|
||||
function toBool (bitString)
|
||||
local boolList, bit = {}
|
||||
for digit = 1, 4 do
|
||||
bit = string.sub(string.format("%04d", bitString), digit, digit)
|
||||
if bit == "0" then table.insert(boolList, false) end
|
||||
if bit == "1" then table.insert(boolList, true) end
|
||||
end
|
||||
return boolList
|
||||
local boolList, bit = {}
|
||||
for digit = 1, 4 do
|
||||
bit = string.sub(string.format("%04d", bitString), digit, digit)
|
||||
if bit == "0" then table.insert(boolList, false) end
|
||||
if bit == "1" then table.insert(boolList, true) end
|
||||
end
|
||||
return boolList
|
||||
end
|
||||
|
||||
-- Take list of booleans, convert to string of binary digits (variadic)
|
||||
function toBits (...)
|
||||
local bitString = ""
|
||||
for i, bool in pairs{...} do
|
||||
if bool then
|
||||
bitString = bitString .. "1"
|
||||
else
|
||||
bitString = bitString .. "0"
|
||||
end
|
||||
end
|
||||
return bitString
|
||||
local bStr = ""
|
||||
for i, bool in pairs{...} do
|
||||
if bool then bStr = bStr .. "1" else bStr = bStr .. "0" end
|
||||
end
|
||||
return bStr
|
||||
end
|
||||
|
||||
-- Little driver function to neaten use of the adder
|
||||
function add (n1, n2)
|
||||
local A, B = toBool(n1), toBool(n2)
|
||||
local v, s0, s1, s2, s3 = fourBitAdder ( A[1], A[2], A[3], A[4],
|
||||
B[1], B[2], B[3], B[4]
|
||||
)
|
||||
return toBits(s0, s1, s2, s3), v
|
||||
local A, B = toBool(n1), toBool(n2)
|
||||
local v, s0, s1, s2, s3 = fourBitAdder( A[1], A[2], A[3], A[4],
|
||||
B[1], B[2], B[3], B[4] )
|
||||
return toBits(s0, s1, s2, s3), v
|
||||
end
|
||||
|
||||
-- Main procedure (usage examples)
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
xor(a,b)=(!a&b)|(a&!b);
|
||||
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]];
|
||||
xor(a,b)=(!a&b)||(a&!b);
|
||||
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]];
|
||||
add4(a3,a2,a1,a0,b3,b2,b1,b0)={
|
||||
my(s0,s1,s2,s3);
|
||||
s0=fulladd(a0,b0,0);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
sub xor ($a, $b) { ($a and not $b) or (not $a and $b) }
|
||||
sub xor ($a, $b) { (($a and not $b) or (not $a and $b)) ?? 1 !! 0 }
|
||||
|
||||
sub half-adder ($a, $b) {
|
||||
return xor($a, $b), ($a and $b);
|
||||
|
|
|
|||
131
Task/Four-bit-adder/PowerShell/four-bit-adder-2.psh
Normal file
131
Task/Four-bit-adder/PowerShell/four-bit-adder-2.psh
Normal file
|
|
@ -0,0 +1,131 @@
|
|||
$source = @'
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
|
||||
namespace RosettaCodeTasks.FourBitAdder
|
||||
{
|
||||
public struct BitAdderOutput
|
||||
{
|
||||
public bool S { get; set; }
|
||||
public bool C { get; set; }
|
||||
public override string ToString ( )
|
||||
{
|
||||
return "S" + ( S ? "1" : "0" ) + "C" + ( C ? "1" : "0" );
|
||||
}
|
||||
}
|
||||
public struct Nibble
|
||||
{
|
||||
public bool _1 { get; set; }
|
||||
public bool _2 { get; set; }
|
||||
public bool _3 { get; set; }
|
||||
public bool _4 { get; set; }
|
||||
public override string ToString ( )
|
||||
{
|
||||
return ( _4 ? "1" : "0" )
|
||||
+ ( _3 ? "1" : "0" )
|
||||
+ ( _2 ? "1" : "0" )
|
||||
+ ( _1 ? "1" : "0" );
|
||||
}
|
||||
}
|
||||
public struct FourBitAdderOutput
|
||||
{
|
||||
public Nibble N { get; set; }
|
||||
public bool C { get; set; }
|
||||
public override string ToString ( )
|
||||
{
|
||||
return N.ToString ( ) + "c" + ( C ? "1" : "0" );
|
||||
}
|
||||
}
|
||||
|
||||
public static class LogicGates
|
||||
{
|
||||
// Basic Gates
|
||||
public static bool Not ( bool A ) { return !A; }
|
||||
public static bool And ( bool A, bool B ) { return A && B; }
|
||||
public static bool Or ( bool A, bool B ) { return A || B; }
|
||||
|
||||
// Composite Gates
|
||||
public static bool Xor ( bool A, bool B ) { return Or ( And ( A, Not ( B ) ), ( And ( Not ( A ), B ) ) ); }
|
||||
}
|
||||
|
||||
public static class ConstructiveBlocks
|
||||
{
|
||||
public static BitAdderOutput HalfAdder ( bool A, bool B )
|
||||
{
|
||||
return new BitAdderOutput ( ) { S = LogicGates.Xor ( A, B ), C = LogicGates.And ( A, B ) };
|
||||
}
|
||||
|
||||
public static BitAdderOutput FullAdder ( bool A, bool B, bool CI )
|
||||
{
|
||||
BitAdderOutput HA1 = HalfAdder ( CI, A );
|
||||
BitAdderOutput HA2 = HalfAdder ( HA1.S, B );
|
||||
|
||||
return new BitAdderOutput ( ) { S = HA2.S, C = LogicGates.Or ( HA1.C, HA2.C ) };
|
||||
}
|
||||
|
||||
public static FourBitAdderOutput FourBitAdder ( Nibble A, Nibble B, bool CI )
|
||||
{
|
||||
|
||||
BitAdderOutput FA1 = FullAdder ( A._1, B._1, CI );
|
||||
BitAdderOutput FA2 = FullAdder ( A._2, B._2, FA1.C );
|
||||
BitAdderOutput FA3 = FullAdder ( A._3, B._3, FA2.C );
|
||||
BitAdderOutput FA4 = FullAdder ( A._4, B._4, FA3.C );
|
||||
|
||||
return new FourBitAdderOutput ( ) { N = new Nibble ( ) { _1 = FA1.S, _2 = FA2.S, _3 = FA3.S, _4 = FA4.S }, C = FA4.C };
|
||||
}
|
||||
|
||||
public static void Test ( )
|
||||
{
|
||||
Console.WriteLine ( "Four Bit Adder" );
|
||||
|
||||
for ( int i = 0; i < 256; i++ )
|
||||
{
|
||||
Nibble A = new Nibble ( ) { _1 = false, _2 = false, _3 = false, _4 = false };
|
||||
Nibble B = new Nibble ( ) { _1 = false, _2 = false, _3 = false, _4 = false };
|
||||
if ( (i & 1) == 1)
|
||||
{
|
||||
A._1 = true;
|
||||
}
|
||||
if ( ( i & 2 ) == 2 )
|
||||
{
|
||||
A._2 = true;
|
||||
}
|
||||
if ( ( i & 4 ) == 4 )
|
||||
{
|
||||
A._3 = true;
|
||||
}
|
||||
if ( ( i & 8 ) == 8 )
|
||||
{
|
||||
A._4 = true;
|
||||
}
|
||||
if ( ( i & 16 ) == 16 )
|
||||
{
|
||||
B._1 = true;
|
||||
}
|
||||
if ( ( i & 32 ) == 32)
|
||||
{
|
||||
B._2 = true;
|
||||
}
|
||||
if ( ( i & 64 ) == 64 )
|
||||
{
|
||||
B._3 = true;
|
||||
}
|
||||
if ( ( i & 128 ) == 128 )
|
||||
{
|
||||
B._4 = true;
|
||||
}
|
||||
|
||||
Console.WriteLine ( "{0} + {1} = {2}", A.ToString ( ), B.ToString ( ), FourBitAdder( A, B, false ).ToString ( ) );
|
||||
|
||||
}
|
||||
|
||||
Console.WriteLine ( );
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
'@
|
||||
|
||||
Add-Type -TypeDefinition $source -Language CSharpVersion3
|
||||
1
Task/Four-bit-adder/PowerShell/four-bit-adder-3.psh
Normal file
1
Task/Four-bit-adder/PowerShell/four-bit-adder-3.psh
Normal file
|
|
@ -0,0 +1 @@
|
|||
[RosettaCodeTasks.FourBitAdder.ConstructiveBlocks]::Test()
|
||||
|
|
@ -1,30 +1,30 @@
|
|||
/*REXX program shows (all) the sums of a full 4─bit adder (with carry).*/
|
||||
call hdr1; call hdr2 /*note order of headers (& below)*/
|
||||
/* [↓] traipse all possibilities*/
|
||||
/*REXX program displays (all) the sums of a full 4─bit adder (with carry). */
|
||||
call hdr1; call hdr2 /*note the order of headers & trailers.*/
|
||||
/* [↓] traipse thru all possibilities.*/
|
||||
do j=0 for 16
|
||||
do m=0 for 4; a.m=bit(j,m); end
|
||||
do m=0 for 4; a.m=bit(j, m); end /*m*/
|
||||
do k=0 for 16
|
||||
do m=0 for 4; b.m=bit(k,m); end
|
||||
do m=0 for 4; b.m=bit(k, m); end /*m*/
|
||||
sc=4bitAdder(a., b.)
|
||||
z=a.3 a.2 a.1 a.0 '_+_' b.3 b.2 b.1 b.0 '_=_' sc ',' s.3 s.2 s.1 s.0
|
||||
say translate(space(z,0),,'_') /*remove all underbars (_) from Z*/
|
||||
z=a.3 a.2 a.1 a.0 '_+_' b.3 b.2 b.1 b.0 "_=_" sc ',' s.3 s.2 s.1 s.0
|
||||
say translate(space(z, 0), , '_') /*remove all the underbars (_) from Z. */
|
||||
end /*k*/
|
||||
end /*j*/
|
||||
|
||||
call hdr2; call hdr1 /*display 2 headers (note order).*/
|
||||
exit /*stick a fork in it, we're done.*/
|
||||
/*──────────────────────────────────one─line subroutines────────────────*/
|
||||
bit: procedure; arg x,y; return substr(reverse(x2b(d2x(x))),y+1,1)
|
||||
halfAdder: procedure expose c; parse arg x,y; c=x & y; return x && y
|
||||
hdr1: say 'aaaa + bbbb = c, sum [c=carry]'; return
|
||||
hdr2: say '════ ════ ══════' ; return
|
||||
/*──────────────────────────────────FULLADDER subroutine────────────────*/
|
||||
fullAdder: procedure expose c; parse arg x,y,fc
|
||||
_1 = halfAdder(fc,x); c1=c
|
||||
_2 = halfAdder(_1,y); c=c | c1; return _2
|
||||
/*──────────────────────────────────4BITADDER subroutine────────────────*/
|
||||
call hdr2; call hdr1 /*display two trailers (note the order)*/
|
||||
exit /*stick a fork in it, we're all done. */
|
||||
/*──────────────────────────────────────────────────────────────────────────────────────*/
|
||||
bit: procedure; parse arg x,y; return substr( reverse( x2b( d2x(x) ) ), y+1, 1)
|
||||
halfAdder: procedure expose c; parse arg x,y; c=x & y; return x && y
|
||||
hdr1: say 'aaaa + bbbb = c, sum [c=carry]'; return
|
||||
hdr2: say '════ ════ ══════' ; return
|
||||
/*──────────────────────────────────────────────────────────────────────────────────────*/
|
||||
fullAdder: procedure expose c; parse arg x,y,fc
|
||||
_1=halfAdder(fc, x); c1=c
|
||||
_2=halfAdder(_1, y); c=c | c1; return _2
|
||||
/*──────────────────────────────────────────────────────────────────────────────────────*/
|
||||
4bitAdder: procedure expose s. a. b.; carry.=0
|
||||
do j=0 for 4; n=j-1
|
||||
s.j=fullAdder(a.j, b.j, carry.n); carry.j=c
|
||||
end /*j*/
|
||||
return c
|
||||
do j=0 for 4; n=j-1
|
||||
s.j=fullAdder(a.j, b.j, carry.n); carry.j=c
|
||||
end /*j*/
|
||||
return c
|
||||
|
|
|
|||
52
Task/Four-bit-adder/Sed/four-bit-adder-1.sed
Normal file
52
Task/Four-bit-adder/Sed/four-bit-adder-1.sed
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
#!/bin/sed -f
|
||||
# (C) 2005,2014 by Mariusz Woloszyn :)
|
||||
# https://en.wikipedia.org/wiki/Adder_(electronics)
|
||||
|
||||
##############################
|
||||
# PURE SED BINARY FULL ADDER #
|
||||
##############################
|
||||
|
||||
|
||||
# Input two lines, sanitize input
|
||||
N
|
||||
s/ //g
|
||||
/^[01 ]\+\n[01 ]\+$/! {
|
||||
i\
|
||||
ERROR: WRONG INPUT DATA
|
||||
d
|
||||
q
|
||||
}
|
||||
s/[ ]//g
|
||||
|
||||
# Add place for Sum and Cary bit
|
||||
s/$/\n\n0/
|
||||
|
||||
:LOOP
|
||||
# Pick A,B and C bits and put that to hold
|
||||
s/^\(.*\)\(.\)\n\(.*\)\(.\)\n\(.*\)\n\(.\)$/0\1\n0\3\n\5\n\6\2\4/
|
||||
h
|
||||
|
||||
# Grab just A,B,C
|
||||
s/^.*\n.*\n.*\n\(...\)$/\1/
|
||||
|
||||
# binary full adder module
|
||||
# INPUT: 3bits (A,B,Carry in), for example 101
|
||||
# OUTPUT: 2bits (Carry, Sum), for wxample 10
|
||||
s/$/;000=00001=01010=01011=10100=01101=10110=10111=11/
|
||||
s/^\(...\)[^;]*;[^;]*\1=\(..\).*/\2/
|
||||
|
||||
# Append the sum to hold
|
||||
H
|
||||
|
||||
# Rewrite the output, append the sum bit to final sum
|
||||
g
|
||||
s/^\(.*\)\n\(.*\)\n\(.*\)\n...\n\(.\)\(.\)$/\1\n\2\n\5\3\n\4/
|
||||
|
||||
# Output result and exit if no more bits to process..
|
||||
/^\([0]*\)\n\([0]*\)\n/ {
|
||||
s/^.*\n.*\n\(.*\)\n\(.\)/\2\1/
|
||||
s/^0\(.*\)/\1/
|
||||
q
|
||||
}
|
||||
|
||||
b LOOP
|
||||
14
Task/Four-bit-adder/Sed/four-bit-adder-2.sed
Normal file
14
Task/Four-bit-adder/Sed/four-bit-adder-2.sed
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
./binAdder.sed
|
||||
1111110111
|
||||
1
|
||||
1111111000
|
||||
|
||||
./binAdder.sed
|
||||
10
|
||||
10001
|
||||
10011
|
||||
|
||||
./binAdder.sed
|
||||
0 1 1 0
|
||||
0 0 0 1
|
||||
111
|
||||
Loading…
Add table
Add a link
Reference in a new issue