changing decimals to integars

Question

I'm trying to convert decimals into whole integers. Thus, far I have found three methods that kind of work and several that don't. It seems mighty peculiar that:

A: Trials A and B fail at the opposite ends of the spectrum.

B: If I change the values 0.14 and 0.28 inside of the array arr_decimals[7] then trial C works. Any value with a 4 or an 8 at those two indices fail! Just about any other value works.

Literally, just changed 14 to 17 and 28 to 27.

I have been struggling with these three solutions for four days and none of them work, completely.

#include <iostream>

int main()
{
    // long doubles for scalablility
    long double arr_decimals[7]{ 0.02, 0.06, 0.1, 0.14, 0.18, 0.22, 0.28 };

    long double arr_pre_values[7]{ 0, 0, 0, 0, 0, 0, 0 };
    long double arr_not_values[7]{ 0, 0, 0, 0, 0, 0, 0 };

    long double arr_input_values[7]{ 0, 0, 0, 0, 0, 0, 0 };
    long double arr_test_values[7]{ 0, 0, 0, 0, 0, 0, 0 };

    int var_array_length = 7;
    int var_int_value = 0;
    bool bool_more_trailing_zeros = 0;

    // trial A:
    std::cout << "trial A:" << std::endl;
    for (int var_change = 0; var_change < var_array_length; var_change++)
    {
        if (arr_decimals[var_change] >= 0.000001 && arr_decimals[var_change] < 0.000009)        arr_pre_values[var_change] = arr_decimals[var_change] * 10000000;       // seven decimals places
        else if (arr_decimals[var_change] >= 0.00001 && arr_decimals[var_change] < 0.00009)     arr_pre_values[var_change] = arr_decimals[var_change] * 1000000;        // six ...
        else if (arr_decimals[var_change] >= 0.0001 && arr_decimals[var_change] < 0.0009)       arr_pre_values[var_change] = arr_decimals[var_change] * 100000;         // five ...
        else if (arr_decimals[var_change] >= 0.001 && arr_decimals[var_change] < 0.009)         arr_pre_values[var_change] = arr_decimals[var_change] * 10000;          // four ...
        else if (arr_decimals[var_change] >= 0.01 && arr_decimals[var_change] < 0.09)           arr_pre_values[var_change] = arr_decimals[var_change] * 1000;           // three ...
        else if (arr_decimals[var_change] >= 0.1 && arr_decimals[var_change] < 0.9)             arr_pre_values[var_change] = arr_decimals[var_change] * 100;            // two ..
        else if (arr_decimals[var_change] < 1)                                                  arr_pre_values[var_change] = arr_decimals[var_change] * 10;             // one ..
        else                                                                                    std::cout << "Error: unexpected value: " << arr_decimals[var_change] << std::endl;

        std::cout << "arr_pre_values: " << arr_pre_values[var_change] << std::endl;
    }
    std::cout << std::endl;

    // trial B:
    std::cout << "trial B:" << std::endl;
    for (int var_change = 0; var_change < var_array_length; var_change++)
    {
        if (arr_decimals[var_change] < 0.000001)        arr_not_values[var_change] = arr_decimals[var_change] * 10000000;       // seven decimals places
        else if (arr_decimals[var_change] < 0.000009)   arr_not_values[var_change] = arr_decimals[var_change] * 1000000;        // six ...
        else if (arr_decimals[var_change] < 0.00009)    arr_not_values[var_change] = arr_decimals[var_change] * 100000;         // five ...
        else if (arr_decimals[var_change] < 0.0009)     arr_not_values[var_change] = arr_decimals[var_change] * 10000;          // four ...
        else if (arr_decimals[var_change] < 0.009)      arr_not_values[var_change] = arr_decimals[var_change] * 1000;           // three ...
        else if (arr_decimals[var_change] < 0.09)       arr_not_values[var_change] = arr_decimals[var_change] * 100;            // two ..
        else if (arr_decimals[var_change] < 1)          arr_not_values[var_change] = arr_decimals[var_change] * 10;             // one ..
        else                                            std::cout << "Error: unexpected value: " << arr_decimals[var_change] << std::endl;

        std::cout << "arr_not_values: " << arr_not_values[var_change] << std::endl;
    }
    std::cout << std::endl;

    // trial C:
    std::cout << "trial C:" << std::endl;
    std::copy(std::begin(arr_decimals), std::end(arr_decimals), std::begin(arr_input_values));
    for (int var_change = 0; var_change < var_array_length; var_change++)
    {
        bool_more_trailing_zeros = 1;
        while (bool_more_trailing_zeros)
        {
            std::cout << "arr_input_values: " << arr_input_values[var_change] << std::endl;
            var_int_value = static_cast<long double>(arr_input_values[var_change]);
            std::cout << "var_int_value: " << var_int_value << std::endl;

            // compare long double to int
            if (arr_input_values[var_change] != var_int_value)
            {
                arr_input_values[var_change] *= 10;
            }
            // move value and end loop
            else // if (arr_input_values[var_change] == var_int_value)
            {
                arr_test_values[var_change] = arr_input_values[var_change];
                bool_more_trailing_zeros = 0;
            }
        }
        std::cout << typeid(var_int_value).name() << " --------->> " << "arr_test_values: " << arr_test_values[var_change] << std::endl;
    }
    return 0;
}

