dissertation_thesis/ariths-gen-mig
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Generated hierarchical C code circuits and updated testing script correspondigly.

Browse Source
This commit is contained in:
honzastor 2021-02-12 01:45:26 +01:00
parent 397d3bc658
commit 193d504120
28 changed files with 1375 additions and 500 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
Tests/C_circuits/Flat_circuits/Adders/f_fa.c Normal file
View File

@ -0,0 +1,39 @@
#include <stdio.h>
#include <stdint.h>
uint8_t f_fa(uint8_t a, uint8_t b, uint8_t cout){
uint8_t out = 0;
uint8_t f_fa_a = 0;
uint8_t f_fa_b = 0;
uint8_t f_fa_y0 = 0;
uint8_t f_fa_y1 = 0;
uint8_t f_fa_cout = 0;
uint8_t f_fa_y2 = 0;
uint8_t f_fa_y3 = 0;
uint8_t f_fa_y4 = 0;
f_fa_a = ((a >> 0) & 0x01);
f_fa_b = ((b >> 0) & 0x01);
f_fa_cout = ((cout >> 0) & 0x01);
f_fa_y0 = f_fa_a ^ f_fa_b;
f_fa_y1 = f_fa_a & f_fa_b;
f_fa_y2 = f_fa_y0 ^ f_fa_cout;
f_fa_y3 = f_fa_y0 & f_fa_cout;
f_fa_y4 = f_fa_y1 | f_fa_y3;
out |= (f_fa_y2 & 0x01) << 0;
out |= (f_fa_y4 & 0x01) << 1;
return out;
}
#include <assert.h>
int main(){
for (int i = 0; i < 2; i++){
for (int j = 0; j < 2; j++){
for (int k = 0; k < 2; k++){
assert((i + j + k) == f_fa(i,j,k));
}
}
}
return 0;
}

29
Tests/C_circuits/Flat_circuits/Adders/f_ha.c Normal file
View File

@ -0,0 +1,29 @@
#include <stdio.h>
#include <stdint.h>
uint8_t f_ha(uint8_t a, uint8_t b){
uint8_t out = 0;
uint8_t f_ha_a = 0;
uint8_t f_ha_b = 0;
uint8_t f_ha_y0 = 0;
uint8_t f_ha_y1 = 0;
f_ha_a = ((a >> 0) & 0x01);
f_ha_b = ((b >> 0) & 0x01);
f_ha_y0 = f_ha_a ^ f_ha_b;
f_ha_y1 = f_ha_a & f_ha_b;
out |= (f_ha_y0 & 0x01) << 0;
out |= (f_ha_y1 & 0x01) << 1;
return out;
}
#include <assert.h>
int main(){
for (int i = 0; i < 2; i++){
for (int j = 0; j < 2; j++){
assert((i + j) == f_ha(i,j));
}
}
return 0;
}

34
Tests/Flat_c_circuits/Adders/s_rca2.c → Tests/C_circuits/Flat_circuits/Adders/f_s_rca2.c
View File

