PROJECT: Logical Math Routines (LMR0)

This project is inspired by an idea from DirtPig and Paradox.

How do the math functions from the math.h library work? How can you add, subtract, divide, multiply, raise to a power, find a root, etc. without using binary operators? What is the logic behind your day-to-day mathematic operations? and how can you teach it to a computer?

–Note that 0=false and 1=true–

NOT-Is fed one value, returns true if the value is false
AND-Is fed two values, returns true if both values are true
OR-Is fed two values, returns true if any value is true
NOR-Is fed two values, returns true if neither value is true
XOR-Is fed two values, returns true if only one value is true
XNOR-Is fed two values, returns true if both values are true or if both values are false
NAND-Is fed two values, returns true unless both values are true

SHIFT-Is fed an array of bits |1|0|1|0|,if we shift left, then we have |0|1|0|0|. If we keep going then the remaining 1 will fall off and we will have |0|0|0|0|. Will only ever add 0 to the array.

ROTATE-Is fed an array of bits |1|0|1|0|0|, if we rotate left then we get |0|1|0|0|1|. Will put the bit that falls off in the new bit spot created. NOTE: Notice how the only difference between shift and rotate is that with rotate, the first value is saved and stuck on the end, rather then adding a 0 to the end like shift does.

We will be pseudo-creating a math library by creating a 12-element array and functions to perform all basic operands.

This week we will be replicating the functionality of the seven basic logic gates and creating our own bitwise operations:

• Not
• And
• Nand
• Or
• Nor
• Xor
• Xnor
• Logical shift (potentially 2 separate operations; Shift Left / Shift Right)
• Logical rotate (Rotate Left / Rotate Right)

We will be writing different functions that will have this functionality. While it seems simple, we have to start somewhere, and you might find the later parts in shift/rotate a bit harder. Your functions will contain a bunch of if, else if, and else statements. Rest assured that you are doing fine if your code consists of a bunch of these.

You must define your own set of values that represent the value true/on and false/off. Could be the traditional TRUE or FALSE, 1 or 0.

IMPORTANT: You will not use the already included bitwise operators from C, since we are creating our own. This would defeat the entire purpose of this iteration of the project.

Make use of the relational operators (==, !=, >, <, >=, ⇐) to complete this project. (Comparison operators such as (&&, ||) are also okay.)

Each bitwise operation function will take 2 arguments and return the result of the operation. Logical shift (left & right) and logical rotate take only one argument and return the result of the operation.

Although this project is intended to be a library, there must be some form of demonstration in the int main() portion of your code. This can be something such as truth tables for each function you have created.

*Our task is to ask questions on Discord or in class and document our findings on this wiki page collaboratively, regarding the functionality of this project.

*For anybody interested in editing the wiki page, here is the dokuwiki user guide: https://www.dokuwiki.org/wiki:syntax#basic_text_formatting -Ash

You are free to use c++ with this project as well. Remember, if you do so, to edit the makefile to be able to compile your c++ code. To do this, edit your makefile and change CC = gcc to CC = g++. Furthermore, you can make use of gdb if writing this program on a raspberry pi for necessary debugging. To run gdb type gdb file to debug, then type run at the prompt. You can make use of list (lists lines) and break # (to set a breakpoint). You can use display to show the values of variables, and you can make use of N (next), S(step), and C(continue)-resume the execution to breakpoint.

Output the display of what the functions do by calling them and printing them inside your main function. This can also be used to confirm that all your functions work correctly. For the bit array you can either display both initial and result or find another way to get input into your bit array.

There is no make verify with this project. Your verification can be in the form of the main function displaying the truth tables. You can also display the rotate left and right array values after calling your function. The truth tables are located above to refer to.

Heres an example output:

USER@lab46:~/src/fall2022/lmr0$ ./lmr0
--NOT--
--------
 x | out
 0 |  1
 1 |  0

--AND--
 x | y | out
------------
 0 | 0 |  0
 0 | 1 |  0
 1 | 0 |  0
 1 | 1 |  1

--OR--
 x | y | out
------------
 0 | 0 |  0
 0 | 1 |  1
 1 | 0 |  1
 1 | 1 |  1

--NOR--
 x | y | out
------------
 0 | 0 |  1
 0 | 1 |  0
 1 | 0 |  0
 1 | 1 |  0

--XOR--
 x | y | out
------------
 0 | 0 |  0
 0 | 1 |  1
 1 | 0 |  1
 1 | 1 |  0

--XNOR--
 x | y | out
------------
 0 | 0 |  1
 0 | 1 |  0
 1 | 0 |  0
 1 | 1 |  1

--NAND--
 x | y | out
------------
 0 | 0 |  1
 0 | 1 |  1
 1 | 0 |  1
 1 | 1 |  0

Bitset:                1010
Bitset (after LSHIFT): 0100
Bitset (after RSHIFT): 0010

Bitset:                 10100
Bitset (after LROTATE): 01001
Bitset (after RROTATE): 10100