# Program To Simulate Bit Adder Using Logic Gate Simulation In Scheme Assignment Solution.

## Instructions

Objective
Write a Scheme assignment program to simulate the bit adder implementation using the knowledge of logic gates simulation.

## Requirements and Specifications

Logic gates and adder are basic components of building a computer and any digital devices. All high-level language programs will be translated into instructions that can be executed on these basic components. The correctness and performance of these components are extremely important.
A computer system consists of hardware and software. Before we implement a hardware component, the design is normally simulated by a program first, so that we can verify its correctness and evaluate its performance. In this project, you will write Scheme programs to simulate an n-bit Adder.
Write three Scheme procedures to simulate these three gates (functions): AND, OR, and XOR, shown in the diagram in Figure 1. Test your procedures using all possible input combinations.
Screenshots of output Source Code
```;Your Name: ;Course: CSE 240 ; Use the template for your programming assignment #lang scheme ; added to test the program in DrRacket ;Q1 (6 points) (define OR-GATE (lambda (a b)   (if (or (= a 1) (= b 1)) ; returns 1 if either a or b are 1, return 0 otherwise     1     0   ))) (define AND-GATE (lambda (a b)   (if (and (= a 1) (= b 1)) ; returns 1 only if a and b are 1, return 0 otherwise     1     0   ))) (define XOR-GATE (lambda (a b)   (if (= a b) ; returns 0 if a and b are equal, return 1 otherwise     0     1   ))) ;Test cases (AND-GATE 0 0) (AND-GATE 0 1) (AND-GATE 1 0) (AND-GATE 1 1) ;0 ;0 ;0 ;1 (newline) (OR-GATE 0 0) (OR-GATE 0 1) (OR-GATE 1 0) (OR-GATE 1 1) ;0 ;1 ;1 ;1 (newline) (XOR-GATE 0 0) (XOR-GATE 0 1) (XOR-GATE 1 0) (XOR-GATE 1 1) ;0 ;1 ;1 ;0 ;Q2 (define bitAdder (lambda (x a b) ;(4 points each)   (cons (sum-bits x a b) (carry-out x a b)))) ; make list with sum and carry (define sum-bits (lambda (x a b) ;(5 points each)   (XOR-GATE (XOR-GATE a b) x))) (define carry-out (lambda (x a b) ;(5 points each)   (OR-GATE (AND-GATE (XOR-GATE a b) x) (AND-GATE a b)))) ;Test cases (newline) (bitAdder 0 0 0) (bitAdder 0 0 1) (bitAdder 0 1 0) (bitAdder 0 1 1) (bitAdder 1 0 0) (bitAdder 1 0 1) (bitAdder 1 1 0) (bitAdder 1 1 1) ;(0 . 0) ;(1 . 0) ;(1 . 0) ;(0 . 1) ;(1 . 0) ;(0 . 1) ;(0 . 1) ;(1 . 1) ;Q3.1 (4 points) (define tail (lambda (lst)   (if (null? (cdr lst)) ; if we have empty tail we are at the last element     (car lst) ; return the last element     ; else list remainder is not empty, recurse using list remainder     (tail (cdr lst))))) ;Q3.2 (4 points) (define rmtail (lambda (lst)   (if (null? (cdr lst)) ; if we have empty tail we are at the last element     '() ; return empty list to remove the last element     ; else list remainder is not empty, recurse using list remainder,     ; keep the current element in the list     (cons (car lst) (rmtail (cdr lst)))))) ;Q3.3 (4 points) ;(1) size-n is the number of bits to sum, the size-n problem will be finding the ; recursive procedure n-bit-adder1 that takes 2 n-bit binary numbers ; (lists of n elements), the n and the previous result (resulti) and returns ; the sum of n-bits and a carry-out ;(2) Stopping condition is n = 0, we added all bits, we return the sum and the ; carry-out of all previous bits which is passed in resulti ;(3) The size-(n-1) problem removes the last bit in each list and decrements n: ; (n-bit-adder (rmtail L1) (rmtail L2) (- n 1)) ;(4) To build the size-n problem from size-(n-1), first we test the stopping ; condition, if test is true then we return the previous resulti ; if false, we recurse to the recursive size-(n-1) problem passing as resulti ; the sum of the current bits appended to the previous sum bit list and ; the previous carry. ;Q3.4 (14 points) (define X1 '(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) ) (define X2 '(1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) ) (define X3 '(0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1) ) (define X4 '(1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0) ) (define X5 '(0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 1) ) (define X6 '(1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1) ) (define n-bit-adder1 (lambda (L1 L2 n)   ; use helper to calculate sum, start with a carry-in of 0 and an empty list   (n-bit-adderhelper1 L1 L2 n '((0))) )) (define n-bit-adderhelper1 (lambda (L1 L2 n resulti)   (if (= n 0) ; if stopping condition     resulti ; return previous result     ; calculate the sum of the current bits and the previous carry,     ; label result as sum, (car sum) will be the sum and (cdr sum) will be the carry     (let ((sum (bitAdder (tail L1) (tail L2) (caar resulti))))         ; recurse removing the tail of the lists and decrementing n         (n-bit-adderhelper1             (rmtail L1)             (rmtail L2)             (- n 1)             ; pass the current result as a list of a list containing only the carry             ; and a list of the previous sums appending the current result at the start             (cons (list (cdr sum)) (cons (car sum) (cdr resulti)))))))) ; this definition was not used but it calculates the carry for the n-bit sum (define n-bit-adder-carry-out (lambda (L1 L2 n resulti)   (if (= n 0) ; if stopping condition     resulti ; return previous result     ; else, recurse removing the tail of the lists and decrementing n     (n-bit-adder-carry-out         (rmtail L1)         (rmtail L2)         (- n 1)         ; calculate the carry between the current bits and the previous result,         ; pass the carry result on the recursive call as the resulti         (carry-out resulti (tail L1) (tail L2)))))) ;Test cases (newline) (n-bit-adder1 X1 X2 32) (n-bit-adder1 X3 X4 32) (n-bit-adder1 X5 X6 32) (n-bit-adder1 X2 X3 32) (n-bit-adder1 X4 X5 32) (n-bit-adder1 X1 X6 32) (newline) (n-bit-adder1 X1 X3 32) (n-bit-adder1 X1 X4 32) (n-bit-adder1 X1 X5 32) (n-bit-adder1 X2 X4 32) (n-bit-adder1 X2 X5 32) (n-bit-adder1 X2 X6 32) ;((0) 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) ;((0) 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) ;((1) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0) ;((1) 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0) ;((1) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1) ;((0) 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1) ;((0) 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1) ;((0) 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0) ;((0) 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 1) ;((1) 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0 1) ;((1) 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 0) ;((1) 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0) ```