@ -3,40 +3,40 @@
uint64_t s_rca2(int64_t a, int64_t b){
uint8_t out = 0;
uint8_t s_rca2_ha_a = 0;
uint8_t s_rca2_ha_b = 0;
uint8_t s_rca2_ha_a_0 = 0;
uint8_t s_rca2_ha_b_0 = 0;
uint8_t s_rca2_ha_y0 = 0;
uint8_t s_rca2_ha_y1 = 0;
uint8_t s_rca2_fa1_a = 0;
uint8_t s_rca2_fa1_b = 0;
uint8_t s_rca2_fa1_a_1 = 0;
uint8_t s_rca2_fa1_b_1 = 0;
uint8_t s_rca2_fa1_y0 = 0;
uint8_t s_rca2_fa1_y1 = 0;
uint8_t s_rca2_fa1_s_rca2_ha_y1 = 0;
uint8_t s_rca2_fa1_y2 = 0;
uint8_t s_rca2_fa1_y3 = 0;
uint8_t s_rca2_fa1_y4 = 0;
uint8_t s_rca2_xor_1_a = 0;
uint8_t s_rca2_xor_1_b = 0;
uint8_t s_rca2_xor_1_a_1 = 0;
uint8_t s_rca2_xor_1_b_1 = 0;
uint8_t s_rca2_xor_1_y0 = 0;
uint8_t s_rca2_xor_2_s_rca2_xor_1_y0 = 0;
uint8_t s_rca2_xor_2_s_rca2_fa1_y4 = 0;
uint8_t s_rca2_xor_2_y0 = 0;
s_rca2_ha_a = ((a >> 0) & 0x01);
s_rca2_ha_b = ((b >> 0) & 0x01);
s_rca2_ha_y0 = s_rca2_ha_a ^ s_rca2_ha_b;
s_rca2_ha_y1 = s_rca2_ha_a & s_rca2_ha_b;
s_rca2_fa1_a = ((a >> 1) & 0x01);
s_rca2_fa1_b = ((b >> 1) & 0x01);
s_rca2_ha_a_0 = ((a >> 0) & 0x01);
s_rca2_ha_b_0 = ((b >> 0) & 0x01);
s_rca2_ha_y0 = s_rca2_ha_a_0 ^ s_rca2_ha_b_0;
s_rca2_ha_y1 = s_rca2_ha_a_0 & s_rca2_ha_b_0;
s_rca2_fa1_a_1 = ((a >> 1) & 0x01);
s_rca2_fa1_b_1 = ((b >> 1) & 0x01);
s_rca2_fa1_s_rca2_ha_y1 = ((s_rca2_ha_y1 >> 0) & 0x01);
s_rca2_fa1_y0 = s_rca2_fa1_a ^ s_rca2_fa1_b;
s_rca2_fa1_y1 = s_rca2_fa1_a & s_rca2_fa1_b;
s_rca2_fa1_y0 = s_rca2_fa1_a_1 ^ s_rca2_fa1_b_1;
s_rca2_fa1_y1 = s_rca2_fa1_a_1 & s_rca2_fa1_b_1;
s_rca2_fa1_y2 = s_rca2_fa1_y0 ^ s_rca2_fa1_s_rca2_ha_y1;
s_rca2_fa1_y3 = s_rca2_fa1_y0 & s_rca2_fa1_s_rca2_ha_y1;
s_rca2_fa1_y4 = s_rca2_fa1_y1 | s_rca2_fa1_y3;
s_rca2_xor_1_a = ((a >> 1) & 0x01);
s_rca2_xor_1_b = ((b >> 1) & 0x01);
s_rca2_xor_1_y0 = s_rca2_xor_1_a ^ s_rca2_xor_1_b;
s_rca2_xor_1_a_1 = ((a >> 1) & 0x01);
s_rca2_xor_1_b_1 = ((b >> 1) & 0x01);
s_rca2_xor_1_y0 = s_rca2_xor_1_a_1 ^ s_rca2_xor_1_b_1;
s_rca2_xor_2_s_rca2_xor_1_y0 = ((s_rca2_xor_1_y0 >> 0) & 0x01);
s_rca2_xor_2_s_rca2_fa1_y4 = ((s_rca2_fa1_y4 >> 0) & 0x01);
s_rca2_xor_2_y0 = s_rca2_xor_2_s_rca2_xor_1_y0 ^ s_rca2_xor_2_s_rca2_fa1_y4;

82
Tests/Flat_c_circuits/Adders/s_rca6.c → Tests/C_circuits/Flat_circuits/Adders/f_s_rca6.c
View File

@ -3,104 +3,104 @@
uint64_t s_rca6(int64_t a, int64_t b){
uint8_t out = 0;
uint8_t s_rca6_ha_a = 0;
uint8_t s_rca6_ha_b = 0;
uint8_t s_rca6_ha_a_0 = 0;
uint8_t s_rca6_ha_b_0 = 0;
uint8_t s_rca6_ha_y0 = 0;
uint8_t s_rca6_ha_y1 = 0;
uint8_t s_rca6_fa1_a = 0;
uint8_t s_rca6_fa1_b = 0;
uint8_t s_rca6_fa1_a_1 = 0;
uint8_t s_rca6_fa1_b_1 = 0;
uint8_t s_rca6_fa1_y0 = 0;
uint8_t s_rca6_fa1_y1 = 0;
uint8_t s_rca6_fa1_s_rca6_ha_y1 = 0;
uint8_t s_rca6_fa1_y2 = 0;
uint8_t s_rca6_fa1_y3 = 0;
uint8_t s_rca6_fa1_y4 = 0;
uint8_t s_rca6_fa2_a = 0;
uint8_t s_rca6_fa2_b = 0;
uint8_t s_rca6_fa2_a_2 = 0;
uint8_t s_rca6_fa2_b_2 = 0;
uint8_t s_rca6_fa2_y0 = 0;
uint8_t s_rca6_fa2_y1 = 0;
uint8_t s_rca6_fa2_s_rca6_fa1_y4 = 0;
uint8_t s_rca6_fa2_y2 = 0;
uint8_t s_rca6_fa2_y3 = 0;
uint8_t s_rca6_fa2_y4 = 0;
uint8_t s_rca6_fa3_a = 0;
uint8_t s_rca6_fa3_b = 0;
uint8_t s_rca6_fa3_a_3 = 0;
uint8_t s_rca6_fa3_b_3 = 0;
uint8_t s_rca6_fa3_y0 = 0;
uint8_t s_rca6_fa3_y1 = 0;
uint8_t s_rca6_fa3_s_rca6_fa2_y4 = 0;
uint8_t s_rca6_fa3_y2 = 0;
uint8_t s_rca6_fa3_y3 = 0;
uint8_t s_rca6_fa3_y4 = 0;
uint8_t s_rca6_fa4_a = 0;
uint8_t s_rca6_fa4_b = 0;
uint8_t s_rca6_fa4_a_4 = 0;
uint8_t s_rca6_fa4_b_4 = 0;
uint8_t s_rca6_fa4_y0 = 0;
uint8_t s_rca6_fa4_y1 = 0;
uint8_t s_rca6_fa4_s_rca6_fa3_y4 = 0;
uint8_t s_rca6_fa4_y2 = 0;
uint8_t s_rca6_fa4_y3 = 0;
uint8_t s_rca6_fa4_y4 = 0;
uint8_t s_rca6_fa5_a = 0;
uint8_t s_rca6_fa5_b = 0;
uint8_t s_rca6_fa5_a_5 = 0;
uint8_t s_rca6_fa5_b_5 = 0;
uint8_t s_rca6_fa5_y0 = 0;
uint8_t s_rca6_fa5_y1 = 0;
uint8_t s_rca6_fa5_s_rca6_fa4_y4 = 0;
uint8_t s_rca6_fa5_y2 = 0;
uint8_t s_rca6_fa5_y3 = 0;
uint8_t s_rca6_fa5_y4 = 0;
uint8_t s_rca6_xor_1_a = 0;
uint8_t s_rca6_xor_1_b = 0;
uint8_t s_rca6_xor_1_a_5 = 0;
uint8_t s_rca6_xor_1_b_5 = 0;
uint8_t s_rca6_xor_1_y0 = 0;
uint8_t s_rca6_xor_2_s_rca6_xor_1_y0 = 0;
uint8_t s_rca6_xor_2_s_rca6_fa5_y4 = 0;
uint8_t s_rca6_xor_2_y0 = 0;
s_rca6_ha_a = ((a >> 0) & 0x01);
s_rca6_ha_b = ((b >> 0) & 0x01);
s_rca6_ha_y0 = s_rca6_ha_a ^ s_rca6_ha_b;
s_rca6_ha_y1 = s_rca6_ha_a & s_rca6_ha_b;
s_rca6_fa1_a = ((a >> 1) & 0x01);
s_rca6_fa1_b = ((b >> 1) & 0x01);
s_rca6_ha_a_0 = ((a >> 0) & 0x01);
s_rca6_ha_b_0 = ((b >> 0) & 0x01);
s_rca6_ha_y0 = s_rca6_ha_a_0 ^ s_rca6_ha_b_0;
s_rca6_ha_y1 = s_rca6_ha_a_0 & s_rca6_ha_b_0;
s_rca6_fa1_a_1 = ((a >> 1) & 0x01);
s_rca6_fa1_b_1 = ((b >> 1) & 0x01);
s_rca6_fa1_s_rca6_ha_y1 = ((s_rca6_ha_y1 >> 0) & 0x01);
s_rca6_fa1_y0 = s_rca6_fa1_a ^ s_rca6_fa1_b;
s_rca6_fa1_y1 = s_rca6_fa1_a & s_rca6_fa1_b;
s_rca6_fa1_y0 = s_rca6_fa1_a_1 ^ s_rca6_fa1_b_1;
s_rca6_fa1_y1 = s_rca6_fa1_a_1 & s_rca6_fa1_b_1;
s_rca6_fa1_y2 = s_rca6_fa1_y0 ^ s_rca6_fa1_s_rca6_ha_y1;
s_rca6_fa1_y3 = s_rca6_fa1_y0 & s_rca6_fa1_s_rca6_ha_y1;
s_rca6_fa1_y4 = s_rca6_fa1_y1 | s_rca6_fa1_y3;
s_rca6_fa2_a = ((a >> 2) & 0x01);
s_rca6_fa2_b = ((b >> 2) & 0x01);
s_rca6_fa2_a_2 = ((a >> 2) & 0x01);
s_rca6_fa2_b_2 = ((b >> 2) & 0x01);
s_rca6_fa2_s_rca6_fa1_y4 = ((s_rca6_fa1_y4 >> 0) & 0x01);
s_rca6_fa2_y0 = s_rca6_fa2_a ^ s_rca6_fa2_b;
s_rca6_fa2_y1 = s_rca6_fa2_a & s_rca6_fa2_b;
s_rca6_fa2_y0 = s_rca6_fa2_a_2 ^ s_rca6_fa2_b_2;
s_rca6_fa2_y1 = s_rca6_fa2_a_2 & s_rca6_fa2_b_2;
s_rca6_fa2_y2 = s_rca6_fa2_y0 ^ s_rca6_fa2_s_rca6_fa1_y4;
s_rca6_fa2_y3 = s_rca6_fa2_y0 & s_rca6_fa2_s_rca6_fa1_y4;
s_rca6_fa2_y4 = s_rca6_fa2_y1 | s_rca6_fa2_y3;
s_rca6_fa3_a = ((a >> 3) & 0x01);
s_rca6_fa3_b = ((b >> 3) & 0x01);
s_rca6_fa3_a_3 = ((a >> 3) & 0x01);
s_rca6_fa3_b_3 = ((b >> 3) & 0x01);
s_rca6_fa3_s_rca6_fa2_y4 = ((s_rca6_fa2_y4 >> 0) & 0x01);
s_rca6_fa3_y0 = s_rca6_fa3_a ^ s_rca6_fa3_b;
s_rca6_fa3_y1 = s_rca6_fa3_a & s_rca6_fa3_b;
s_rca6_fa3_y0 = s_rca6_fa3_a_3 ^ s_rca6_fa3_b_3;
s_rca6_fa3_y1 = s_rca6_fa3_a_3 & s_rca6_fa3_b_3;
s_rca6_fa3_y2 = s_rca6_fa3_y0 ^ s_rca6_fa3_s_rca6_fa2_y4;
s_rca6_fa3_y3 = s_rca6_fa3_y0 & s_rca6_fa3_s_rca6_fa2_y4;
s_rca6_fa3_y4 = s_rca6_fa3_y1 | s_rca6_fa3_y3;
s_rca6_fa4_a = ((a >> 4) & 0x01);
s_rca6_fa4_b = ((b >> 4) & 0x01);
s_rca6_fa4_a_4 = ((a >> 4) & 0x01);
s_rca6_fa4_b_4 = ((b >> 4) & 0x01);
s_rca6_fa4_s_rca6_fa3_y4 = ((s_rca6_fa3_y4 >> 0) & 0x01);
s_rca6_fa4_y0 = s_rca6_fa4_a ^ s_rca6_fa4_b;
s_rca6_fa4_y1 = s_rca6_fa4_a & s_rca6_fa4_b;
s_rca6_fa4_y0 = s_rca6_fa4_a_4 ^ s_rca6_fa4_b_4;
s_rca6_fa4_y1 = s_rca6_fa4_a_4 & s_rca6_fa4_b_4;
s_rca6_fa4_y2 = s_rca6_fa4_y0 ^ s_rca6_fa4_s_rca6_fa3_y4;
s_rca6_fa4_y3 = s_rca6_fa4_y0 & s_rca6_fa4_s_rca6_fa3_y4;
s_rca6_fa4_y4 = s_rca6_fa4_y1 | s_rca6_fa4_y3;
s_rca6_fa5_a = ((a >> 5) & 0x01);
s_rca6_fa5_b = ((b >> 5) & 0x01);
s_rca6_fa5_a_5 = ((a >> 5) & 0x01);
s_rca6_fa5_b_5 = ((b >> 5) & 0x01);
s_rca6_fa5_s_rca6_fa4_y4 = ((s_rca6_fa4_y4 >> 0) & 0x01);
s_rca6_fa5_y0 = s_rca6_fa5_a ^ s_rca6_fa5_b;
s_rca6_fa5_y1 = s_rca6_fa5_a & s_rca6_fa5_b;
s_rca6_fa5_y0 = s_rca6_fa5_a_5 ^ s_rca6_fa5_b_5;
s_rca6_fa5_y1 = s_rca6_fa5_a_5 & s_rca6_fa5_b_5;
s_rca6_fa5_y2 = s_rca6_fa5_y0 ^ s_rca6_fa5_s_rca6_fa4_y4;
s_rca6_fa5_y3 = s_rca6_fa5_y0 & s_rca6_fa5_s_rca6_fa4_y4;
s_rca6_fa5_y4 = s_rca6_fa5_y1 | s_rca6_fa5_y3;
s_rca6_xor_1_a = ((a >> 5) & 0x01);
s_rca6_xor_1_b = ((b >> 5) & 0x01);
s_rca6_xor_1_y0 = s_rca6_xor_1_a ^ s_rca6_xor_1_b;
s_rca6_xor_1_a_5 = ((a >> 5) & 0x01);
s_rca6_xor_1_b_5 = ((b >> 5) & 0x01);
s_rca6_xor_1_y0 = s_rca6_xor_1_a_5 ^ s_rca6_xor_1_b_5;
s_rca6_xor_2_s_rca6_xor_1_y0 = ((s_rca6_xor_1_y0 >> 0) & 0x01);
s_rca6_xor_2_s_rca6_fa5_y4 = ((s_rca6_fa5_y4 >> 0) & 0x01);
s_rca6_xor_2_y0 = s_rca6_xor_2_s_rca6_xor_1_y0 ^ s_rca6_xor_2_s_rca6_fa5_y4;

106
Tests/Flat_c_circuits/Adders/s_rca8.c → Tests/C_circuits/Flat_circuits/Adders/f_s_rca8.c
View File

@ -3,136 +3,136 @@
uint64_t s_rca8(int64_t a, int64_t b){
uint64_t out = 0;
uint8_t s_rca8_ha_a = 0;
uint8_t s_rca8_ha_b = 0;
uint8_t s_rca8_ha_a_0 = 0;
uint8_t s_rca8_ha_b_0 = 0;
uint8_t s_rca8_ha_y0 = 0;
uint8_t s_rca8_ha_y1 = 0;
uint8_t s_rca8_fa1_a = 0;
uint8_t s_rca8_fa1_b = 0;
uint8_t s_rca8_fa1_a_1 = 0;
uint8_t s_rca8_fa1_b_1 = 0;
uint8_t s_rca8_fa1_y0 = 0;
uint8_t s_rca8_fa1_y1 = 0;
uint8_t s_rca8_fa1_s_rca8_ha_y1 = 0;
uint8_t s_rca8_fa1_y2 = 0;
uint8_t s_rca8_fa1_y3 = 0;
uint8_t s_rca8_fa1_y4 = 0;
uint8_t s_rca8_fa2_a = 0;
uint8_t s_rca8_fa2_b = 0;
uint8_t s_rca8_fa2_a_2 = 0;
uint8_t s_rca8_fa2_b_2 = 0;
uint8_t s_rca8_fa2_y0 = 0;
uint8_t s_rca8_fa2_y1 = 0;
uint8_t s_rca8_fa2_s_rca8_fa1_y4 = 0;
uint8_t s_rca8_fa2_y2 = 0;
uint8_t s_rca8_fa2_y3 = 0;
uint8_t s_rca8_fa2_y4 = 0;
uint8_t s_rca8_fa3_a = 0;
uint8_t s_rca8_fa3_b = 0;
uint8_t s_rca8_fa3_a_3 = 0;
uint8_t s_rca8_fa3_b_3 = 0;
uint8_t s_rca8_fa3_y0 = 0;
uint8_t s_rca8_fa3_y1 = 0;
uint8_t s_rca8_fa3_s_rca8_fa2_y4 = 0;
uint8_t s_rca8_fa3_y2 = 0;
uint8_t s_rca8_fa3_y3 = 0;
uint8_t s_rca8_fa3_y4 = 0;
uint8_t s_rca8_fa4_a = 0;
uint8_t s_rca8_fa4_b = 0;
uint8_t s_rca8_fa4_a_4 = 0;
uint8_t s_rca8_fa4_b_4 = 0;
uint8_t s_rca8_fa4_y0 = 0;
uint8_t s_rca8_fa4_y1 = 0;
uint8_t s_rca8_fa4_s_rca8_fa3_y4 = 0;
uint8_t s_rca8_fa4_y2 = 0;
uint8_t s_rca8_fa4_y3 = 0;
uint8_t s_rca8_fa4_y4 = 0;
uint8_t s_rca8_fa5_a = 0;
uint8_t s_rca8_fa5_b = 0;
uint8_t s_rca8_fa5_a_5 = 0;
uint8_t s_rca8_fa5_b_5 = 0;
uint8_t s_rca8_fa5_y0 = 0;
uint8_t s_rca8_fa5_y1 = 0;
uint8_t s_rca8_fa5_s_rca8_fa4_y4 = 0;
uint8_t s_rca8_fa5_y2 = 0;
uint8_t s_rca8_fa5_y3 = 0;
uint8_t s_rca8_fa5_y4 = 0;
uint8_t s_rca8_fa6_a = 0;
uint8_t s_rca8_fa6_b = 0;
uint8_t s_rca8_fa6_a_6 = 0;
uint8_t s_rca8_fa6_b_6 = 0;
uint8_t s_rca8_fa6_y0 = 0;
uint8_t s_rca8_fa6_y1 = 0;
uint8_t s_rca8_fa6_s_rca8_fa5_y4 = 0;
uint8_t s_rca8_fa6_y2 = 0;
uint8_t s_rca8_fa6_y3 = 0;
uint8_t s_rca8_fa6_y4 = 0;
uint8_t s_rca8_fa7_a = 0;
uint8_t s_rca8_fa7_b = 0;
uint8_t s_rca8_fa7_a_7 = 0;
uint8_t s_rca8_fa7_b_7 = 0;
uint8_t s_rca8_fa7_y0 = 0;
uint8_t s_rca8_fa7_y1 = 0;
uint8_t s_rca8_fa7_s_rca8_fa6_y4 = 0;
uint8_t s_rca8_fa7_y2 = 0;
uint8_t s_rca8_fa7_y3 = 0;
uint8_t s_rca8_fa7_y4 = 0;
uint8_t s_rca8_xor_1_a = 0;
uint8_t s_rca8_xor_1_b = 0;
uint8_t s_rca8_xor_1_a_7 = 0;
uint8_t s_rca8_xor_1_b_7 = 0;
uint8_t s_rca8_xor_1_y0 = 0;
uint8_t s_rca8_xor_2_s_rca8_xor_1_y0 = 0;
uint8_t s_rca8_xor_2_s_rca8_fa7_y4 = 0;
uint8_t s_rca8_xor_2_y0 = 0;
s_rca8_ha_a = ((a >> 0) & 0x01);
s_rca8_ha_b = ((b >> 0) & 0x01);
s_rca8_ha_y0 = s_rca8_ha_a ^ s_rca8_ha_b;
s_rca8_ha_y1 = s_rca8_ha_a & s_rca8_ha_b;
s_rca8_fa1_a = ((a >> 1) & 0x01);
s_rca8_fa1_b = ((b >> 1) & 0x01);
s_rca8_ha_a_0 = ((a >> 0) & 0x01);
s_rca8_ha_b_0 = ((b >> 0) & 0x01);
s_rca8_ha_y0 = s_rca8_ha_a_0 ^ s_rca8_ha_b_0;
s_rca8_ha_y1 = s_rca8_ha_a_0 & s_rca8_ha_b_0;
s_rca8_fa1_a_1 = ((a >> 1) & 0x01);
s_rca8_fa1_b_1 = ((b >> 1) & 0x01);
s_rca8_fa1_s_rca8_ha_y1 = ((s_rca8_ha_y1 >> 0) & 0x01);
s_rca8_fa1_y0 = s_rca8_fa1_a ^ s_rca8_fa1_b;
s_rca8_fa1_y1 = s_rca8_fa1_a & s_rca8_fa1_b;
s_rca8_fa1_y0 = s_rca8_fa1_a_1 ^ s_rca8_fa1_b_1;
s_rca8_fa1_y1 = s_rca8_fa1_a_1 & s_rca8_fa1_b_1;
s_rca8_fa1_y2 = s_rca8_fa1_y0 ^ s_rca8_fa1_s_rca8_ha_y1;
s_rca8_fa1_y3 = s_rca8_fa1_y0 & s_rca8_fa1_s_rca8_ha_y1;
s_rca8_fa1_y4 = s_rca8_fa1_y1 | s_rca8_fa1_y3;
s_rca8_fa2_a = ((a >> 2) & 0x01);
s_rca8_fa2_b = ((b >> 2) & 0x01);
s_rca8_fa2_a_2 = ((a >> 2) & 0x01);
s_rca8_fa2_b_2 = ((b >> 2) & 0x01);
s_rca8_fa2_s_rca8_fa1_y4 = ((s_rca8_fa1_y4 >> 0) & 0x01);
s_rca8_fa2_y0 = s_rca8_fa2_a ^ s_rca8_fa2_b;
s_rca8_fa2_y1 = s_rca8_fa2_a & s_rca8_fa2_b;
s_rca8_fa2_y0 = s_rca8_fa2_a_2 ^ s_rca8_fa2_b_2;
s_rca8_fa2_y1 = s_rca8_fa2_a_2 & s_rca8_fa2_b_2;
s_rca8_fa2_y2 = s_rca8_fa2_y0 ^ s_rca8_fa2_s_rca8_fa1_y4;
s_rca8_fa2_y3 = s_rca8_fa2_y0 & s_rca8_fa2_s_rca8_fa1_y4;
s_rca8_fa2_y4 = s_rca8_fa2_y1 | s_rca8_fa2_y3;
s_rca8_fa3_a = ((a >> 3) & 0x01);
s_rca8_fa3_b = ((b >> 3) & 0x01);
s_rca8_fa3_a_3 = ((a >> 3) & 0x01);
s_rca8_fa3_b_3 = ((b >> 3) & 0x01);
s_rca8_fa3_s_rca8_fa2_y4 = ((s_rca8_fa2_y4 >> 0) & 0x01);
s_rca8_fa3_y0 = s_rca8_fa3_a ^ s_rca8_fa3_b;
s_rca8_fa3_y1 = s_rca8_fa3_a & s_rca8_fa3_b;
s_rca8_fa3_y0 = s_rca8_fa3_a_3 ^ s_rca8_fa3_b_3;
s_rca8_fa3_y1 = s_rca8_fa3_a_3 & s_rca8_fa3_b_3;
s_rca8_fa3_y2 = s_rca8_fa3_y0 ^ s_rca8_fa3_s_rca8_fa2_y4;
s_rca8_fa3_y3 = s_rca8_fa3_y0 & s_rca8_fa3_s_rca8_fa2_y4;
s_rca8_fa3_y4 = s_rca8_fa3_y1 | s_rca8_fa3_y3;
s_rca8_fa4_a = ((a >> 4) & 0x01);
s_rca8_fa4_b = ((b >> 4) & 0x01);
s_rca8_fa4_a_4 = ((a >> 4) & 0x01);
s_rca8_fa4_b_4 = ((b >> 4) & 0x01);
s_rca8_fa4_s_rca8_fa3_y4 = ((s_rca8_fa3_y4 >> 0) & 0x01);
s_rca8_fa4_y0 = s_rca8_fa4_a ^ s_rca8_fa4_b;
s_rca8_fa4_y1 = s_rca8_fa4_a & s_rca8_fa4_b;
s_rca8_fa4_y0 = s_rca8_fa4_a_4 ^ s_rca8_fa4_b_4;
s_rca8_fa4_y1 = s_rca8_fa4_a_4 & s_rca8_fa4_b_4;
s_rca8_fa4_y2 = s_rca8_fa4_y0 ^ s_rca8_fa4_s_rca8_fa3_y4;
s_rca8_fa4_y3 = s_rca8_fa4_y0 & s_rca8_fa4_s_rca8_fa3_y4;
s_rca8_fa4_y4 = s_rca8_fa4_y1 | s_rca8_fa4_y3;
s_rca8_fa5_a = ((a >> 5) & 0x01);
s_rca8_fa5_b = ((b >> 5) & 0x01);
s_rca8_fa5_a_5 = ((a >> 5) & 0x01);
s_rca8_fa5_b_5 = ((b >> 5) & 0x01);
s_rca8_fa5_s_rca8_fa4_y4 = ((s_rca8_fa4_y4 >> 0) & 0x01);
s_rca8_fa5_y0 = s_rca8_fa5_a ^ s_rca8_fa5_b;
s_rca8_fa5_y1 = s_rca8_fa5_a & s_rca8_fa5_b;
s_rca8_fa5_y0 = s_rca8_fa5_a_5 ^ s_rca8_fa5_b_5;
s_rca8_fa5_y1 = s_rca8_fa5_a_5 & s_rca8_fa5_b_5;
s_rca8_fa5_y2 = s_rca8_fa5_y0 ^ s_rca8_fa5_s_rca8_fa4_y4;
s_rca8_fa5_y3 = s_rca8_fa5_y0 & s_rca8_fa5_s_rca8_fa4_y4;
s_rca8_fa5_y4 = s_rca8_fa5_y1 | s_rca8_fa5_y3;
s_rca8_fa6_a = ((a >> 6) & 0x01);
s_rca8_fa6_b = ((b >> 6) & 0x01);
s_rca8_fa6_a_6 = ((a >> 6) & 0x01);
s_rca8_fa6_b_6 = ((b >> 6) & 0x01);
s_rca8_fa6_s_rca8_fa5_y4 = ((s_rca8_fa5_y4 >> 0) & 0x01);
s_rca8_fa6_y0 = s_rca8_fa6_a ^ s_rca8_fa6_b;
s_rca8_fa6_y1 = s_rca8_fa6_a & s_rca8_fa6_b;
s_rca8_fa6_y0 = s_rca8_fa6_a_6 ^ s_rca8_fa6_b_6;
s_rca8_fa6_y1 = s_rca8_fa6_a_6 & s_rca8_fa6_b_6;
s_rca8_fa6_y2 = s_rca8_fa6_y0 ^ s_rca8_fa6_s_rca8_fa5_y4;
s_rca8_fa6_y3 = s_rca8_fa6_y0 & s_rca8_fa6_s_rca8_fa5_y4;
s_rca8_fa6_y4 = s_rca8_fa6_y1 | s_rca8_fa6_y3;
s_rca8_fa7_a = ((a >> 7) & 0x01);
s_rca8_fa7_b = ((b >> 7) & 0x01);
s_rca8_fa7_a_7 = ((a >> 7) & 0x01);
s_rca8_fa7_b_7 = ((b >> 7) & 0x01);
s_rca8_fa7_s_rca8_fa6_y4 = ((s_rca8_fa6_y4 >> 0) & 0x01);
s_rca8_fa7_y0 = s_rca8_fa7_a ^ s_rca8_fa7_b;
s_rca8_fa7_y1 = s_rca8_fa7_a & s_rca8_fa7_b;
s_rca8_fa7_y0 = s_rca8_fa7_a_7 ^ s_rca8_fa7_b_7;
s_rca8_fa7_y1 = s_rca8_fa7_a_7 & s_rca8_fa7_b_7;
s_rca8_fa7_y2 = s_rca8_fa7_y0 ^ s_rca8_fa7_s_rca8_fa6_y4;
s_rca8_fa7_y3 = s_rca8_fa7_y0 & s_rca8_fa7_s_rca8_fa6_y4;
s_rca8_fa7_y4 = s_rca8_fa7_y1 | s_rca8_fa7_y3;
s_rca8_xor_1_a = ((a >> 7) & 0x01);
s_rca8_xor_1_b = ((b >> 7) & 0x01);
s_rca8_xor_1_y0 = s_rca8_xor_1_a ^ s_rca8_xor_1_b;
s_rca8_xor_1_a_7 = ((a >> 7) & 0x01);
s_rca8_xor_1_b_7 = ((b >> 7) & 0x01);
s_rca8_xor_1_y0 = s_rca8_xor_1_a_7 ^ s_rca8_xor_1_b_7;
s_rca8_xor_2_s_rca8_xor_1_y0 = ((s_rca8_xor_1_y0 >> 0) & 0x01);
s_rca8_xor_2_s_rca8_fa7_y4 = ((s_rca8_fa7_y4 >> 0) & 0x01);
s_rca8_xor_2_y0 = s_rca8_xor_2_s_rca8_xor_1_y0 ^ s_rca8_xor_2_s_rca8_fa7_y4;

36
Tests/Flat_c_circuits/Adders/u_rca3.c → Tests/C_circuits/Flat_circuits/Adders/f_u_rca3.c
View File

@ -3,20 +3,20 @@
uint64_t u_rca3(uint64_t a, uint64_t b){
uint8_t out = 0;
uint8_t u_rca3_ha_a = 0;
uint8_t u_rca3_ha_b = 0;
uint8_t u_rca3_ha_a_0 = 0;
uint8_t u_rca3_ha_b_0 = 0;
uint8_t u_rca3_ha_y0 = 0;
uint8_t u_rca3_ha_y1 = 0;
uint8_t u_rca3_fa1_a = 0;
uint8_t u_rca3_fa1_b = 0;
uint8_t u_rca3_fa1_a_1 = 0;
uint8_t u_rca3_fa1_b_1 = 0;
uint8_t u_rca3_fa1_y0 = 0;
uint8_t u_rca3_fa1_y1 = 0;
uint8_t u_rca3_fa1_u_rca3_ha_y1 = 0;
uint8_t u_rca3_fa1_y2 = 0;
uint8_t u_rca3_fa1_y3 = 0;
uint8_t u_rca3_fa1_y4 = 0;
uint8_t u_rca3_fa2_a = 0;
uint8_t u_rca3_fa2_b = 0;
uint8_t u_rca3_fa2_a_2 = 0;
uint8_t u_rca3_fa2_b_2 = 0;
uint8_t u_rca3_fa2_y0 = 0;
uint8_t u_rca3_fa2_y1 = 0;
uint8_t u_rca3_fa2_u_rca3_fa1_y4 = 0;
@ -24,23 +24,23 @@ uint64_t u_rca3(uint64_t a, uint64_t b){
uint8_t u_rca3_fa2_y3 = 0;
uint8_t u_rca3_fa2_y4 = 0;
u_rca3_ha_a = ((a >> 0) & 0x01);
u_rca3_ha_b = ((b >> 0) & 0x01);
u_rca3_ha_y0 = u_rca3_ha_a ^ u_rca3_ha_b;
u_rca3_ha_y1 = u_rca3_ha_a & u_rca3_ha_b;
u_rca3_fa1_a = ((a >> 1) & 0x01);
u_rca3_fa1_b = ((b >> 1) & 0x01);
u_rca3_ha_a_0 = ((a >> 0) & 0x01);
u_rca3_ha_b_0 = ((b >> 0) & 0x01);
u_rca3_ha_y0 = u_rca3_ha_a_0 ^ u_rca3_ha_b_0;
u_rca3_ha_y1 = u_rca3_ha_a_0 & u_rca3_ha_b_0;
u_rca3_fa1_a_1 = ((a >> 1) & 0x01);
u_rca3_fa1_b_1 = ((b >> 1) & 0x01);
u_rca3_fa1_u_rca3_ha_y1 = ((u_rca3_ha_y1 >> 0) & 0x01);
u_rca3_fa1_y0 = u_rca3_fa1_a ^ u_rca3_fa1_b;
u_rca3_fa1_y1 = u_rca3_fa1_a & u_rca3_fa1_b;
u_rca3_fa1_y0 = u_rca3_fa1_a_1 ^ u_rca3_fa1_b_1;
u_rca3_fa1_y1 = u_rca3_fa1_a_1 & u_rca3_fa1_b_1;
u_rca3_fa1_y2 = u_rca3_fa1_y0 ^ u_rca3_fa1_u_rca3_ha_y1;
u_rca3_fa1_y3 = u_rca3_fa1_y0 & u_rca3_fa1_u_rca3_ha_y1;
u_rca3_fa1_y4 = u_rca3_fa1_y1 | u_rca3_fa1_y3;
u_rca3_fa2_a = ((a >> 2) & 0x01);
u_rca3_fa2_b = ((b >> 2) & 0x01);
u_rca3_fa2_a_2 = ((a >> 2) & 0x01);
u_rca3_fa2_b_2 = ((b >> 2) & 0x01);
u_rca3_fa2_u_rca3_fa1_y4 = ((u_rca3_fa1_y4 >> 0) & 0x01);
u_rca3_fa2_y0 = u_rca3_fa2_a ^ u_rca3_fa2_b;
u_rca3_fa2_y1 = u_rca3_fa2_a & u_rca3_fa2_b;
u_rca3_fa2_y0 = u_rca3_fa2_a_2 ^ u_rca3_fa2_b_2;
u_rca3_fa2_y1 = u_rca3_fa2_a_2 & u_rca3_fa2_b_2;
u_rca3_fa2_y2 = u_rca3_fa2_y0 ^ u_rca3_fa2_u_rca3_fa1_y4;
u_rca3_fa2_y3 = u_rca3_fa2_y0 & u_rca3_fa2_u_rca3_fa1_y4;
u_rca3_fa2_y4 = u_rca3_fa2_y1 | u_rca3_fa2_y3;

60
Tests/Flat_c_circuits/Adders/u_rca5.c → Tests/C_circuits/Flat_circuits/Adders/f_u_rca5.c
View File

@ -3,36 +3,36 @@
uint64_t u_rca5(uint64_t a, uint64_t b){
uint8_t out = 0;
uint8_t u_rca5_ha_a = 0;
uint8_t u_rca5_ha_b = 0;
uint8_t u_rca5_ha_a_0 = 0;
uint8_t u_rca5_ha_b_0 = 0;
uint8_t u_rca5_ha_y0 = 0;
uint8_t u_rca5_ha_y1 = 0;
uint8_t u_rca5_fa1_a = 0;
uint8_t u_rca5_fa1_b = 0;
uint8_t u_rca5_fa1_a_1 = 0;
uint8_t u_rca5_fa1_b_1 = 0;
uint8_t u_rca5_fa1_y0 = 0;
uint8_t u_rca5_fa1_y1 = 0;
uint8_t u_rca5_fa1_u_rca5_ha_y1 = 0;
uint8_t u_rca5_fa1_y2 = 0;
uint8_t u_rca5_fa1_y3 = 0;
uint8_t u_rca5_fa1_y4 = 0;
uint8_t u_rca5_fa2_a = 0;
uint8_t u_rca5_fa2_b = 0;
uint8_t u_rca5_fa2_a_2 = 0;
uint8_t u_rca5_fa2_b_2 = 0;
uint8_t u_rca5_fa2_y0 = 0;
uint8_t u_rca5_fa2_y1 = 0;
uint8_t u_rca5_fa2_u_rca5_fa1_y4 = 0;
uint8_t u_rca5_fa2_y2 = 0;
uint8_t u_rca5_fa2_y3 = 0;
uint8_t u_rca5_fa2_y4 = 0;
uint8_t u_rca5_fa3_a = 0;
uint8_t u_rca5_fa3_b = 0;
uint8_t u_rca5_fa3_a_3 = 0;
uint8_t u_rca5_fa3_b_3 = 0;
uint8_t u_rca5_fa3_y0 = 0;
uint8_t u_rca5_fa3_y1 = 0;
uint8_t u_rca5_fa3_u_rca5_fa2_y4 = 0;
uint8_t u_rca5_fa3_y2 = 0;
uint8_t u_rca5_fa3_y3 = 0;
uint8_t u_rca5_fa3_y4 = 0;
uint8_t u_rca5_fa4_a = 0;
uint8_t u_rca5_fa4_b = 0;
uint8_t u_rca5_fa4_a_4 = 0;
uint8_t u_rca5_fa4_b_4 = 0;
uint8_t u_rca5_fa4_y0 = 0;
uint8_t u_rca5_fa4_y1 = 0;
uint8_t u_rca5_fa4_u_rca5_fa3_y4 = 0;
@ -40,39 +40,39 @@ uint64_t u_rca5(uint64_t a, uint64_t b){
uint8_t u_rca5_fa4_y3 = 0;
uint8_t u_rca5_fa4_y4 = 0;
u_rca5_ha_a = ((a >> 0) & 0x01);
u_rca5_ha_b = ((b >> 0) & 0x01);
u_rca5_ha_y0 = u_rca5_ha_a ^ u_rca5_ha_b;
u_rca5_ha_y1 = u_rca5_ha_a & u_rca5_ha_b;
u_rca5_fa1_a = ((a >> 1) & 0x01);
u_rca5_fa1_b = ((b >> 1) & 0x01);
u_rca5_ha_a_0 = ((a >> 0) & 0x01);
u_rca5_ha_b_0 = ((b >> 0) & 0x01);
u_rca5_ha_y0 = u_rca5_ha_a_0 ^ u_rca5_ha_b_0;
u_rca5_ha_y1 = u_rca5_ha_a_0 & u_rca5_ha_b_0;
u_rca5_fa1_a_1 = ((a >> 1) & 0x01);
u_rca5_fa1_b_1 = ((b >> 1) & 0x01);
u_rca5_fa1_u_rca5_ha_y1 = ((u_rca5_ha_y1 >> 0) & 0x01);
u_rca5_fa1_y0 = u_rca5_fa1_a ^ u_rca5_fa1_b;
u_rca5_fa1_y1 = u_rca5_fa1_a & u_rca5_fa1_b;
u_rca5_fa1_y0 = u_rca5_fa1_a_1 ^ u_rca5_fa1_b_1;
u_rca5_fa1_y1 = u_rca5_fa1_a_1 & u_rca5_fa1_b_1;
u_rca5_fa1_y2 = u_rca5_fa1_y0 ^ u_rca5_fa1_u_rca5_ha_y1;
u_rca5_fa1_y3 = u_rca5_fa1_y0 & u_rca5_fa1_u_rca5_ha_y1;
u_rca5_fa1_y4 = u_rca5_fa1_y1 | u_rca5_fa1_y3;
u_rca5_fa2_a = ((a >> 2) & 0x01);
u_rca5_fa2_b = ((b >> 2) & 0x01);
u_rca5_fa2_a_2 = ((a >> 2) & 0x01);
u_rca5_fa2_b_2 = ((b >> 2) & 0x01);
u_rca5_fa2_u_rca5_fa1_y4 = ((u_rca5_fa1_y4 >> 0) & 0x01);
u_rca5_fa2_y0 = u_rca5_fa2_a ^ u_rca5_fa2_b;
u_rca5_fa2_y1 = u_rca5_fa2_a & u_rca5_fa2_b;
u_rca5_fa2_y0 = u_rca5_fa2_a_2 ^ u_rca5_fa2_b_2;
u_rca5_fa2_y1 = u_rca5_fa2_a_2 & u_rca5_fa2_b_2;
u_rca5_fa2_y2 = u_rca5_fa2_y0 ^ u_rca5_fa2_u_rca5_fa1_y4;
u_rca5_fa2_y3 = u_rca5_fa2_y0 & u_rca5_fa2_u_rca5_fa1_y4;
u_rca5_fa2_y4 = u_rca5_fa2_y1 | u_rca5_fa2_y3;
u_rca5_fa3_a = ((a >> 3) & 0x01);
u_rca5_fa3_b = ((b >> 3) & 0x01);
u_rca5_fa3_a_3 = ((a >> 3) & 0x01);
u_rca5_fa3_b_3 = ((b >> 3) & 0x01);
u_rca5_fa3_u_rca5_fa2_y4 = ((u_rca5_fa2_y4 >> 0) & 0x01);
u_rca5_fa3_y0 = u_rca5_fa3_a ^ u_rca5_fa3_b;
u_rca5_fa3_y1 = u_rca5_fa3_a & u_rca5_fa3_b;
u_rca5_fa3_y0 = u_rca5_fa3_a_3 ^ u_rca5_fa3_b_3;
u_rca5_fa3_y1 = u_rca5_fa3_a_3 & u_rca5_fa3_b_3;
u_rca5_fa3_y2 = u_rca5_fa3_y0 ^ u_rca5_fa3_u_rca5_fa2_y4;
u_rca5_fa3_y3 = u_rca5_fa3_y0 & u_rca5_fa3_u_rca5_fa2_y4;
u_rca5_fa3_y4 = u_rca5_fa3_y1 | u_rca5_fa3_y3;
u_rca5_fa4_a = ((a >> 4) & 0x01);
u_rca5_fa4_b = ((b >> 4) & 0x01);
u_rca5_fa4_a_4 = ((a >> 4) & 0x01);
u_rca5_fa4_b_4 = ((b >> 4) & 0x01);
u_rca5_fa4_u_rca5_fa3_y4 = ((u_rca5_fa3_y4 >> 0) & 0x01);
u_rca5_fa4_y0 = u_rca5_fa4_a ^ u_rca5_fa4_b;
u_rca5_fa4_y1 = u_rca5_fa4_a & u_rca5_fa4_b;
u_rca5_fa4_y0 = u_rca5_fa4_a_4 ^ u_rca5_fa4_b_4;
u_rca5_fa4_y1 = u_rca5_fa4_a_4 & u_rca5_fa4_b_4;
u_rca5_fa4_y2 = u_rca5_fa4_y0 ^ u_rca5_fa4_u_rca5_fa3_y4;
u_rca5_fa4_y3 = u_rca5_fa4_y0 & u_rca5_fa4_u_rca5_fa3_y4;
u_rca5_fa4_y4 = u_rca5_fa4_y1 | u_rca5_fa4_y3;

96
Tests/Flat_c_circuits/Adders/u_rca8.c → Tests/C_circuits/Flat_circuits/Adders/f_u_rca8.c
View File

@ -3,60 +3,60 @@
uint64_t u_rca8(uint64_t a, uint64_t b){
uint64_t out = 0;
uint8_t u_rca8_ha_a = 0;
uint8_t u_rca8_ha_b = 0;
uint8_t u_rca8_ha_a_0 = 0;
uint8_t u_rca8_ha_b_0 = 0;
uint8_t u_rca8_ha_y0 = 0;
uint8_t u_rca8_ha_y1 = 0;
uint8_t u_rca8_fa1_a = 0;
uint8_t u_rca8_fa1_b = 0;
uint8_t u_rca8_fa1_a_1 = 0;
uint8_t u_rca8_fa1_b_1 = 0;
uint8_t u_rca8_fa1_y0 = 0;
uint8_t u_rca8_fa1_y1 = 0;
uint8_t u_rca8_fa1_u_rca8_ha_y1 = 0;
uint8_t u_rca8_fa1_y2 = 0;
uint8_t u_rca8_fa1_y3 = 0;
uint8_t u_rca8_fa1_y4 = 0;
uint8_t u_rca8_fa2_a = 0;
uint8_t u_rca8_fa2_b = 0;
uint8_t u_rca8_fa2_a_2 = 0;
uint8_t u_rca8_fa2_b_2 = 0;
uint8_t u_rca8_fa2_y0 = 0;
uint8_t u_rca8_fa2_y1 = 0;
uint8_t u_rca8_fa2_u_rca8_fa1_y4 = 0;
uint8_t u_rca8_fa2_y2 = 0;
uint8_t u_rca8_fa2_y3 = 0;
uint8_t u_rca8_fa2_y4 = 0;
uint8_t u_rca8_fa3_a = 0;
uint8_t u_rca8_fa3_b = 0;
uint8_t u_rca8_fa3_a_3 = 0;
uint8_t u_rca8_fa3_b_3 = 0;
uint8_t u_rca8_fa3_y0 = 0;
uint8_t u_rca8_fa3_y1 = 0;
uint8_t u_rca8_fa3_u_rca8_fa2_y4 = 0;
uint8_t u_rca8_fa3_y2 = 0;
uint8_t u_rca8_fa3_y3 = 0;
uint8_t u_rca8_fa3_y4 = 0;
uint8_t u_rca8_fa4_a = 0;
uint8_t u_rca8_fa4_b = 0;
uint8_t u_rca8_fa4_a_4 = 0;
uint8_t u_rca8_fa4_b_4 = 0;
uint8_t u_rca8_fa4_y0 = 0;
uint8_t u_rca8_fa4_y1 = 0;
uint8_t u_rca8_fa4_u_rca8_fa3_y4 = 0;
uint8_t u_rca8_fa4_y2 = 0;
uint8_t u_rca8_fa4_y3 = 0;
uint8_t u_rca8_fa4_y4 = 0;
uint8_t u_rca8_fa5_a = 0;
uint8_t u_rca8_fa5_b = 0;
uint8_t u_rca8_fa5_a_5 = 0;
uint8_t u_rca8_fa5_b_5 = 0;
uint8_t u_rca8_fa5_y0 = 0;
uint8_t u_rca8_fa5_y1 = 0;
uint8_t u_rca8_fa5_u_rca8_fa4_y4 = 0;
uint8_t u_rca8_fa5_y2 = 0;
uint8_t u_rca8_fa5_y3 = 0;
uint8_t u_rca8_fa5_y4 = 0;
uint8_t u_rca8_fa6_a = 0;
uint8_t u_rca8_fa6_b = 0;
uint8_t u_rca8_fa6_a_6 = 0;
uint8_t u_rca8_fa6_b_6 = 0;
uint8_t u_rca8_fa6_y0 = 0;
uint8_t u_rca8_fa6_y1 = 0;
uint8_t u_rca8_fa6_u_rca8_fa5_y4 = 0;
uint8_t u_rca8_fa6_y2 = 0;
uint8_t u_rca8_fa6_y3 = 0;
uint8_t u_rca8_fa6_y4 = 0;
uint8_t u_rca8_fa7_a = 0;
uint8_t u_rca8_fa7_b = 0;
uint8_t u_rca8_fa7_a_7 = 0;
uint8_t u_rca8_fa7_b_7 = 0;
uint8_t u_rca8_fa7_y0 = 0;
uint8_t u_rca8_fa7_y1 = 0;
uint8_t u_rca8_fa7_u_rca8_fa6_y4 = 0;
@ -64,63 +64,63 @@ uint64_t u_rca8(uint64_t a, uint64_t b){
uint8_t u_rca8_fa7_y3 = 0;
uint8_t u_rca8_fa7_y4 = 0;
u_rca8_ha_a = ((a >> 0) & 0x01);
u_rca8_ha_b = ((b >> 0) & 0x01);
u_rca8_ha_y0 = u_rca8_ha_a ^ u_rca8_ha_b;
u_rca8_ha_y1 = u_rca8_ha_a & u_rca8_ha_b;
u_rca8_fa1_a = ((a >> 1) & 0x01);
u_rca8_fa1_b = ((b >> 1) & 0x01);
u_rca8_ha_a_0 = ((a >> 0) & 0x01);
u_rca8_ha_b_0 = ((b >> 0) & 0x01);
u_rca8_ha_y0 = u_rca8_ha_a_0 ^ u_rca8_ha_b_0;
u_rca8_ha_y1 = u_rca8_ha_a_0 & u_rca8_ha_b_0;
u_rca8_fa1_a_1 = ((a >> 1) & 0x01);
u_rca8_fa1_b_1 = ((b >> 1) & 0x01);
u_rca8_fa1_u_rca8_ha_y1 = ((u_rca8_ha_y1 >> 0) & 0x01);
u_rca8_fa1_y0 = u_rca8_fa1_a ^ u_rca8_fa1_b;
u_rca8_fa1_y1 = u_rca8_fa1_a & u_rca8_fa1_b;
u_rca8_fa1_y0 = u_rca8_fa1_a_1 ^ u_rca8_fa1_b_1;
u_rca8_fa1_y1 = u_rca8_fa1_a_1 & u_rca8_fa1_b_1;
u_rca8_fa1_y2 = u_rca8_fa1_y0 ^ u_rca8_fa1_u_rca8_ha_y1;
u_rca8_fa1_y3 = u_rca8_fa1_y0 & u_rca8_fa1_u_rca8_ha_y1;
u_rca8_fa1_y4 = u_rca8_fa1_y1 | u_rca8_fa1_y3;
u_rca8_fa2_a = ((a >> 2) & 0x01);
u_rca8_fa2_b = ((b >> 2) & 0x01);
u_rca8_fa2_a_2 = ((a >> 2) & 0x01);
u_rca8_fa2_b_2 = ((b >> 2) & 0x01);
u_rca8_fa2_u_rca8_fa1_y4 = ((u_rca8_fa1_y4 >> 0) & 0x01);
u_rca8_fa2_y0 = u_rca8_fa2_a ^ u_rca8_fa2_b;
u_rca8_fa2_y1 = u_rca8_fa2_a & u_rca8_fa2_b;
u_rca8_fa2_y0 = u_rca8_fa2_a_2 ^ u_rca8_fa2_b_2;
u_rca8_fa2_y1 = u_rca8_fa2_a_2 & u_rca8_fa2_b_2;
u_rca8_fa2_y2 = u_rca8_fa2_y0 ^ u_rca8_fa2_u_rca8_fa1_y4;
u_rca8_fa2_y3 = u_rca8_fa2_y0 & u_rca8_fa2_u_rca8_fa1_y4;
u_rca8_fa2_y4 = u_rca8_fa2_y1 | u_rca8_fa2_y3;
u_rca8_fa3_a = ((a >> 3) & 0x01);
u_rca8_fa3_b = ((b >> 3) & 0x01);
u_rca8_fa3_a_3 = ((a >> 3) & 0x01);
u_rca8_fa3_b_3 = ((b >> 3) & 0x01);
u_rca8_fa3_u_rca8_fa2_y4 = ((u_rca8_fa2_y4 >> 0) & 0x01);
u_rca8_fa3_y0 = u_rca8_fa3_a ^ u_rca8_fa3_b;
u_rca8_fa3_y1 = u_rca8_fa3_a & u_rca8_fa3_b;
u_rca8_fa3_y0 = u_rca8_fa3_a_3 ^ u_rca8_fa3_b_3;
u_rca8_fa3_y1 = u_rca8_fa3_a_3 & u_rca8_fa3_b_3;
u_rca8_fa3_y2 = u_rca8_fa3_y0 ^ u_rca8_fa3_u_rca8_fa2_y4;
u_rca8_fa3_y3 = u_rca8_fa3_y0 & u_rca8_fa3_u_rca8_fa2_y4;
u_rca8_fa3_y4 = u_rca8_fa3_y1 | u_rca8_fa3_y3;
u_rca8_fa4_a = ((a >> 4) & 0x01);
u_rca8_fa4_b = ((b >> 4) & 0x01);
u_rca8_fa4_a_4 = ((a >> 4) & 0x01);
u_rca8_fa4_b_4 = ((b >> 4) & 0x01);
u_rca8_fa4_u_rca8_fa3_y4 = ((u_rca8_fa3_y4 >> 0) & 0x01);
u_rca8_fa4_y0 = u_rca8_fa4_a ^ u_rca8_fa4_b;
u_rca8_fa4_y1 = u_rca8_fa4_a & u_rca8_fa4_b;
u_rca8_fa4_y0 = u_rca8_fa4_a_4 ^ u_rca8_fa4_b_4;
u_rca8_fa4_y1 = u_rca8_fa4_a_4 & u_rca8_fa4_b_4;
u_rca8_fa4_y2 = u_rca8_fa4_y0 ^ u_rca8_fa4_u_rca8_fa3_y4;
u_rca8_fa4_y3 = u_rca8_fa4_y0 & u_rca8_fa4_u_rca8_fa3_y4;
u_rca8_fa4_y4 = u_rca8_fa4_y1 | u_rca8_fa4_y3;
u_rca8_fa5_a = ((a >> 5) & 0x01);
u_rca8_fa5_b = ((b >> 5) & 0x01);
u_rca8_fa5_a_5 = ((a >> 5) & 0x01);
u_rca8_fa5_b_5 = ((b >> 5) & 0x01);
u_rca8_fa5_u_rca8_fa4_y4 = ((u_rca8_fa4_y4 >> 0) & 0x01);
u_rca8_fa5_y0 = u_rca8_fa5_a ^ u_rca8_fa5_b;
u_rca8_fa5_y1 = u_rca8_fa5_a & u_rca8_fa5_b;
u_rca8_fa5_y0 = u_rca8_fa5_a_5 ^ u_rca8_fa5_b_5;
u_rca8_fa5_y1 = u_rca8_fa5_a_5 & u_rca8_fa5_b_5;
u_rca8_fa5_y2 = u_rca8_fa5_y0 ^ u_rca8_fa5_u_rca8_fa4_y4;
u_rca8_fa5_y3 = u_rca8_fa5_y0 & u_rca8_fa5_u_rca8_fa4_y4;
u_rca8_fa5_y4 = u_rca8_fa5_y1 | u_rca8_fa5_y3;
u_rca8_fa6_a = ((a >> 6) & 0x01);
u_rca8_fa6_b = ((b >> 6) & 0x01);
u_rca8_fa6_a_6 = ((a >> 6) & 0x01);
u_rca8_fa6_b_6 = ((b >> 6) & 0x01);
u_rca8_fa6_u_rca8_fa5_y4 = ((u_rca8_fa5_y4 >> 0) & 0x01);
u_rca8_fa6_y0 = u_rca8_fa6_a ^ u_rca8_fa6_b;
u_rca8_fa6_y1 = u_rca8_fa6_a & u_rca8_fa6_b;
u_rca8_fa6_y0 = u_rca8_fa6_a_6 ^ u_rca8_fa6_b_6;
u_rca8_fa6_y1 = u_rca8_fa6_a_6 & u_rca8_fa6_b_6;
u_rca8_fa6_y2 = u_rca8_fa6_y0 ^ u_rca8_fa6_u_rca8_fa5_y4;
u_rca8_fa6_y3 = u_rca8_fa6_y0 & u_rca8_fa6_u_rca8_fa5_y4;
u_rca8_fa6_y4 = u_rca8_fa6_y1 | u_rca8_fa6_y3;
u_rca8_fa7_a = ((a >> 7) & 0x01);
u_rca8_fa7_b = ((b >> 7) & 0x01);
u_rca8_fa7_a_7 = ((a >> 7) & 0x01);
u_rca8_fa7_b_7 = ((b >> 7) & 0x01);
u_rca8_fa7_u_rca8_fa6_y4 = ((u_rca8_fa6_y4 >> 0) & 0x01);
u_rca8_fa7_y0 = u_rca8_fa7_a ^ u_rca8_fa7_b;
u_rca8_fa7_y1 = u_rca8_fa7_a & u_rca8_fa7_b;
u_rca8_fa7_y0 = u_rca8_fa7_a_7 ^ u_rca8_fa7_b_7;
u_rca8_fa7_y1 = u_rca8_fa7_a_7 & u_rca8_fa7_b_7;
u_rca8_fa7_y2 = u_rca8_fa7_y0 ^ u_rca8_fa7_u_rca8_fa6_y4;
u_rca8_fa7_y3 = u_rca8_fa7_y0 & u_rca8_fa7_u_rca8_fa6_y4;
u_rca8_fa7_y4 = u_rca8_fa7_y1 | u_rca8_fa7_y3;

41
Tests/C_circuits/Hierarchical_circuits/Adders/h_fa.c Normal file
View File

@ -0,0 +1,41 @@
#include <stdio.h>
#include <stdint.h>
uint8_t xor_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) ^ ((b >> 0) & 0x01);
}
uint8_t and_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) & ((b >> 0) & 0x01);
}
uint8_t or_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) | ((b >> 0) & 0x01);
}
uint8_t h_fa(uint8_t a, uint8_t b, uint8_t cout){
uint8_t out = 0;
uint8_t xor_1 = 0;
uint8_t and_1 = 0;
uint8_t and_2 = 0;
xor_1 = xor_gate(a, b);
and_1 = and_gate(a, b);
and_2 = and_gate(xor_1, cout);
out |= (xor_gate(xor_1, cout) & 0x01) << 0;
out |= (or_gate(and_1, and_2) & 0x01) << 1;
return out;
}
#include <assert.h>
int main(){
for (int i = 0; i < 2; i++){
for (int j = 0; j < 2; j++){
for (int k = 0; k < 2; k++){
assert((i + j + k) == h_fa(i,j,k));
}
}
}
return 0;
}

28
Tests/C_circuits/Hierarchical_circuits/Adders/h_ha.c Normal file
View File

@ -0,0 +1,28 @@
#include <stdio.h>
#include <stdint.h>
uint8_t xor_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) ^ ((b >> 0) & 0x01);
}
uint8_t and_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) & ((b >> 0) & 0x01);
}
uint8_t h_ha(uint8_t a, uint8_t b){
uint8_t out = 0;
out |= (xor_gate(a, b) & 0x01) << 0;
out |= (and_gate(a, b) & 0x01) << 1;
return out;
}
#include <assert.h>
int main(){
for (int i = 0; i < 2; i++){
for (int j = 0; j < 2; j++){
assert((i + j) == h_ha(i,j));
}
}
return 0;
}

