Skip to content

A Calculator (2): Basic Four Functions

This is the second article in a series on making our very own calculator.

Introduction

When I was in 13th grade, I almost flunked math. Test after test, I was getting poor grades and it seemed that I just could not get those answers straight. I was messing up a lot. As the semester progressed, things were getting worse. Luckily, my late dad, having been a teacher himself in the past, understood the problem, and hired an old lady, a former professor, to tutor me.

She was from the old school: strict, authoritative, and always with a proverbial ruler in her hands to smack me when I would not follow her directions. (Yes, she really did it a few times, but gently, I should say. Those were different times, a different country).

After a couple of months, my grades dramatically improved. In fact, I remember the day after we got one test back, our teacher said in front of the whole class just how impressive my improvement was and that I was reaching the top of the class. It felt surreal.

She did not teach me math or how to remember the formulas.

What she did teach me was the method of doing the math.

She made me slow down and do my work, pedantically, on the paper. “Don’t rush! Slow down! Step by step! Verify it on the side!”, she would keep repeating. I was trying to calculate too many steps in my head since I was getting them right. Almost … most of the time, at least.

This brings me to the importance of step-by-step testing and verification, and this article is about prototyping and the verification of basic algorithms.

Algorithm Verification

We need to investigate and pick algorithms that we will use and verify them against a known good, “golden”, model. That platform also needs to be easy to use and debug. It should be quick to prototype various models so we can research different ideas before committing to them.

Normally, for such tasks, Python comes to mind, but for this project, I have selected C++ and MS Visual Studio’s basic console C++ project to construct such a framework. In my opinion, Visual Studio is the best freely available debugging framework. I also checked in a Makefile to compile it under Linux. Using both, I have also found certain discrepancies between the two compilers which I will describe.

The goal of this step is to verify the basic operations of addition, subtraction, multiplication, and division and the parsing of the input buffer. We want to investigate various ideas on how to do that effectively on BCD values, with mantissa and exponent processed separately. The code should be flexible and not tied to a particular mantissa width so that we could change it and see the impacts of such changes on the overall precision.

This code, a functional-level simulator, does not have to be too fancy, or fast. In fact, quite the opposite: the goal is to start mimicking some kind of low-level implementation that could be done in hardware so that the eventual translation to it may be simpler. Still, nothing is set in stone yet – as the verification progresses, it should become more obvious which parts would belong to what implementation level.

I have checked this project in on github here: Calculator Project: Proof of Concept (github.com)

I have rewritten that code many times and spent many evening hours on it as I was trying and debugging various approaches and algorithms.

Gradually, some certainties about the internal architecture started to emerge almost as all by itself. As you take certain directions, many related variables seem to naturally fall in place to form an architecturally consistent, and arguably perfect, model (ex. the way scratch registers extend calculation precision by adding extra digits). Those are the easy ones to decide, they are obvious and represent a sound engineering conclusion. The harder ones require giving up some obvious benefits to satisfy other variables (ex. selecting the mantissa or exponent widths). They are an ever-present nemesis of these engineering tradeoffs.

Somewhere in that spectrum is a decision to use BCD as the internal number specification.

Why BCD?

While the binary floating point (or IEEE 754 standard) is overwhelmingly used in general and scientific computation, fixed point BCD calculations are still very relevant in banking, finance, and commercial calculations due to their precision, accuracy, and the immunity from implicit conversion errors. In many ways, doing arithmetic with BCD digits resembles calculating values as taught in school, on a paper, digit by digit – there are no conversions to other number systems. Also, at any point in the process, digits are readily visible to a debugger which makes the algorithms easier to debug.

Hence, mantissas will be stored in BCD format.

Exponents

Exponents, however, will be stored as 8-bit binary (integer) numbers. That format simplifies the kinds of operations that need to be done with them – exponents are never addressed as individual digits and are always used as integer numbers, so keeping them in a multi-digit BCD format would make their handling unnecessarily more complicated. Moreover, we will add a bias value of 128 to it. That will “move” their range to positive integers and simplify their comparisons.

