White Paper (pdf):
High precision C++
arithmetic (345 KB)

Why Use The Base/1 Number Class?

Base One's Number Class is a general-purpose alternative to the built-in numeric data types of C++, with added safeguards against a variety of common (and not-so-common) errors.  Whether you write programs for DOS, Windows, Unix, or any other platform, you can use our Number Class just as easily as the native C++ number types.  If you have an existing application, conversion couldn't be easier.  With a few localized changes to include our header files, huge applications can be made to support greatly enhanced precision simply by recompiling.  You could pay ten times as much for a competitor's product, and still not get the features that set the Base/1 Number Class apart from the rest.

The Unique Advantages of Base One's Number Class

• uncompromisingly exact decimal arithmetic

• up to 100 significant digits of precision with the decimal point at any desired digit

• eliminates pervasive rounding errors and automatically detects overflows

• efficient arithmetic on both very large and very small numbers

• blazingly fast comparison logic makes it ideal for searching, sorting, and indexing

• compact representation minimizes memory and disk storage requirements

• well suited to database applications, including support of nulls (blanks)

• fully documented ANSI/C++ source code with an extensive set of examples

• plus still more benefits when used with the Base/1 Foundation Component Library

As one of the world's largest banks, our client was used to dealing with large numbers. With foreign currency conversions, sensitive interest rate calculations, and precise financial reporting requirements, they were continually running into the limitations built into C++. In order to cope with large numbers, they had to sacrifice accuracy, which is definitely frowned upon in their line of business.

When the bank decided to port their application from 16 to 32-bit, they were surprised to discover that Microsoft had actually lowered the maximum precision of floating point numbers from 19 to 16 digits. Add to this the complication of planning for the new Euro currency standard, imposing still further demands on precision, and you can see how they crossed the limits of what could be handled by conventional C++ numeric data types. With C++'s large integer and currency data types, scaling logic made the prospect of dealing with more than 16 digits and more than 4 digits to the right of the decimal point a programming nightmare. They also considered third-party libraries supporting variations of Binary Coded Decimal (BCD) and Packed Decimal. These could represent large numbers, but only at the expense of choosing either grossly inflated storage requirements for fixed length fields, or highly inefficient arithmetic and comparison operations for variable length fields. In addition the reprogramming costs were unacceptable.

---

"We were astounded to discover how many of our reports showed discrepancies before and after trying out the Base/1 Number Class. We checked the arithmetic and confirmed that Base One's calculations were right."
Vice President, Deutsche Bank

---

"I was dreading the job of squeezing more precision out of our system for the Euro-awareness project. When I saw how little programming it would take with the Base/1 Number Class, I was ecstatic. We finished the project so far ahead of schedule, my boss gave me an extra 3 days of vacation."
Senior Systems Analyst, Deutsche Bank

Also see our algorithms page for in-depth descriptions and examples with more diagrams like the one below.

Even if your application doesn't require the highest level of precision, Base One's Number Class makes it easier to write reliable applications by adding convenient error-trapping features. This covers errors like Overflow, Divide by zero, Invalid sign, etc., which are not handled automatically by C++.

All too often obscure bugs result from failing to add adequate error checking logic. The Number Class provides additional capabilities for detecting and handling errors, so these details don't burden the programmer but they also don't get overlooked.

Overflow errors

If you add two conventional C++ numbers and the correct result requires more digits than the variable can hold, C++ doesn't detect the error, as you might have expected if you were accustomed to programming on old mainframe computers. Instead, C++ simply wraps the value, effectively truncating the most significant digits and producing totally incorrect results without any notification. Base One's Number Class gives you an easy way to trap and handle these errors, without having to write extra code to explicitly check for overflow on each arithmetic operation.

Division by zero

C++ also doesn't detect invalid attempts to divide a number by zero (unless you consider immediately crashing to be a form of error "detection"). This too is a type of error that the Number Class makes easy to trap and handle cleanly, again without a lot of extra code. The Number Class also detects attempts to raise 0 to a negative power.

Another important category of errors is those that can occur when converting back and forth between different types of numeric and character representations. The limited error-handling features of C++'s conversion functions are greatly improved upon in the Base/1 Number Class. For example, Number Class conversions discriminate among many specific error types, such as invalid sign, missing digit, negative number converted to an unsigned data type, particular flavors of overflow, etc. You also have the choice of detecting errors either based on a return code or by raising an exception for which you can supply your own handler.

But the main point is that clsNumDbFld numbers can be large - with many digits both to the left and to the right of the decimal point. Support for larger ranges of values avoids insidious arithmetic truncation, without any special effort dedicated to overflow error detection and handling.

Copyright © 2012, Base One International Corporation