79
Tests/C_circuits/Hierarchical_circuits/Adders/h_s_rca2.c Normal file
View File

@ -0,0 +1,79 @@
#include <stdio.h>
#include <stdint.h>
uint8_t xor_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) ^ ((b >> 0) & 0x01);
}
uint8_t and_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) & ((b >> 0) & 0x01);
}
uint8_t or_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) | ((b >> 0) & 0x01);
}
uint8_t ha(uint8_t a_0, uint8_t b_0){
uint8_t out = 0;
out |= (xor_gate(a_0, b_0) & 0x01) << 0;
out |= (and_gate(a_0, b_0) & 0x01) << 1;
return out;
}
uint8_t fa(uint8_t a_1, uint8_t b_1, uint8_t cin){
uint8_t out = 0;
uint8_t xor_1 = 0;
uint8_t and_1 = 0;
uint8_t and_2 = 0;
xor_1 = xor_gate(a_1, b_1);
and_1 = and_gate(a_1, b_1);
and_2 = and_gate(xor_1, cin);
out |= (xor_gate(xor_1, cin) & 0x01) << 0;
out |= (or_gate(and_1, and_2) & 0x01) << 1;
return out;
}
uint64_t s_rca2(int64_t a, int64_t b){
uint8_t out = 0;
uint8_t a_0 = 0;
uint8_t a_1 = 0;
uint8_t b_0 = 0;
uint8_t b_1 = 0;
uint8_t cout_0 = 0;
uint8_t cout_1 = 0;
uint8_t s_rca2_xor_1_y0 = 0;
a_0 = ((a >> 0) & 0x01);
a_1 = ((a >> 1) & 0x01);
b_0 = ((b >> 0) & 0x01);
b_1 = ((b >> 1) & 0x01);
cout_0 = (ha(a_0, b_0) >> 1) & 0x01;
cout_1 = (fa(a_1, b_1, cout_0) >> 1) & 0x01;
s_rca2_xor_1_y0 = xor_gate(a_1, b_1);
out |= ((ha(a_0, b_0) >> 0) & 0x01) << 0;
out |= ((fa(a_1, b_1, cout_0) >> 0) & 0x01) << 1;
out |= (xor_gate(s_rca2_xor_1_y0, cout_1) & 0x01) << 2;
return out;
}
#include <assert.h>
int main(){
int result = 0;
for (int i = -2; i < 2; i++){
for (int j = -2; j < 2; j++){
result = i + j;
// Calculating 2's complement in case of negative sum
if (result < 0) {
result = 8 + result;
}
assert(result == (int)s_rca2(i,j));
}
}
return 0;
}

