13,289,626 members (57,911 online)
alternative version

#### Stats

15.6K views
17 bookmarked
Posted 30 Jul 2014

# Comparing doubles using Google's C++ testing framework

, 11 Aug 2014
 Rate this:
Using a portion of Google's C++ testing framework to compare doubles

## Introduction

This article uses a portion of Google's C++ testing framework to compare double precision values.  This is useful for irrational numbers which can't be exactly represented in binary.

## Background

The user is encouraged to read about the IEEE standard for floating point numbers, (IEEE 754).

## Using the code

Use the class like you would the double primitive variable type.  For single parameter construction the code uses an explicit constructor to prevent the compiler from doing implicit conversions.  Please refer to the stackoverflow question and answer for using explicit in a constructor.

```CDouble d1;
d1 = 1.0;
CDouble d2(1.0);
CDouble d3 = CDouble(1.0);
CDouble d4 = 1.0; // COMPILATION ERROR!```

At some point in time you will be faced with comparing double precision numbers.  For most of my programming career I took the "lah-lah-lah-lah" approach while plugging my ears with something.  A time came when my open source fractal software needed more accuracy in this department.  So I went digging around looking for the best way to compare 2 double precision numbers.  There is alot of information (and mis-information) about how to accomplish this task.  Some people recommend comparing the absolute value of the result from subtracting two numbers with an epsilon value and others run from the hills from this approach.  The explanation about why you don't want use an epsilon is outside of the scope of the article.  My search uncovered source code for the Google C++ testing framework and I dug into it and found the gem of information that I used to build the CDouble class. The explanation of the Google code is also outside the scope of this article but once you read about IEEE 754 then hopefully you can understand the code.  If not then any questions regarding that code should be sent straight to them :)

The following code demonstrates the instability of comparing double precision values.  Everyone knows that 3.41 equals 3.41, correct?  Everyone but your C++ compiler that is... The result is that 3.41 is not really equal to 3.41 and we get the expletive nag!

```double d1,d2,d3,d4;
d1 = 3.4;
d2 = 0.01;
d3 = d1 + d2;
d4 = 3.41;
if (d3 != d4)
MessageBox(NULL,L"WTF!",L"Comparing...",MB_ICONSTOP);
else
MessageBox(NULL,L"The universe is causal.",L"Comparing...",MB_ICONSTOP);```

The following code uses the CDouble class to solve our problem.  Now we get the correct comparison of two double precision numbers.

```double d1,d2,d3;
d1 = 3.4;
d2 = 0.01;
d3 = d1 + d2;
CDouble d4(3.41);
if (d3 != d4)
MessageBox(NULL,L"WTF!",L"Comparing...",MB_ICONSTOP);
else
MessageBox(NULL,L"The universe is causal.",L"Comparing...",MB_OK);```

Did the != comparison tickle something about what you know about C++ and operator overloading? The variable d3 is a double and d4 is a CDouble. The d4 variable is used like a double so how did the code know to do that? It knows how to do that because a double operator is defined in the class.

`operator double () const`

Wait, you say, but it if returns a double and the left hand side of the comparison is also a double, then how does the compiler know how to avoid the error in the first scenario? Clearly we have arrived at the same scenario as above when we used just doubles.  It is then you remember friend functions in operator overloading. The code makes use of C++ operator overloading to let us compare CDouble just like a double.

`friend bool operator != (double d1,CDouble d2)`

The use of chaining in the class allows for the creation of complex arithmetic and comparison logic.

`friend CDouble operator + (double d1,CDouble d2)`
```// An example that uses chaining and the friend operator != shown above
CDouble d1,d2;
d1 = 3.4;
d2 = 0.01;
if (3.41 != d1 + d2)
MessageBox(NULL,L"WTF!",L"Comparing...",MB_ICONSTOP);
else
MessageBox(NULL,L"The universe is causal.",L"Comparing...",MB_ICONSTOP);```

The explicit constructor sometimes makes more work for us.  Consider the example.

```CDouble e = CDouble(1.0);
if (e == 0) {} // COMPILATION ERROR!```

This must be coded in the following manner. Removing the explicit keyword is not an option as it gives the compiler too many similar choices and thus the code won't compile.

```CDouble e = CDouble(1.0);
if (e == 0.0) {} // OK```

What about the scenario when you must know if the value is absolutely equal to 0.0 or not, with no tolerance for error?  The following code demonstrates how to accomplish the task.

```CDouble e = CDouble(0.0);
if ((double)e == 0.0) {} // OK```

And there you have it! I hope you can make use of the class and build onto it and share any improvements. I've never considered myself an expert at C++ or a real student of the language. I am a problem solver who likes to figure out aspects of the language when I need them to solve something in particular.

## Points of Interest

The class for CDouble reminded me of why I love C++ and operator overloading.

## History

7/30/2014 - Article submission

8/11/2014 - A note about the explicit constructor

## About the Author

 Founder United States
Working as a software developer since 1989. Started out with Basic, FORTRAN and JCL, moved into Visual Basic 1.0, C, then C++, and now I work mainly in C++ using MFC, Win32, and ATL/COM. I use Microsoft Products only because that is what gives me gainful employment. Through work, I have a lot of experience with HTML, JavaScript, XSL transformations, the XMLHTTP object, PHP 4.x, and simple COM object integrations.

I've worked for the University of Oklahoma in the school of meteorology (Go SOONERS!), consulting, and now as a Senior Software Engineer. These things keep my lights on and electricity going. My dream job is to own a bowling alley and rub elbows with pro-bowlers! I'm also an avid pedicab driver and have my own cab. I like the hustle of picking up people in downtown and biking them to their destination.

## You may also be interested in...

 Pro Pro

## Comments and Discussions

 First Prev Next
 My vote of 5 Mihai MOGA13-Aug-14 4:16 Mihai MOGA 13-Aug-14 4:16
 Re: My vote of 5 Andy Bantly13-Aug-14 13:12 Andy Bantly 13-Aug-14 13:12
 Can't compare to 0 Stefan_Lang11-Aug-14 6:03 Stefan_Lang 11-Aug-14 6:03
 Re: Can't compare to 0 Andy Bantly11-Aug-14 11:26 Andy Bantly 11-Aug-14 11:26
 Re: Can't compare to 0 Stefan_Lang11-Aug-14 21:57 Stefan_Lang 11-Aug-14 21:57
 Re: Can't compare to 0 Andy Bantly12-Aug-14 4:35 Andy Bantly 12-Aug-14 4:35
 I like it! 5 Stars for you! Geoffrey Armstrong31-Jul-14 14:05 Geoffrey Armstrong 31-Jul-14 14:05
 Re: I like it! 5 Stars for you! Andy Bantly31-Jul-14 15:08 Andy Bantly 31-Jul-14 15:08
 Very Cool! koothkeeper31-Jul-14 10:32 koothkeeper 31-Jul-14 10:32
 Re: Very Cool! Andy Bantly31-Jul-14 15:12 Andy Bantly 31-Jul-14 15:12
 Re: Very Cool! koothkeeper29-Aug-14 3:27 koothkeeper 29-Aug-14 3:27
 Last Visit: 31-Dec-99 19:00     Last Update: 11-Dec-17 22:31 Refresh 1

General    News    Suggestion    Question    Bug    Answer    Joke    Praise    Rant    Admin

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.