=====BACKGROUND=====

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?

Continuing from where we left off from lmr0, after making bitwise operator functions:
  * Not
  * And
  * Nand
  * Or
  * Nor
  * Xor
  * Xnor
  * Logical shift
  * Logical rotate

This week we will be focusing on creating functions that do basic algorithm operations.
=====SPECIFICATIONS=====
Use your bitwise functions from lmr0. Bit arrays should be the output. 


*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
====OUTPUT SPECIFICATIONS====
Determine a unified means of output so that all submissions have an identical format. Should get identical output to running non-bitwise versions of the same functions. 

Example: your function subtraction of 27 and 3 should output 24 just like  27 - 3 = 24. 

Make sure to be mindful of what numbers you are using in the tests. You should ideally pick numbers that could cause problems in your code, that way you can see if you are missing a case, or maybe a function is incorrect. Other than this, there is no output specification. Show your function does what it's supposed to do.

=====PROGRAM=====
Two main ways to approach this project: the more laid out approach, and the straight to the point approach. You can either do the bitwise portion of each mathematical operator and convert it to the bit array, or, just work with the bit array from the start. If you work with the bit array from the start, you might find some functions easier, but some functions could also be harder. There really isn't a "recommended" approach just whatever way you find easier to interpret and understand.

When it comes to binary division and multiplication, you may want to try using your add and subtract functions to complete the division and multiplication functions. For multiplication, you will want to add a 12-bit array to itself n amount of times based on the other function input. This may require the creation of a binary to int converter for this solution to work.
=====EXAMPLES=====
====COOL BITWISE TRICKS====
1. Right-shift is equivalent to dividing by 2\\
2. Left-shift is equivalent to multiplying by 2\\
3. AND can be used on the first bit to check for odd/even\\
=====VERIFICATION=====
Make sure to test multiple different numbers, some numbers may work while others may not.
Derive a set of tests that all submissions should perform to ascertain correctness (state the tests, the inputs, and the expected outputs). In conjunction with conforming output specifications, all submissions should match (this is the basis for writing a verification script that can automate the process).

Which, being said: once output specifications and verification tests have been established, anyone writing a verification script to automate this can be eligible to receive bonus points.

=====PSEUDOCODE=====

=====C++ operator overloading=====
C++ operator overloading could be relevant to this project as a means of cleaning up your code. With operator overloading you could go from
<code>
multiply(a, b)
</code>
To:
<code>
a * b
</code>
If you're interested in doing this the basic syntax is as follows:
<code>
struct MyStruct
{
    MyStruct operator*(MyStruct other_struct) { ... }
    bool operator==(int x) { ... }
}
</code>
Its just a function with some nice syntax!