93
Tests/C_circuits/Hierarchical_circuits/Adders/h_s_rca4.c Normal file
View File

@ -0,0 +1,93 @@
#include <stdio.h>
#include <stdint.h>
uint8_t xor_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) ^ ((b >> 0) & 0x01);
}
uint8_t and_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) & ((b >> 0) & 0x01);
}
uint8_t or_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) | ((b >> 0) & 0x01);
}
uint8_t ha(uint8_t a_0, uint8_t b_0){
uint8_t out = 0;
out |= (xor_gate(a_0, b_0) & 0x01) << 0;
out |= (and_gate(a_0, b_0) & 0x01) << 1;
return out;
}
uint8_t fa(uint8_t a_3, uint8_t b_3, uint8_t cin){
uint8_t out = 0;
uint8_t xor_1 = 0;
uint8_t and_1 = 0;
uint8_t and_2 = 0;
xor_1 = xor_gate(a_3, b_3);
and_1 = and_gate(a_3, b_3);
and_2 = and_gate(xor_1, cin);
out |= (xor_gate(xor_1, cin) & 0x01) << 0;
out |= (or_gate(and_1, and_2) & 0x01) << 1;
return out;
}
uint64_t s_rca4(int64_t a, int64_t b){
uint8_t out = 0;
uint8_t a_0 = 0;
uint8_t a_1 = 0;
uint8_t a_2 = 0;
uint8_t a_3 = 0;
uint8_t b_0 = 0;
uint8_t b_1 = 0;
uint8_t b_2 = 0;
uint8_t b_3 = 0;
uint8_t cout_0 = 0;
uint8_t cout_1 = 0;
uint8_t cout_2 = 0;
uint8_t cout_3 = 0;
uint8_t s_rca4_xor_1_y0 = 0;
a_0 = ((a >> 0) & 0x01);
a_1 = ((a >> 1) & 0x01);
a_2 = ((a >> 2) & 0x01);
a_3 = ((a >> 3) & 0x01);
b_0 = ((b >> 0) & 0x01);
b_1 = ((b >> 1) & 0x01);
b_2 = ((b >> 2) & 0x01);
b_3 = ((b >> 3) & 0x01);
cout_0 = (ha(a_0, b_0) >> 1) & 0x01;
cout_1 = (fa(a_1, b_1, cout_0) >> 1) & 0x01;
cout_2 = (fa(a_2, b_2, cout_1) >> 1) & 0x01;
cout_3 = (fa(a_3, b_3, cout_2) >> 1) & 0x01;
s_rca4_xor_1_y0 = xor_gate(a_3, b_3);
out |= ((ha(a_0, b_0) >> 0) & 0x01) << 0;
out |= ((fa(a_1, b_1, cout_0) >> 0) & 0x01) << 1;
out |= ((fa(a_2, b_2, cout_1) >> 0) & 0x01) << 2;
out |= ((fa(a_3, b_3, cout_2) >> 0) & 0x01) << 3;
out |= (xor_gate(s_rca4_xor_1_y0, cout_3) & 0x01) << 4;
return out;
}
#include <assert.h>
int main(){
int result = 0;
for (int i = -8; i < 8; i++){
for (int j = -8; j < 8; j++){
result = i + j;
// Calculating 2's complement in case of negative sum
if (result < 0) {
result = 32 + result;
}
assert(result == (int)s_rca4(i,j));
}
}
return 0;
}

