Modern C++ way to map constant doubles to integers

Question

What is a modern way to map constant value doubles to integers?

I want this as a header only include.

I have avoided #define and started with a nest of if statements.

I believe the if statements were faster ( I had them prioritized and a few gotos in there) but the switch below seems more readable.

I looked at dis-assembly of code below and it seemed reasonable.

I do not like the giant switch. I thought there may be a better modern approach (without loosing performance or requiring linking).

inline int InchtoGauge(double d)
{
    switch (static_cast<int>(d * 10000))
    {
    case 2391: return 3;
    case 2242: return 4;
    case 2092: return 5;
    case 1943: return 6;
    case 1793: return 7;
    case 1644: return 8;
    case 1495: return 9;
    case 1345: return 10;
    case 1196: return 11;
    case 1046: return 12;
    case 897: return 13;
    case 747: return 14;
    case 673: return 15;
    case 598: return 16;
    case 538: return 17;
    case 478: return 18;
    case 418: return 19;
    case 359: return 20;
    case 329: return 21;
    case 299: return 22;
    case 269: return 23;
    case 239: return 24;
    case 209: return 25;
    case 179: return 26;
    case 164: return 27;
    case 149: return 28;
    case 135: return 29;
    case 120: return 30;
    case 105: return 31;
    case 97: return 32;
    case 90: return 33;
    case 82: return 34;
    case 75: return 35;
    case 67: return 36;
    default:return -1;
    }

}