Most calculators use a two-digit exponent, from -99 to +99, so we will limit ours to that range, too. As they get internally converted to 8 binary bits, they will “lose” values in the ranges [0-28] and [228-255] and that is ok. (Maybe we could allow intermediate results to extend into those ranges.) Since exponents are always whole numbers (integers), we are not losing any precision when we convert them from a format of two-digit input buffer to integers, and back when we need to display their values. The process of such a 2-digit conversion is quite simple either way.

Input parsing

This is the first practical operation that we need to code and verify.

The deployed heuristic should be able to process any reasonably well-formatted number which a user might have typed in and produce a mantissa and exponent pair. Since the mantissa is stored in BCD format, a separate mantissa sign bit should also be extracted and stored.

We will allow two basic formats: with and without the exponent value. The test code contains a list of values that we consider valid and runs a verification algorithm on each. Note that the input parsing process does not check for incorrectly formatted numbers – it will be the job of the input editor routine to deliver us properly formatted buffers.

Number format without the exponent
Number format with the exponent

The input parser will have to normalize all input numbers. In this implementation, a normalized BCD register contains left-aligned digits, with an implied decimal point after the first digit. That decimal point is shifted by the value of the exponent.

Two numbers and their internal, normalized, representation

All internal operations will be performed on such normalized values stored in registers.

Having specified the internal number representation, we can now tackle the four basic algorithms.

Addition/Subtraction

This implementation uses a “nibble-by-nibble” serial algorithm.

Usually, the subtraction is performed by negating the subtrahend and then using the addition. Most known BCD heuristics use 9’s or 10’s complement (subtract each BCD digit from 9 or 10, add one, and then add them). That is also similar to the way processors do subtraction of binary values.

After coding in several variations of popular algorithms, I have decided to create a slightly different one, one that is more suitable to the architecture that keeps the sign bits separately from their mantissas and does not store negative numbers as complements. Our implementation of subtraction does not negate the subtrahend. There are many ways to skin a cat, as they say.

Addition and subtraction operations are complementary and are used interchangeably depending on the signs of the addend and augend, or minuend and subtrahend (the former naming a base value, the latter naming a value to be added or subtracted).

First, we align the mantissas so that their digits represent equal decimal weights. The normalized form had them all left aligned while the exponent specified the position of their decimal points. We must shift the smaller of the two to the right by the difference of their exponents so that we can add ones to ones and tens to tens.  However, this could also result in a lesser number being shifted out of existence (ex. 1e20 – 1); we recognize such cases early and return the larger value unchanged.

Since the result may need a new significant digit (as in “9+9=18”), we need to have a nibble pre-allocated for it.

Our code splits up discrete addition and subtraction cases by this heuristic:

Another twist to subtraction is that we make sure to always subtract a lesser value from a greater one, avoiding the last (MSB digit) “borrow”. When the terms are swapped, the result is the same but negative (like in “10-3=7” but “3-10=-7”)

The implemented heuristic, although slightly different from the traditional ways to solve the problem, is well suited to this architectural implementation making the code not only readable and simple but more importantly, exact.

Multiplication

There are many methods of multiplying two BCD numbers. They range from traditional iterative partial-sum methods to intermediate conversion to binary value and back. There are also different approaches to implementing a multiplier in ASIC and FPGA. However, using an FPGA embedded multiplier would not be fun, would it?

The multiplication algorithm is using 2 extra scratch registers: one to store the intermediate product and the other one for a running total of the sums of products. In the outer loop, we multiply a multiplicand with each digit of a multiplier, while in the inner loop we multiply each pair of individual digits. Each result of these iterations is then being summed with the running total.

At this time, we assume that the hardware will be able to multiply a single (4-bit) BCD nibble with another one and return a 2-nibble wide result. This may be an oversimplification and may likely change as we start designing the hardware.

The sign of a result is an XOR of the signs of the input terms. The exponent is the sum of the exponents of those terms. Simple.

Division

We use a classic “Shift and Subtract” method to divide two numbers. This method mimics long division. Since both, the dividend and divisor, are already normalized, we do not need to align their decimal digits.