107
Tests/C_circuits/Hierarchical_circuits/Adders/h_s_rca6.c Normal file
View File

@ -0,0 +1,107 @@
#include <stdio.h>
#include <stdint.h>
uint8_t xor_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) ^ ((b >> 0) & 0x01);
}
uint8_t and_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) & ((b >> 0) & 0x01);
}
uint8_t or_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) | ((b >> 0) & 0x01);
}
uint8_t ha(uint8_t a_0, uint8_t b_0){
uint8_t out = 0;
out |= (xor_gate(a_0, b_0) & 0x01) << 0;
out |= (and_gate(a_0, b_0) & 0x01) << 1;
return out;
}
uint8_t fa(uint8_t a_5, uint8_t b_5, uint8_t cin){
uint8_t out = 0;
uint8_t xor_1 = 0;
uint8_t and_1 = 0;
uint8_t and_2 = 0;
xor_1 = xor_gate(a_5, b_5);
and_1 = and_gate(a_5, b_5);
and_2 = and_gate(xor_1, cin);
out |= (xor_gate(xor_1, cin) & 0x01) << 0;
out |= (or_gate(and_1, and_2) & 0x01) << 1;
return out;
}
uint64_t s_rca6(int64_t a, int64_t b){
uint8_t out = 0;
uint8_t a_0 = 0;
uint8_t a_1 = 0;
uint8_t a_2 = 0;
uint8_t a_3 = 0;
uint8_t a_4 = 0;
uint8_t a_5 = 0;
uint8_t b_0 = 0;
uint8_t b_1 = 0;
uint8_t b_2 = 0;
uint8_t b_3 = 0;
uint8_t b_4 = 0;
uint8_t b_5 = 0;
uint8_t cout_0 = 0;
uint8_t cout_1 = 0;
uint8_t cout_2 = 0;
uint8_t cout_3 = 0;
uint8_t cout_4 = 0;
uint8_t cout_5 = 0;
uint8_t s_rca6_xor_1_y0 = 0;
a_0 = ((a >> 0) & 0x01);
a_1 = ((a >> 1) & 0x01);
a_2 = ((a >> 2) & 0x01);
a_3 = ((a >> 3) & 0x01);
a_4 = ((a >> 4) & 0x01);
a_5 = ((a >> 5) & 0x01);
b_0 = ((b >> 0) & 0x01);
b_1 = ((b >> 1) & 0x01);
b_2 = ((b >> 2) & 0x01);
b_3 = ((b >> 3) & 0x01);
b_4 = ((b >> 4) & 0x01);
b_5 = ((b >> 5) & 0x01);
cout_0 = (ha(a_0, b_0) >> 1) & 0x01;
cout_1 = (fa(a_1, b_1, cout_0) >> 1) & 0x01;
cout_2 = (fa(a_2, b_2, cout_1) >> 1) & 0x01;
cout_3 = (fa(a_3, b_3, cout_2) >> 1) & 0x01;
cout_4 = (fa(a_4, b_4, cout_3) >> 1) & 0x01;
cout_5 = (fa(a_5, b_5, cout_4) >> 1) & 0x01;
s_rca6_xor_1_y0 = xor_gate(a_5, b_5);
out |= ((ha(a_0, b_0) >> 0) & 0x01) << 0;
out |= ((fa(a_1, b_1, cout_0) >> 0) & 0x01) << 1;
out |= ((fa(a_2, b_2, cout_1) >> 0) & 0x01) << 2;
out |= ((fa(a_3, b_3, cout_2) >> 0) & 0x01) << 3;
out |= ((fa(a_4, b_4, cout_3) >> 0) & 0x01) << 4;
out |= ((fa(a_5, b_5, cout_4) >> 0) & 0x01) << 5;
out |= (xor_gate(s_rca6_xor_1_y0, cout_5) & 0x01) << 6;
return out;
}
#include <assert.h>
int main(){
int result = 0;
for (int i = -32; i < 32; i++){
for (int j = -32; j < 32; j++){
result = i + j;
// Calculating 2's complement in case of negative sum
if (result < 0) {
result = 128 + result;
}
assert(result == (int)s_rca6(i,j));
}
}
return 0;
}