Store the mappings as a sorted array and perform lookup with binary search (e.g. `std::lower_bound`)? — Kerrek SB, Oct 12 '15 at 13:57
[`std::unordered_map`](http://en.cppreference.com/w/cpp/container/unordered_map)? — NathanOliver, Oct 12 '15 at 13:59
Associative array, std::unordered_map or similar. If there aren't too many I'm sure the mapping would be unique, no collisions and it would perform quite well. Better than a giant switch anyway. — Robinson, Oct 12 '15 at 13:59
For an array of values, I suggest using an array. The main problem here is that *floating point values seldom match on equality*. — Cheers and hth. - Alf, Oct 12 '15 at 14:06
@Hurkyl yes I do. Might not be the general case for someone else. These are constants in my program not measurements from calipers. I may just be going about the whole issue the wrong way. — Joe McGrath, Oct 12 '15 at 14:29
@Joe: Hrm. Then the complementary question; is `InchtoGauge(0.10461)` supposed to be `12`? And what about `InchtoGauge(0.1046)`? Floating point error is involved there; `10000 * 0.1046` is probably not 1046 exactly. I'm not sure which way that will round; e.g. it might give `12` or it might give `-1`. Without knowing your actual requirements, I strongly suspect that the given implementation doesn't do what you want. — , Oct 12 '15 at 14:33
Round off error is not your friend. You're multiplying a potential inexact floating point value by 10000, and expecting the int representation to match one of your cases. If you're going that route, you need an exact type (fixed point) instead of `double` (and this is regardless of whether you use a big `switch` statement, a `std::(unorderd)map`, etc.) — PaulMcKenzie, Oct 12 '15 at 14:37
I voted to close question. It is not a good question. I am not trying to compute values but store constant data. I had these as integers originally in my code but switched to double to simplify something else. Just need to start over. Thanks for help. — Joe McGrath, Oct 12 '15 at 14:43
@JoeMcGrath: As the one who posed the question, you can just delete it. — Cheers and hth. - Alf, Oct 12 '15 at 14:47
@Cheersandhth.-Alf Says I cannot delete an answered question. — Joe McGrath, Oct 12 '15 at 14:48

Cheers and hth. - Alf · Answer 1 · 2015-10-12T14:32:31.733

2

Doing a header-only implementation of something, what you think is a problem, is not problematic.

Comparing fractional floating point values for equality, which the code shows you think is unproblematic, is the main problem here.

The function name InchtoGauge suggests that the ill-fated comparisons are meant to just be an implementation of a simple function. You should just compute that function. It looks like this (you can just interpolate on a few values):

In passing, evidently the large number of values in the code have just been computed from 5 straight line segments. At least it looks that way to me. This means you can get by with far fewer values than you have, to define the function.

edited Oct 12 '15 at 14:32

answered Oct 12 '15 at 14:12

Cheers and hth. - Alf

142,714
15
209
331

Inch to gauge is unfortunately not a simple or well defined function. Most parts of manufacturing use a look up table to find value. Does not mean it could not be implemented differently. – Joe McGrath Oct 12 '15 at 14:26
@JoeMcGrath: The function you have tried to implement is simple. I've added a graph of it. – Cheers and hth. - Alf Oct 12 '15 at 14:32

score 2 · Accepted Answer · edited May 23 '17 at 12:14

Regardless of how you actually want to use the data, I imagine it's best to first store it in some simple, exact form:

static constexpr int GaugeToInchScale = 10000;
static constexpr std::array<int, 34> GaugeToInchScaledData = { 2391, 2242, ..., 67 };
static constexpr int GaugeToInchFirstGauge = 3;

Then, any functions to use this data would be implemented in terms of the constants in whichever sense was most natural.

And if needed, other tables could be synthesized from this data — even as compile time constants if desired.

Here is a simplistic example of a compile time algorithm that just generates a linear chain of if statements that test for equality. The point of this example isn't to make an efficient algorithm, but to demonstrate how to write algorithms of this type.

// searcher<N>::search(x) assumes `x` doesn't appear among the first `N` entries
template< int N >
struct searcher {
    constexpr static int search(int x) {
        if (x == GaugeToInchScaledData[N]) {
            return N + GaugeToInchFirstGauge;
        }
        return searcher<N+1>::search(x);
    }
};

template<>
struct searcher<GaugeToInchScaledData.size()>
{
    constexpr static int search(int x) {
        return -1;
    }
};

int search(int n) { return searcher<0>::search(n); }

johnjohnlys · Answer 3 · 2015-10-12T17:05:04.727

1

I have compared switch method, unorder_map and binary_search (I ignored the *10000)

int InchtoGauge2(int d) {
    const int lut[] = {
        2391, 2242, 2092, 1943, 1793,
        1644, 1495, 1345, 1196, 1046,...
    };
    const int N = sizeof(lut)/sizeof(lut[0]);
    const int n = lower_bound(lut, lut+N, d, greater<int>()) - lut;
    return (n==N || lut[n]!=d)? -1: 3+n;
}

int InchtoGauge3(int d)
{
    unordered_map<int,int> m{
        {2391, 3},
        {2242, 4},
        {2092, 5},...
    };
    auto p = m.find(d);
    return p == m.end()? -1: p->second;
}

I have executed them for several times.

switch/case 228us
binary_search 12913us
unordered_map 1307857us

So just use the switch/case...

Edited

I try to split the cpp file (to prevent some optimaztions) and make the objects static.

The gap is still huge but becomes smaller.

The running time:

switch/case x
binary_search 15x
unordered_map 25x

edited Oct 12 '15 at 17:05

answered Oct 12 '15 at 14:50

johnjohnlys

394
1
9

Thank you for input. I find most of my old habits are faster. I am determined to find way to use modern c++ when it isn't slower. – Joe McGrath Oct 12 '15 at 14:59
What are your compiler flags? Are you compiling with optimizations? It's worth showing how you're doing the timing too; getting accurate timing is a surprisingly nontrivial task, and you may be doing things that skew the results. – Oct 12 '15 at 17:23
Also, it would help to time a real program that uses it; sometimes things (especially things like unrolled loops or lookup tables) perform *much* better when tested on their own than they do in realistic usage scenarios. – Oct 12 '15 at 17:33
On the topic of lookup tables, consider making a `char lut[2392]` that contains the result to return whenever `d < 2392`. (If you make the parameter `unsigned int` instead of `int` as well, then you don't have to test whether or not `d < 0`) – Oct 12 '15 at 17:42
@Hurkyl: I compile it with `g++ -O2`. I test the fragment by running `for (i = -10; i < 10010; ++i)` since the real usage is not described in the original question. – johnjohnlys Oct 23 '15 at 11:52

Modern C++ way to map constant doubles to integers

3 Answers3