failed console print out:

>! arr_pre_values: 20
>! arr_pre_values: 60
>! arr_pre_values: 10
>! arr_pre_values: 14
>! arr_pre_values: 18
>! arr_pre_values: 22
>! arr_pre_values: 28
>! 
>! arr_not_values: 2
>! arr_not_values: 6
>! arr_not_values: 1
>! arr_not_values: 1.4
>! arr_not_values: 1.8
>! arr_not_values: 2.2
>! arr_not_values: 2.8
>! 
>! arr_input_values: 0.02
>! var_int_value: 0
>! arr_input_values: 0.2
>! var_int_value: 0
>! arr_input_values: 2
>! var_int_value: 2
>! int --------->> arr_test_values: 2
>! arr_input_values: 0.06
>! var_int_value: 0
>! arr_input_values: 0.6
>! var_int_value: 0
>! arr_input_values: 6
>! var_int_value: 6
>! int --------->> arr_test_values: 6
>! arr_input_values: 0.1
>! var_int_value: 0
>! arr_input_values: 1
>! var_int_value: 1
>! int --------->> arr_test_values: 1
>! arr_input_values: 0.14
>! var_int_value: 0
>! arr_input_values: 1.4
>! var_int_value: 1
>! arr_input_values: 14
>! var_int_value: 14
>! arr_input_values: 140
>! var_int_value: 140
>! arr_input_values: 1400
>! var_int_value: 1400
>! arr_input_values: 14000
>! var_int_value: 14000
>! arr_input_values: 140000
>! var_int_value: 140000
>! arr_input_values: 1.4e+06
>! var_int_value: 1400000
>! arr_input_values: 1.4e+07
>! var_int_value: 14000000
>! arr_input_values: 1.4e+08
>! var_int_value: 140000000
>! arr_input_values: 1.4e+09
>! var_int_value: 1400000000
>! to INF and beyond!

successuful console print out for trial C:

>! arr_input_values: 0.02
>! var_int_value: 0
>! arr_input_values: 0.2
>! var_int_value: 0
>! arr_input_values: 2
>! var_int_value: 2
>! int --------->> arr_test_values: 2
>! arr_input_values: 0.06
>! var_int_value: 0
>! arr_input_values: 0.6
>! var_int_value: 0
>! arr_input_values: 6
>! var_int_value: 6
>! int --------->> arr_test_values: 6
>! arr_input_values: 0.1
>! var_int_value: 0
>! arr_input_values: 1
>! var_int_value: 1
>! int --------->> arr_test_values: 1
>! arr_input_values: 0.17
>! var_int_value: 0
>! arr_input_values: 1.7
>! var_int_value: 1
>! arr_input_values: 17
>! var_int_value: 17
>! int --------->> arr_test_values: 17
>! arr_input_values: 0.18
>! var_int_value: 0
>! arr_input_values: 1.8
>! var_int_value: 1
>! arr_input_values: 18
>! var_int_value: 18
>! int --------->> arr_test_values: 18
>! arr_input_values: 0.22
>! var_int_value: 0
>! arr_input_values: 2.2
>! var_int_value: 2
>! arr_input_values: 22
>! var_int_value: 22
>! int --------->> arr_test_values: 22
>! arr_input_values: 0.27
>! var_int_value: 0
>! arr_input_values: 2.7
>! var_int_value: 2
>! arr_input_values: 27
>! var_int_value: 27
>! int --------->> arr_test_values: 27

I didn't look into the code. However when it comes to decimal, better not using `double` representing decimal values. Refer to [this](https://stackoverflow.com/q/14096026/4123703) for more details. — Louis Go, Nov 15 '22 at 05:46
Thanx Louis! I know 'float' is the preferred method here, but I wanna be able to use longer values later on. — Retro Epiphany, Nov 15 '22 at 05:50
Obligatory: [Is floating point math broken?](https://stackoverflow.com/questions/588004/is-floating-point-math-broken) — Retired Ninja, Nov 15 '22 at 06:05
Neither `float` or `double` is proper... decimal is decimal and unfortunately C++ doesn't support it in standard. Refer to [this](https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency) for details.. — Louis Go, Nov 15 '22 at 06:07

score 0 · Answer 1 · answered Nov 16 '22 at 07:57

0

Decimals are inaccurate. If you're just doing simple addition and subtraction and need exact numbers, you can use arrays to store decimals and integers separately.

answered Nov 16 '22 at 07:57

Minxin Yu - MSFT

2,234
1
3
14

thanxthat is the following ararys are for 'long double arr_input_values[7]{ 0, 0, 0, 0, 0, 0, 0 };' AND 'long double arr_test_values[7]{ 0, 0, 0, 0, 0, 0, 0 };' – Retro Epiphany Nov 17 '22 at 00:52
Note: when the decimal is split, it should be two integers. – Minxin Yu - MSFT Nov 17 '22 at 05:42

changing decimals to integars

1 Answers1