121
Tests/C_circuits/Hierarchical_circuits/Adders/h_s_rca8.c Normal file
View File

@ -0,0 +1,121 @@
#include <stdio.h>
#include <stdint.h>
uint8_t xor_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) ^ ((b >> 0) & 0x01);
}
uint8_t and_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) & ((b >> 0) & 0x01);
}
uint8_t or_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) | ((b >> 0) & 0x01);
}
uint8_t ha(uint8_t a_0, uint8_t b_0){
uint8_t out = 0;
out |= (xor_gate(a_0, b_0) & 0x01) << 0;
out |= (and_gate(a_0, b_0) & 0x01) << 1;
return out;
}
uint8_t fa(uint8_t a_7, uint8_t b_7, uint8_t cin){
uint8_t out = 0;
uint8_t xor_1 = 0;
uint8_t and_1 = 0;
uint8_t and_2 = 0;
xor_1 = xor_gate(a_7, b_7);
and_1 = and_gate(a_7, b_7);
and_2 = and_gate(xor_1, cin);
out |= (xor_gate(xor_1, cin) & 0x01) << 0;
out |= (or_gate(and_1, and_2) & 0x01) << 1;
return out;
}
uint64_t s_rca8(int64_t a, int64_t b){
uint64_t out = 0;
uint8_t a_0 = 0;
uint8_t a_1 = 0;
uint8_t a_2 = 0;
uint8_t a_3 = 0;
uint8_t a_4 = 0;
uint8_t a_5 = 0;
uint8_t a_6 = 0;
uint8_t a_7 = 0;
uint8_t b_0 = 0;
uint8_t b_1 = 0;
uint8_t b_2 = 0;
uint8_t b_3 = 0;
uint8_t b_4 = 0;
uint8_t b_5 = 0;
uint8_t b_6 = 0;
uint8_t b_7 = 0;
uint8_t cout_0 = 0;
uint8_t cout_1 = 0;
uint8_t cout_2 = 0;
uint8_t cout_3 = 0;
uint8_t cout_4 = 0;
uint8_t cout_5 = 0;
uint8_t cout_6 = 0;
uint8_t cout_7 = 0;
uint8_t s_rca8_xor_1_y0 = 0;
a_0 = ((a >> 0) & 0x01);
a_1 = ((a >> 1) & 0x01);
a_2 = ((a >> 2) & 0x01);
a_3 = ((a >> 3) & 0x01);
a_4 = ((a >> 4) & 0x01);
a_5 = ((a >> 5) & 0x01);
a_6 = ((a >> 6) & 0x01);
a_7 = ((a >> 7) & 0x01);
b_0 = ((b >> 0) & 0x01);
b_1 = ((b >> 1) & 0x01);
b_2 = ((b >> 2) & 0x01);
b_3 = ((b >> 3) & 0x01);
b_4 = ((b >> 4) & 0x01);
b_5 = ((b >> 5) & 0x01);
b_6 = ((b >> 6) & 0x01);
b_7 = ((b >> 7) & 0x01);
cout_0 = (ha(a_0, b_0) >> 1) & 0x01;
cout_1 = (fa(a_1, b_1, cout_0) >> 1) & 0x01;
cout_2 = (fa(a_2, b_2, cout_1) >> 1) & 0x01;
cout_3 = (fa(a_3, b_3, cout_2) >> 1) & 0x01;
cout_4 = (fa(a_4, b_4, cout_3) >> 1) & 0x01;
cout_5 = (fa(a_5, b_5, cout_4) >> 1) & 0x01;
cout_6 = (fa(a_6, b_6, cout_5) >> 1) & 0x01;
cout_7 = (fa(a_7, b_7, cout_6) >> 1) & 0x01;
s_rca8_xor_1_y0 = xor_gate(a_7, b_7);
out |= ((ha(a_0, b_0) >> 0) & 0x01) << 0;
out |= ((fa(a_1, b_1, cout_0) >> 0) & 0x01) << 1;
out |= ((fa(a_2, b_2, cout_1) >> 0) & 0x01) << 2;
out |= ((fa(a_3, b_3, cout_2) >> 0) & 0x01) << 3;
out |= ((fa(a_4, b_4, cout_3) >> 0) & 0x01) << 4;
out |= ((fa(a_5, b_5, cout_4) >> 0) & 0x01) << 5;
out |= ((fa(a_6, b_6, cout_5) >> 0) & 0x01) << 6;
out |= ((fa(a_7, b_7, cout_6) >> 0) & 0x01) << 7;
out |= (xor_gate(s_rca8_xor_1_y0, cout_7) & 0x01) << 8;
return out;
}
#include <assert.h>
int main(){
int result = 0;
for (int i = -128; i < 128; i++){
for (int j = -128; j < 128; j++){
result = i + j;
// Calculating 2's complement in case of negative sum
if (result < 0) {
result = 512 + result;
}
assert(result == (int)s_rca8(i,j));
}
}
return 0;
}

74
Tests/C_circuits/Hierarchical_circuits/Adders/h_u_rca3.c Normal file
View File

