I have tried to get the number of digit from double value but it is not working properly. I have tried this:
int main()
{
double value = 123456.05;
std::cout<<"number of digit::"<<((int)std::log10(value ) + 1);
}
output::
number of digit::6
How to get exact number of digits? Expected result is 9.
Assuming that you only need this to work for double literals, the following will work.
EDIT: Added an equivalent function that works for a subset of doubles. It uses exhaustive search for all reasonable ways to display a double in decimal, there is probably some way to make it more efficient if you need this function to really scream.
#include <iostream>
#include <string.h>
#include <assert.h>
#include <cmath>
struct double_literal {
const char* string_value;
double double_value;
size_t num_digits;
};
#define DOUBLE_LITERAL(x) {#x, x, strlen(#x)};
size_t num_digits(double value){
//Double gives around 15 accurate digits usually.
//Disregarding exponential notation, there are hence only 15 reasonable
//ways to display value, ranging from 15 places in front of the decimal
//to 15 behind. Figure out which of these is best in terms of error,
//and then at the end print out how many digits are needed to display
//the number by removing unecessary zeros.
//Routine currently only handles values within these bounds
//If your value is outside, can scale it with a power of ten before
//using. Special cases for zero and negative values can also be added.
double window_stop = std::pow(10.0, 15);
double window_start = 1 + std::pow(10.0, -15);
assert(value < window_stop);
assert(value > window_start);
size_t best_window = 0;
double best_error = INFINITY;
double pow_ten_window = 1;
for(size_t window = 0; window <= 15; window++, pow_ten_window *= 10){
double rounded = fmod(
std::round(value * pow_ten_window),
window_stop
) / pow_ten_window;
double error = std::abs(rounded - value);
if (error < best_error){
best_error = error;
best_window = window;
}
}
unsigned long long best_rounding = std::llround(
fmod(
value * std::pow(10.0, best_window),
window_stop
)
);
size_t best_digits = std::llround(std::log10(best_rounding) + 1);
//Representation has an integer part => just figure out if we
//need a decimal point
if (best_window > 0){
best_digits++;
}
std::cout << best_window << std::endl;
return best_digits;
}
int main(int argc, char** argv){
struct double_literal literal DOUBLE_LITERAL(123456.05);
std::cout << "number of digit::" << literal.num_digits << std::endl;
//As a function
std::cout << "numbr of digit::" << num_digits(literal.double_value);
}
Using the literal, you can get the value of the literal in multiple forms later in the code.
The function works on non-literals as well, but only for a restricted subset of doubles. See the comments for how to generalize it for the rest.
You can convert the double value to string:
double value = 123456.05;
std::string s = std::to_string(value);
After it you need to remove trailing zeroez (because it is possible that s == "123456.050000" now):
s.erase(s.find_last_not_of('0') + 1, std::string::npos);
Than get a number of characters of this string:
std::cout<<"number of digit::"<< s.length();
(In this case you will process "." as digit)
So, the program below returns expected result:
number of digit::9
But this is not perfect for integer values, because "123" will be represented as "123." (one more character at the end). So, for integer values it is better to remove trailing "." before getting of the length:
void print_nb_digits(double value) {
std::string s = std::to_string(value);
s.erase(s.find_last_not_of('0') + 1, std::string::npos);
if (!s.empty() && !std::isdigit(s.back()))
s.pop_back();
std::cout<<"number of digit::"<< s.length();
}
double value = 123456.05;
print_nb_digits(value);
In this case the program returns correct result for value = 123456 too:
number of digit::6