Getting the precision of a string number

Question

I'm reading values from a text file and converting them to doubles, then, I'll need to print these values on screen, and they should look exactly the same as in the text file.

Currently, I'm using max precision when printing, and I might get results like this:

text value: 8.994279313857e-317 printed value: 8.99427931385706e-317

Each text file may have different precision, or even different precision for different values (in the same text file), and I can't store these values as strings for memory concern.

My thought is to store them as doubles with another unsigned int for precision, is there a way to get the precision out of a string number?

Answer 1

You can't have your cake and eat it too! :)

I mean, you want the exact representation of a string in a number, without having to pay the cost in terms of memory (by just storing the string^*).

So in that case the best thing you could do is to use a long double, you know the L we append at the end of numeric constants. However, of course this also has its limits (..since our computer also has limits). Moreover, what a waste of space (and processing time) would it be to use a long double for numbers that do not need, since you say that the precisions that you will meet are not fixed. So, you could do that with that code (kindly assembled by this and this answers and the std::numeric limits):

#include <fstream>
#include <vector>
#include <cstdlib>
#include <iostream>
#include <limits>

typedef std::numeric_limits< double > dbl;

int main() {
    std::ifstream ifile("example.txt", std::ios::in);
    std::vector<long double> scores;

    //check to see that the file was opened correctly:
    if (!ifile.is_open()) {
        std::cerr << "There was a problem opening the input file!\n";
        exit(1);//exit or do additional error checking
    }

    long double num = 0.0;
    //keep storing values from the text file so long as data exists:
    while (ifile >> num) {
        scores.push_back(num);
    }

    std::cout.precision(dbl::max_digits10); // you can print more digits if you like, you won't the exact representation obviously
    //verify that the scores were stored correctly:
    for (int i = 0; i < scores.size(); ++i) {
        std::cout << std::fixed << scores[i] << std::endl;
    }

    return 0;
}

which gives on my machine:

C02QT2UBFVH6-lm:~ gsamaras$ cat example.txt 
3.12345678912345678912345678 2.79
C02QT2UBFVH6-lm:~ gsamaras$ g++ -Wall main.cpp
C02QT2UBFVH6-lm:~ gsamaras$ ./a.out
3.12345678912345679
2.79000000000000000

---

If you want to go even further, then use GMP, which is "a free library for arbitrary precision arithmetic". Of course, this will won't come for free in terms of memory usage and processing time, so you should really think twice before using it!

---

*_{I feel that you are a victim of premature optimization. If I were you, I would just store the strings and see how this is going, or better yet use a numeric data type, thus losing some precision, making your life far easier. When the project is ready see what results you are getting and if the precision achieved pleases "your boss". If not, use strings (or gmp).}

Answer 2

The right way is to use some class represents any numeric value faithfully. To represent such values you can use the arbitrary precision integer class with scale factor. For example, it can be defined like the following:

#include <boost/multiprecision/cpp_int.hpp>

// numeric = value/pow(10, scale)
struct numeric {
  /// arbitrary precision integer
  boost::multiprecision::cpp_int value;
  /// point position
  int scale;
};
// for example, 10.1 can be represented with the numeric class exactlty in difference to double :
numeric n{101, 1}; // 101/pow(10, 1)

To print such number you can use helper function which convert objects of the numeric class to std::string:

std::string to_string(const numeric& n)  const
{
  if (n.value.is_zero() && n.scale <= 0)
    return "0";
  bool neg = n.value < 0;
  std::string r;
  {
    std::ostringstream s;
    s << (neg ? -n.value : n.value);
    s.str().swap(r);
  }
  if (n.scale > 0) {
    if (n.scale >= r.length()) {
      r = std::string(n.scale - r.length() + 1, '0') + r;
    }
    r.insert(r.length() - n.scale, 1, '.');
    if (neg)
      r = '-' + r;
  }
  else if (n.scale < 0) {
    if (neg)
      r = '-' + r;
    r += std::string(-n.scale, '0');
  }
  else {
    if (neg)
      r = '-' + r;
  }
  return std::move(r);
}

To construct the numeric object from std::string you can find point position (that is scale of the numeric), remove point and init cpp_int with the cleared from a point string.