@ -0,0 +1,74 @@
#include <stdio.h>
#include <stdint.h>
uint8_t xor_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) ^ ((b >> 0) & 0x01);
}
uint8_t and_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) & ((b >> 0) & 0x01);
}
uint8_t or_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) | ((b >> 0) & 0x01);
}
uint8_t ha(uint8_t a_0, uint8_t b_0){
uint8_t out = 0;
out |= (xor_gate(a_0, b_0) & 0x01) << 0;
out |= (and_gate(a_0, b_0) & 0x01) << 1;
return out;
}
uint8_t fa(uint8_t a_2, uint8_t b_2, uint8_t cin){
uint8_t out = 0;
uint8_t xor_1 = 0;
uint8_t and_1 = 0;
uint8_t and_2 = 0;
xor_1 = xor_gate(a_2, b_2);
and_1 = and_gate(a_2, b_2);
and_2 = and_gate(xor_1, cin);
out |= (xor_gate(xor_1, cin) & 0x01) << 0;
out |= (or_gate(and_1, and_2) & 0x01) << 1;
return out;
}
uint64_t u_rca3(uint64_t a, uint64_t b){
uint8_t out = 0;
uint8_t a_0 = 0;
uint8_t a_1 = 0;
uint8_t a_2 = 0;
uint8_t b_0 = 0;
uint8_t b_1 = 0;
uint8_t b_2 = 0;
uint8_t cout_0 = 0;
uint8_t cout_1 = 0;
a_0 = ((a >> 0) & 0x01);
a_1 = ((a >> 1) & 0x01);
a_2 = ((a >> 2) & 0x01);
b_0 = ((b >> 0) & 0x01);
b_1 = ((b >> 1) & 0x01);
b_2 = ((b >> 2) & 0x01);
cout_0 = (ha(a_0, b_0) >> 1) & 0x01;
cout_1 = (fa(a_1, b_1, cout_0) >> 1) & 0x01;
out |= ((ha(a_0, b_0) >> 0) & 0x01) << 0;
out |= ((fa(a_1, b_1, cout_0) >> 0) & 0x01) << 1;
out |= ((fa(a_2, b_2, cout_1) >> 0) & 0x01) << 2;
out |= ((fa(a_2, b_2, cout_1) >> 1) & 0x01) << 3;
return out;
}
#include <assert.h>
int main(){
for (int i = 0; i < 8; i++){
for (int j = 0; j < 8; j++){
assert((i + j) == u_rca3(i,j));
}
}
return 0;
}

88
Tests/C_circuits/Hierarchical_circuits/Adders/h_u_rca5.c Normal file
View File

@ -0,0 +1,88 @@
#include <stdio.h>
#include <stdint.h>
uint8_t xor_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) ^ ((b >> 0) & 0x01);
}
uint8_t and_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) & ((b >> 0) & 0x01);
}
uint8_t or_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) | ((b >> 0) & 0x01);
}
uint8_t ha(uint8_t a_0, uint8_t b_0){
uint8_t out = 0;
out |= (xor_gate(a_0, b_0) & 0x01) << 0;
out |= (and_gate(a_0, b_0) & 0x01) << 1;
return out;
}
uint8_t fa(uint8_t a_4, uint8_t b_4, uint8_t cin){
uint8_t out = 0;
uint8_t xor_1 = 0;
uint8_t and_1 = 0;
uint8_t and_2 = 0;
xor_1 = xor_gate(a_4, b_4);
and_1 = and_gate(a_4, b_4);
and_2 = and_gate(xor_1, cin);
out |= (xor_gate(xor_1, cin) & 0x01) << 0;
out |= (or_gate(and_1, and_2) & 0x01) << 1;
return out;
}
uint64_t u_rca5(uint64_t a, uint64_t b){
uint8_t out = 0;
uint8_t a_0 = 0;
uint8_t a_1 = 0;
uint8_t a_2 = 0;
uint8_t a_3 = 0;
uint8_t a_4 = 0;
uint8_t b_0 = 0;
uint8_t b_1 = 0;
uint8_t b_2 = 0;
uint8_t b_3 = 0;
uint8_t b_4 = 0;
uint8_t cout_0 = 0;
uint8_t cout_1 = 0;
uint8_t cout_2 = 0;
uint8_t cout_3 = 0;
a_0 = ((a >> 0) & 0x01);
a_1 = ((a >> 1) & 0x01);
a_2 = ((a >> 2) & 0x01);
a_3 = ((a >> 3) & 0x01);
a_4 = ((a >> 4) & 0x01);
b_0 = ((b >> 0) & 0x01);
b_1 = ((b >> 1) & 0x01);
b_2 = ((b >> 2) & 0x01);
b_3 = ((b >> 3) & 0x01);
b_4 = ((b >> 4) & 0x01);
cout_0 = (ha(a_0, b_0) >> 1) & 0x01;
cout_1 = (fa(a_1, b_1, cout_0) >> 1) & 0x01;
cout_2 = (fa(a_2, b_2, cout_1) >> 1) & 0x01;
cout_3 = (fa(a_3, b_3, cout_2) >> 1) & 0x01;
out |= ((ha(a_0, b_0) >> 0) & 0x01) << 0;
out |= ((fa(a_1, b_1, cout_0) >> 0) & 0x01) << 1;
out |= ((fa(a_2, b_2, cout_1) >> 0) & 0x01) << 2;
out |= ((fa(a_3, b_3, cout_2) >> 0) & 0x01) << 3;
out |= ((fa(a_4, b_4, cout_3) >> 0) & 0x01) << 4;
out |= ((fa(a_4, b_4, cout_3) >> 1) & 0x01) << 5;
return out;
}
#include <assert.h>
int main(){
for (int i = 0; i < 32; i++){
for (int j = 0; j < 32; j++){
assert((i + j) == u_rca5(i,j));
}
}
return 0;
}

109
Tests/C_circuits/Hierarchical_circuits/Adders/h_u_rca8.c Normal file
View File

@ -0,0 +1,109 @@
#include <stdio.h>
#include <stdint.h>
uint8_t xor_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) ^ ((b >> 0) & 0x01);
}
uint8_t and_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) & ((b >> 0) & 0x01);
}
uint8_t or_gate(uint8_t a, uint8_t b){
return ((a >> 0) & 0x01) | ((b >> 0) & 0x01);
}
uint8_t ha(uint8_t a_0, uint8_t b_0){
uint8_t out = 0;
out |= (xor_gate(a_0, b_0) & 0x01) << 0;
out |= (and_gate(a_0, b_0) & 0x01) << 1;
return out;
}
uint8_t fa(uint8_t a_7, uint8_t b_7, uint8_t cin){
uint8_t out = 0;
uint8_t xor_1 = 0;
uint8_t and_1 = 0;
uint8_t and_2 = 0;
xor_1 = xor_gate(a_7, b_7);
and_1 = and_gate(a_7, b_7);
and_2 = and_gate(xor_1, cin);
out |= (xor_gate(xor_1, cin) & 0x01) << 0;
out |= (or_gate(and_1, and_2) & 0x01) << 1;
return out;
}
uint64_t u_rca8(uint64_t a, uint64_t b){
uint64_t out = 0;
uint8_t a_0 = 0;
uint8_t a_1 = 0;
uint8_t a_2 = 0;
uint8_t a_3 = 0;
uint8_t a_4 = 0;
uint8_t a_5 = 0;
uint8_t a_6 = 0;
uint8_t a_7 = 0;
uint8_t b_0 = 0;
uint8_t b_1 = 0;
uint8_t b_2 = 0;
uint8_t b_3 = 0;
uint8_t b_4 = 0;
uint8_t b_5 = 0;
uint8_t b_6 = 0;
uint8_t b_7 = 0;
uint8_t cout_0 = 0;
uint8_t cout_1 = 0;
uint8_t cout_2 = 0;
uint8_t cout_3 = 0;
uint8_t cout_4 = 0;
uint8_t cout_5 = 0;
uint8_t cout_6 = 0;
a_0 = ((a >> 0) & 0x01);
a_1 = ((a >> 1) & 0x01);
a_2 = ((a >> 2) & 0x01);
a_3 = ((a >> 3) & 0x01);
a_4 = ((a >> 4) & 0x01);
a_5 = ((a >> 5) & 0x01);
a_6 = ((a >> 6) & 0x01);
a_7 = ((a >> 7) & 0x01);
b_0 = ((b >> 0) & 0x01);
b_1 = ((b >> 1) & 0x01);
b_2 = ((b >> 2) & 0x01);
b_3 = ((b >> 3) & 0x01);
b_4 = ((b >> 4) & 0x01);
b_5 = ((b >> 5) & 0x01);
b_6 = ((b >> 6) & 0x01);
b_7 = ((b >> 7) & 0x01);
cout_0 = (ha(a_0, b_0) >> 1) & 0x01;
cout_1 = (fa(a_1, b_1, cout_0) >> 1) & 0x01;
cout_2 = (fa(a_2, b_2, cout_1) >> 1) & 0x01;
cout_3 = (fa(a_3, b_3, cout_2) >> 1) & 0x01;
cout_4 = (fa(a_4, b_4, cout_3) >> 1) & 0x01;
cout_5 = (fa(a_5, b_5, cout_4) >> 1) & 0x01;
cout_6 = (fa(a_6, b_6, cout_5) >> 1) & 0x01;
out |= ((ha(a_0, b_0) >> 0) & 0x01) << 0;
out |= ((fa(a_1, b_1, cout_0) >> 0) & 0x01) << 1;
out |= ((fa(a_2, b_2, cout_1) >> 0) & 0x01) << 2;
out |= ((fa(a_3, b_3, cout_2) >> 0) & 0x01) << 3;
out |= ((fa(a_4, b_4, cout_3) >> 0) & 0x01) << 4;
out |= ((fa(a_5, b_5, cout_4) >> 0) & 0x01) << 5;
out |= ((fa(a_6, b_6, cout_5) >> 0) & 0x01) << 6;
out |= ((fa(a_7, b_7, cout_6) >> 0) & 0x01) << 7;
out |= ((fa(a_7, b_7, cout_6) >> 1) & 0x01) << 8;
return out;
}
#include <assert.h>
int main(){
for (int i = 0; i < 256; i++){
for (int j = 0; j < 256; j++){
assert((i + j) == u_rca8(i,j));
}
}
return 0;
}

0
Tests/Flat_c_circuits/Logic_gates/and_gate.c → Tests/C_circuits/Logic_gates/and_gate.c
View File

0
Tests/Flat_c_circuits/Logic_gates/nand_gate.c → Tests/C_circuits/Logic_gates/nand_gate.c
View File

0
Tests/Flat_c_circuits/Logic_gates/nor_gate.c → Tests/C_circuits/Logic_gates/nor_gate.c
View File

0
Tests/Flat_c_circuits/Logic_gates/not_gate.c → Tests/C_circuits/Logic_gates/not_gate.c
View File

0
Tests/Flat_c_circuits/Logic_gates/or_gate.c → Tests/C_circuits/Logic_gates/or_gate.c
View File

0
Tests/Flat_c_circuits/Logic_gates/xnor_gate.c → Tests/C_circuits/Logic_gates/xnor_gate.c
View File

0
Tests/Flat_c_circuits/Logic_gates/xor_gate.c → Tests/C_circuits/Logic_gates/xor_gate.c
View File

39
Tests/Flat_c_circuits/Adders/fa.c
View File

@ -1,39 +0,0 @@
#include <stdio.h>
#include <stdint.h>
uint8_t full_adder(uint8_t a, uint8_t b, uint8_t cin){
uint8_t out = 0;
uint8_t full_adder_a = 0;
uint8_t full_adder_b = 0;
uint8_t full_adder_y0 = 0;
uint8_t full_adder_y1 = 0;
uint8_t full_adder_cin = 0;
uint8_t full_adder_y2 = 0;
uint8_t full_adder_y3 = 0;
uint8_t full_adder_y4 = 0;
full_adder_a = ((a >> 0) & 0x01);
full_adder_b = ((b >> 0) & 0x01);
full_adder_cin = ((cin >> 0) & 0x01);
full_adder_y0 = full_adder_a ^ full_adder_b;
full_adder_y1 = full_adder_a & full_adder_b;
full_adder_y2 = full_adder_y0 ^ full_adder_cin;
full_adder_y3 = full_adder_y0 & full_adder_cin;
full_adder_y4 = full_adder_y1 | full_adder_y3;
out |= (full_adder_y2 & 0x01) << 0;
out |= (full_adder_y4 & 0x01) << 1;
return out;
}
#include <assert.h>
int main(){
for (int i = 0; i < 2; i++){
for (int j = 0; j < 2; j++){
for (int k = 0; k < 2; k++){
assert((i + j + k) == full_adder(i,j,k));
}
}
}
return 0;
}

29
Tests/Flat_c_circuits/Adders/ha.c
View File

@ -1,29 +0,0 @@
#include <stdio.h>
#include <stdint.h>
uint8_t half_adder(uint8_t a, uint8_t b){
uint8_t out = 0;
uint8_t half_adder_a = 0;
uint8_t half_adder_b = 0;
uint8_t half_adder_y0 = 0;
uint8_t half_adder_y1 = 0;
half_adder_a = ((a >> 0) & 0x01);
half_adder_b = ((b >> 0) & 0x01);
half_adder_y0 = half_adder_a ^ half_adder_b;
half_adder_y1 = half_adder_a & half_adder_b;
out |= (half_adder_y0 & 0x01) << 0;
out |= (half_adder_y1 & 0x01) << 1;
return out;
}
#include <assert.h>
int main(){
for (int i = 0; i < 2; i++){
for (int j = 0; j < 2; j++){
assert((i + j) == half_adder(i,j));
}
}
return 0;
}

360
Tests/c_tests.sh Normal file
View File