To obtain each digit of a quotient, we subtract the divisor from the dividend as many times as we can (for as long as the dividend is greater or equal to a divisor) and count. To get the next digit of a quotient, we shift the dividend one place (one digit) to the left (thus multiplying it by 10, decimal). Note that many classic “Division by Shift and Subtract” algorithms shift the divisor one bit to the right instead, a process that eventually “eats up” the bottom digits of the divisor, losing the precision.

Once we have found all the quotient digits, the dividend value (which is now numerically less than the divisor) represents the remainder. If we wanted to, this convenience leaves us with an option to implement a modulus or a remainder function in the future.

Not unlike multiplication, the sign of a result is simply an XOR of the signs of the input terms while the exponent is a difference of the term’s exponents.

With all four operations, we also need to normalize the result. In the end, the total number of digits might exceed the width of our scratch register causing a loss of accuracy.

Proof of Concept

To verify our calculations, the checked-in code carries along parallel computation using a standard C++ type “double”. This data type is convenient since, when printed, it provides up to 15 decimal digits of precision. Those are the “control” or “golden” values we compare our results with.

I could have used one of many “Arbitrary Precision Math” packages instead-but taking the advantage of a C++ built-in type suffices since we don’t need our calculator to exceed its precision. We also don’t need to tie-in another, potentially large, package with our sources.

Creating a test bench, we add a set of tests to each function we implement. The tests run a function using statically defined values that include several common and corner case numbers (ex. 0, 1, 0.00000001, 0.99999999).

These values are used in combination with each other and with varying mantissa and exponent signs.

Additional test sections use purely random values. Here we use C++11 “std::minstd_rand” to generate the same pseudo-random sequence across different, compliant, C++ platforms. That way, our VS and gcc runs will use the same random sequence and we can simply compare their outputs as text files.

Although such test coverage is not exhaustive, it seems to be sufficient.

The validator code compares the output of our algorithms with the calculated control value and prints “OK” if the values match exactly, “NEAR” if the values differ by only a magnitude of the last digit (a rounding error), or “FAIL” otherwise.

Since we currently do not perform any rounding, there are many results marked as “NEAR”, as expected.

It turns out that VS and gcc libraries round numbers differently, so there is a slight mismatch in the control values between those two platforms.

For example, on VS:
123456789012345 / 0.1 = 1.2345678901234e+15 vs. +1.2345678901235e+15  NEAR (5e-14)

while, on Linux gcc:
123456789012345 / 0.1 = 1.2345678901234e+15 vs. +1.2345678901234e+15  OK

(The last number in each line is the control value calculated using a standard VS or gcc library).

I also cross-checked by hand many calculations using SpeedCrunch software, which in this case shows 1.23456789012345e15; and as with many/all other values, the difference is clearly in the rounding digit.

During the development of that code, algorithms, and tests, in the subconscious pursuit of a “perfect match”, I had to keep reminding myself that the goal of this validator was not to match a particular C++ library perfectly but to provide a well-defined and consistent accuracy of the result. At one point I have coded in the rounding function and had matched VS control values perfectly. However, the same values would mismatch when compiled with gcc (by the said rounding errors), so I decided to keep the code simpler and not do the rounding, for now, implementing only the truncation policy.

There are two major defines in the validator code: MAX_MANT specifies the number of mantissa digits for input values and the result, and MAX_SCRATCH specifies the number of mantissa digits used in the internal calculation. The latter I call, “Arithmetic Scratch Register” since it should likely map to an equivalent register in our final design.

You can change those two defines and see the impact they make on the precision of the results.

Here is the somewhat abbreviated result of the verification: Verification.txt

After getting basic algorithms to work and to match the control values, I could verify successive changes to the code by quickly re-running the tests and spot functional regressions. Such verification setup made the development process faster and less error-prone.

Finally, I iteratively rewrote the code, simplifying it into conceptually basic steps (no fancy C++ constructs!) so that we could write some kind of microcode that mimics it. The microcode will be for a simple processor we will design, and the design will greatly be influenced by the kind of operations and data structures (registers) we use in these basic algorithms.

Just like doing the basic math in 13th grade properly: we are doing it step by step, not rushing it and we are verifying it on the side. This time, though, without a proverbial ruler looming in the air…

Interesting Reads

Leave a Reply

Your email address will not be published. Required fields are marked *