@ -0,0 +1,360 @@
#!/bin/sh
POSIXLY_CORRECT=yes
# Colors
# set thanks to: https://linux.101hacks.com/ps1-examples/prompt-color-using-tput/
REDCOLOR="$(tput setaf 1)"
GREENCOLOR="$(tput setaf 2)"
BLUECOLOR="$(tput setaf 4)"
NOCOLOR="$(tput sgr0)"
# Compiler options
C=g++
CFLAGS=-std=c++11 -Wextra -pedantic -g
LG_PATH="C_circuits/Logic_gates/"
FLAT_ADD_PATH="C_circuits/Flat_circuits/Adders/"
HIER_ADD_PATH="C_circuits/Hierarchical_circuits/Adders/"
# FLATTENED C CODE CIRCUITS #
# Logic gates
AND_G="./and_gate 2>/dev/null"
NAND_G="./nand_gate 2>/dev/null"
OR_G="./or_gate 2>/dev/null"
NOR_G="./nor_gate 2>/dev/null"
XOR_G="./xor_gate 2>/dev/null"
XNOR_G="./xnor_gate 2>/dev/null"
NOT_G="./not_gate 2>/dev/null"
# Adders
F_HA="./f_ha 2>/dev/null"
F_FA="./f_fa 2>/dev/null"
H_HA="./h_ha 2>/dev/null"
H_FA="./h_fa 2>/dev/null"
# Unsigned
F_U_RCA3="./f_u_rca3 2>/dev/null"
F_U_RCA5="./f_u_rca5 2>/dev/null"
F_U_RCA8="./f_u_rca8 2>/dev/null"
H_U_RCA3="./h_u_rca3 2>/dev/null"
H_U_RCA5="./h_u_rca5 2>/dev/null"
H_U_RCA8="./h_u_rca8 2>/dev/null"
# Signed
F_S_RCA2="./f_s_rca2 2>/dev/null"
F_S_RCA6="./f_s_rca6 2>/dev/null"
F_S_RCA8="./f_s_rca8 2>/dev/null"
H_S_RCA2="./h_s_rca2 2>/dev/null"
H_S_RCA4="./h_s_rca4 2>/dev/null"
H_S_RCA6="./h_s_rca6 2>/dev/null"
H_S_RCA8="./h_s_rca8 2>/dev/null"
# TESTING #
echo "${BLUECOLOR}TESTING C CODE CIRCUITS GENERATED USING arithmetic_circuits_generator.py"
echo "––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––"
echo ""
echo "${GREENCOLOR}–––––––––––––––"
echo " FLAT CIRCUITS"
echo "–––––––––––––––"
echo ""
echo "${BLUECOLOR}LOGIC GATES TESTS${NOCOLOR}"
## LOGIC GATES ##
#################
# AND
${C} ${CFLAGS} ${LG_PATH}and_gate.c -o and_gate
echo "TEST_1: and_gate.c"
eval "$AND_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm and_gate
# NAND
${C} ${CFLAGS} ${LG_PATH}nand_gate.c -o nand_gate
echo "TEST_2: nand_gate.c"
eval "$NAND_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm nand_gate
# OR
${C} ${CFLAGS} ${LG_PATH}or_gate.c -o or_gate
echo "TEST_3: or_gate.c"
eval "$OR_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm or_gate
# NOR
${C} ${CFLAGS} ${LG_PATH}nor_gate.c -o nor_gate
echo "TEST_4: nor_gate.c"
eval "$NOR_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm nor_gate
# XOR
${C} ${CFLAGS} ${LG_PATH}xor_gate.c -o xor_gate
echo "TEST_5: xor_gate.c"
eval "$XOR_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm xor_gate
# XNOR
${C} ${CFLAGS} ${LG_PATH}xnor_gate.c -o xnor_gate
echo "TEST_6: xnor_gate.c"
eval "$XNOR_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm xnor_gate
# NOT
${C} ${CFLAGS} ${LG_PATH}not_gate.c -o not_gate
echo "TEST_7: not_gate.c"
eval "$NOT_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm not_gate
echo ""
echo "${BLUECOLOR}UNSIGNED ADDERS TESTS${NOCOLOR}"
## FLAT 1-BIT ADDERS ##
# HALF ADDER
${C} ${CFLAGS} ${FLAT_ADD_PATH}f_ha.c -o f_ha
echo "TEST_8: f_ha.c"
eval "$F_HA"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm f_ha
# FULL ADDER
${C} ${CFLAGS} ${FLAT_ADD_PATH}f_fa.c -o f_fa
echo "TEST_9: f_fa.c"
eval "$F_FA"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm f_fa
## FLAT UNSIGNED ADDERS ##
# 3-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${FLAT_ADD_PATH}f_u_rca3.c -o f_u_rca3
echo "TEST_10: f_u_rca3.c"
eval "$F_U_RCA3"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm f_u_rca3
# 5-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${FLAT_ADD_PATH}f_u_rca5.c -o f_u_rca5
echo "TEST_11: f_u_rca5.c"
eval "$F_U_RCA5"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm f_u_rca5
# 8-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${FLAT_ADD_PATH}f_u_rca8.c -o f_u_rca8
echo "TEST_12: f_u_rca8.c"
eval "$F_U_RCA8"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm f_u_rca8
echo ""
echo "${BLUECOLOR}SIGNED ADDERS TESTS${NOCOLOR}"
## FLAT SIGNED ADDERS ##
# 2-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${FLAT_ADD_PATH}f_s_rca2.c -o f_s_rca2
echo "TEST_13: f_s_rca2.c"
eval "$F_S_RCA2"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm f_s_rca2
# 6-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${FLAT_ADD_PATH}f_s_rca6.c -o f_s_rca6
echo "TEST_14: f_s_rca6.c"
eval "$F_S_RCA6"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm f_s_rca6
# 8-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${FLAT_ADD_PATH}f_s_rca8.c -o f_s_rca8
echo "TEST_15: f_s_rca8.c"
eval "$F_S_RCA8"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm f_s_rca8
echo ""
echo "${GREENCOLOR}–––––––––––––––––––––––"
echo " HIERARCHICAL CIRCUITS"
echo "–––––––––––––––––––––––"
echo ""
echo "${BLUECOLOR}UNSIGNED ADDERS TESTS${NOCOLOR}"
## HIERARCHICAL 1-BIT ADDERS ##
# HALF ADDER
${C} ${CFLAGS} ${HIER_ADD_PATH}h_ha.c -o h_ha
echo "TEST_16: h_ha.c"
eval "$H_HA"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm h_ha
# FULL ADDER
${C} ${CFLAGS} ${HIER_ADD_PATH}h_fa.c -o h_fa
echo "TEST_17: h_fa.c"
eval "$H_FA"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm h_fa
## HIERARCHICAL UNSIGNED ADDERS ##
# 3-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${HIER_ADD_PATH}h_u_rca3.c -o h_u_rca3
echo "TEST_18: h_u_rca3.c"
eval "$H_U_RCA3"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm h_u_rca3
# 5-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${HIER_ADD_PATH}h_u_rca5.c -o h_u_rca5
echo "TEST_19: h_u_rca5.c"
eval "$H_U_RCA5"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm h_u_rca5
# 8-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${HIER_ADD_PATH}h_u_rca8.c -o h_u_rca8
echo "TEST_20: h_u_rca8.c"
eval "$H_U_RCA8"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm h_u_rca8
echo ""
echo "${BLUECOLOR}SIGNED ADDERS TESTS${NOCOLOR}"
## HIERARCHICAL SIGNED ADDERS ##
# 2-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${HIER_ADD_PATH}h_s_rca2.c -o h_s_rca2
echo "TEST_21: h_s_rca2.c"
eval "$H_S_RCA2"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm h_s_rca2
# 4-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${HIER_ADD_PATH}h_s_rca4.c -o h_s_rca4
echo "TEST_22: h_s_rca4.c"
eval "$H_S_RCA4"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm h_s_rca4
# 6-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${HIER_ADD_PATH}h_s_rca6.c -o h_s_rca6
echo "TEST_23: h_s_rca6.c"
eval "$H_S_RCA6"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm h_s_rca6
# 8-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${HIER_ADD_PATH}h_s_rca8.c -o h_s_rca8
echo "TEST_24: h_s_rca8.c"
eval "$H_S_RCA8"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm h_s_rca8

225
Tests/flat_c_tests.sh
View File

@ -1,225 +0,0 @@
#!/bin/sh
POSIXLY_CORRECT=yes
# Colors
# set thanks to: https://linux.101hacks.com/ps1-examples/prompt-color-using-tput/
REDCOLOR="$(tput setaf 1)"
GREENCOLOR="$(tput setaf 2)"
BLUECOLOR="$(tput setaf 4)"
NOCOLOR="$(tput sgr0)"
# Compiler options
C=g++
CFLAGS=-std=c++11 -Wextra -pedantic -g
LG_PATH="Flat_c_circuits/Logic_gates/"
ADD_PATH="Flat_c_circuits/Adders/"
# FLATTENED C CODE CIRCUITS #
# Logic gates
AND_G="./and_gate 2>/dev/null"
NAND_G="./nand_gate 2>/dev/null"
OR_G="./or_gate 2>/dev/null"
NOR_G="./nor_gate 2>/dev/null"
XOR_G="./xor_gate 2>/dev/null"
XNOR_G="./xnor_gate 2>/dev/null"
NOT_G="./not_gate 2>/dev/null"
# Adders
HA="./ha 2>/dev/null"
FA="./fa 2>/dev/null"
# Unsigned
U_RCA3="./u_rca3 2>/dev/null"
U_RCA5="./u_rca5 2>/dev/null"
U_RCA8="./u_rca8 2>/dev/null"
# Signed
S_RCA2="./s_rca2 2>/dev/null"
S_RCA6="./s_rca6 2>/dev/null"
S_RCA8="./s_rca8 2>/dev/null"
# TESTING #
echo "${BLUECOLOR}TESTING OF FLATTENED CIRCUITS GENERATED USING arithmetic_circuits_generator.py"
echo "––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––"
echo ""
echo "LOGIC GATES TESTS${NOCOLOR}"
## LOGIC GATES ##
#################
# AND
${C} ${CFLAGS} ${LG_PATH}and_gate.c -o and_gate
echo "TEST_1: and_gate.c"
eval "$AND_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm and_gate
# NAND
${C} ${CFLAGS} ${LG_PATH}nand_gate.c -o nand_gate
echo "TEST_2: nand_gate.c"
eval "$NAND_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm nand_gate
# OR
${C} ${CFLAGS} ${LG_PATH}or_gate.c -o or_gate
echo "TEST_3: or_gate.c"
eval "$OR_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm or_gate
# NOR
${C} ${CFLAGS} ${LG_PATH}nor_gate.c -o nor_gate
echo "TEST_4: nor_gate.c"
eval "$NOR_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm nor_gate
# XOR
${C} ${CFLAGS} ${LG_PATH}xor_gate.c -o xor_gate
echo "TEST_5: xor_gate.c"
eval "$XOR_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm xor_gate
# XNOR
${C} ${CFLAGS} ${LG_PATH}xnor_gate.c -o xnor_gate
echo "TEST_6: xnor_gate.c"
eval "$XNOR_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm xnor_gate
# NOT
${C} ${CFLAGS} ${LG_PATH}not_gate.c -o not_gate
echo "TEST_7: not_gate.c"
eval "$NOT_G"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm not_gate
echo ""
echo "${BLUECOLOR}ADDERS TESTS${NOCOLOR}"
## ADDERS ##
############
# HALF ADDER
${C} ${CFLAGS} ${ADD_PATH}ha.c -o ha
echo "TEST_8: ha.c"
eval "$HA"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm ha
# FULL ADDER
${C} ${CFLAGS} ${ADD_PATH}fa.c -o fa
echo "TEST_9: fa.c"
eval "$FA"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm fa
## UNSIGNED ADDERS ##
# 3-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${ADD_PATH}u_rca3.c -o u_rca3
echo "TEST_10: u_rca3.c"
eval "$U_RCA3"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm u_rca3
# 5-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${ADD_PATH}u_rca5.c -o u_rca5
echo "TEST_11: u_rca5.c"
eval "$U_RCA5"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm u_rca5
# 8-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${ADD_PATH}u_rca8.c -o u_rca8
echo "TEST_12: u_rca8.c"
eval "$U_RCA8"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm u_rca8
## SIGNED ADDERS ##
# 2-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${ADD_PATH}s_rca2.c -o s_rca2
echo "TEST_13: s_rca2.c"
eval "$S_RCA2"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm s_rca2
# 2-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${ADD_PATH}s_rca6.c -o s_rca6
echo "TEST_14: s_rca6.c"
eval "$S_RCA6"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm s_rca6
# 8-BIT RIPPLE CARRY ADDER
${C} ${CFLAGS} ${ADD_PATH}s_rca8.c -o s_rca8
echo "TEST_15: s_rca8.c"
eval "$S_RCA8"
if [ "$?" -eq 0 ] ; then
echo "${GREENCOLOR}PASSED${NOCOLOR}"
else
echo "${REDCOLOR}FAILED${NOCOLOR}"
fi
rm s_rca8