floatを文字列に変換する
ライブラリ関数sprintfなしでC/C++で浮動小数点整数を文字列に変換するにはどうすればよいですか？
機能を探しています。 char *ftoa(float num)は、numを文字列に変換して返します。
ftoa(3.1415)は"3.1415"を返します。
Fp数を処理する場合、非常に複雑になる可能性がありますが、アルゴリズムは単純化されており、edgar holleisの答えに似ています。賞賛！浮動小数点数を処理している場合、選択した精度によっては計算が少しずれるので、複雑になります。そのため、浮動小数点数をゼロと比較するのは適切ではありません。
しかし、答えはあり、これはそれを実装するための私の試みです。ここでは、許容値を使用しているため、小数点以下の計算が多すぎて無限ループが発生することはありません。もっと良い解決策があるかもしれないと確信していますが、これはそれを行う方法をよく理解するのに役立つはずです。
char fstr[80];
float num = 2.55f;
int m = log10(num);
int digit;
float tolerance = .0001f;
while (num > 0 + precision)
{
float weight = pow(10.0f, m);
digit = floor(num / weight);
num -= (digit*weight);
*(fstr++)= '0' + digit;
if (m == 0)
*(fstr++) = '.';
m--;
}
*(fstr) = '\0';
Sophy Palの回答に基づくと、これは、ゼロ、NaN、無限、負の数、および科学的表記を考慮に入れた、少し完全なソリューションです。ただし、sprintfはより正確な文字列表現を提供します。
/*
Double to ASCII Conversion without sprintf.
Roughly equivalent to: sprintf(s, "%.14g", n);
*/
#include <math.h>
#include <string.h>
// For printf
#include <stdio.h>
static double PRECISION = 0.00000000000001;
static int MAX_NUMBER_STRING_SIZE = 32;
/**
* Double to ASCII
*/
char * dtoa(char *s, double n) {
// handle special cases
if (isnan(n)) {
strcpy(s, "nan");
} else if (isinf(n)) {
strcpy(s, "inf");
} else if (n == 0.0) {
strcpy(s, "0");
} else {
int digit, m, m1;
char *c = s;
int neg = (n < 0);
if (neg)
n = -n;
// calculate magnitude
m = log10(n);
int useExp = (m >= 14 || (neg && m >= 9) || m <= -9);
if (neg)
*(c++) = '-';
// set up for scientific notation
if (useExp) {
if (m < 0)
m -= 1.0;
n = n / pow(10.0, m);
m1 = m;
m = 0;
}
if (m < 1.0) {
m = 0;
}
// convert the number
while (n > PRECISION || m >= 0) {
double weight = pow(10.0, m);
if (weight > 0 && !isinf(weight)) {
digit = floor(n / weight);
n -= (digit * weight);
*(c++) = '0' + digit;
}
if (m == 0 && n > 0)
*(c++) = '.';
m--;
}
if (useExp) {
// convert the exponent
int i, j;
*(c++) = 'e';
if (m1 > 0) {
*(c++) = '+';
} else {
*(c++) = '-';
m1 = -m1;
}
m = 0;
while (m1 > 0) {
*(c++) = '0' + m1 % 10;
m1 /= 10;
m++;
}
c -= m;
for (i = 0, j = m-1; i<j; i++, j--) {
// swap without temporary
c[i] ^= c[j];
c[j] ^= c[i];
c[i] ^= c[j];
}
c += m;
}
*(c) = '\0';
}
return s;
}
int main(int argc, char** argv) {
int i;
char s[MAX_NUMBER_STRING_SIZE];
double d[] = {
0.0,
42.0,
1234567.89012345,
0.000000000000018,
555555.55555555555555555,
-888888888888888.8888888,
111111111111111111111111.2222222222
};
for (i = 0; i < 7; i++) {
printf("%d: printf: %.14g, dtoa: %s\n", i+1, d[i], dtoa(s, d[i]));
}
}
出力：
- printf：0、dtoa：0
- printf：42、dtoa：42
- printf：1234567.8901234、dtoa：1234567.89012344996444
- printf：1.8e-14、dtoa：1.79999999999999e-14
- printf：555555.55555556、dtoa：555555.55555555550381
- printf：-8.8888888888889e + 14、dtoa：-8.88888888888888e + 14
- printf：1.1111111111111e + 23、dtoa：1.11111111111111e + 23
log-関数を使用して、数値の大きさmを調べます。マグニチュードが負の場合は、_"0."_と適切な量のゼロを出力します。- _
10^m_で連続的に除算し、結果をintにキャストして、10進数を取得します。 _m--_次の桁。 - _
m==0_に遭遇した場合は、小数点__"."_を出力することを忘れないでください。 - 数桁後に区切ります。中断したときに_
m>0_の場合は、_"E"_およびitoa(m)を出力することを忘れないでください。
log関数の代わりに、ビットシフトして指数のオフセットを修正することにより、指数を直接抽出することもできます（IEEE 754を参照）。 Javaには、バイナリ表現を取得するためのdouble-to-bits関数があります。
/*
* Program to convert float number to string without using sprintf
*/
#include "iostream"
#include "string"
#include "math.h"
# define PRECISION 5
using namespace std;
char* floatToString(float num)
{
int whole_part = num;
int digit = 0, reminder =0;
int log_value = log10(num), index = log_value;
long wt =0;
// String containg result
char* str = new char[20];
//Initilise stirng to zero
memset(str, 0 ,20);
//Extract the whole part from float num
for(int i = 1 ; i < log_value + 2 ; i++)
{
wt = pow(10.0,i);
reminder = whole_part % wt;
digit = (reminder - digit) / (wt/10);
//Store digit in string
str[index--] = digit + 48; // ASCII value of digit = digit + 48
if (index == -1)
break;
}
index = log_value + 1;
str[index] = '.';
float fraction_part = num - whole_part;
float tmp1 = fraction_part, tmp =0;
//Extract the fraction part from num
for( int i= 1; i < PRECISION; i++)
{
wt =10;
tmp = tmp1 * wt;
digit = tmp;
//Store digit in string
str[++index] = digit +48; // ASCII value of digit = digit + 48
tmp1 = tmp - digit;
}
return str;
}
//Main program
void main()
{
int i;
float f = 123456.789;
char* str = floatToString(f);
cout << endl << str;
cin >> i;
delete [] str;
}
https://code.google.com/p/stringencoders/ で本当に良い実装を見つけました
size_t modp_dtoa(double value, char* str, int prec)
{
/* Hacky test for NaN
* under -fast-math this won't work, but then you also won't
* have correct nan values anyways. The alternative is
* to link with libmath (bad) or hack IEEE double bits (bad)
*/
if (! (value == value)) {
str[0] = 'n'; str[1] = 'a'; str[2] = 'n'; str[3] = '\0';
return (size_t)3;
}
/* if input is larger than thres_max, revert to exponential */
const double thres_max = (double)(0x7FFFFFFF);
double diff = 0.0;
char* wstr = str;
if (prec < 0) {
prec = 0;
} else if (prec > 9) {
/* precision of >= 10 can lead to overflow errors */
prec = 9;
}
/* we'll work in positive values and deal with the
negative sign issue later */
int neg = 0;
if (value < 0) {
neg = 1;
value = -value;
}
int whole = (int) value;
double tmp = (value - whole) * powers_of_10[prec];
uint32_t frac = (uint32_t)(tmp);
diff = tmp - frac;
if (diff > 0.5) {
++frac;
/* handle rollover, e.g. case 0.99 with prec 1 is 1.0 */
if (frac >= powers_of_10[prec]) {
frac = 0;
++whole;
}
} else if (diff == 0.5 && ((frac == 0) || (frac & 1))) {
/* if halfway, round up if odd, OR
if last digit is 0. That last part is strange */
++frac;
}
/* for very large numbers switch back to native sprintf for exponentials.
anyone want to write code to replace this? */
/*
normal printf behavior is to print EVERY whole number digit
which can be 100s of characters overflowing your buffers == bad
*/
if (value > thres_max) {
sprintf(str, "%e", neg ? -value : value);
return strlen(str);
}
if (prec == 0) {
diff = value - whole;
if (diff > 0.5) {
/* greater than 0.5, round up, e.g. 1.6 -> 2 */
++whole;
} else if (diff == 0.5 && (whole & 1)) {
/* exactly 0.5 and ODD, then round up */
/* 1.5 -> 2, but 2.5 -> 2 */
++whole;
}
} else {
int count = prec;
// now do fractional part, as an unsigned number
do {
--count;
*wstr++ = (char)(48 + (frac % 10));
} while (frac /= 10);
// add extra 0s
while (count-- > 0) *wstr++ = '0';
// add decimal
*wstr++ = '.';
}
// do whole part
// Take care of sign
// Conversion. Number is reversed.
do *wstr++ = (char)(48 + (whole % 10)); while (whole /= 10);
if (neg) {
*wstr++ = '-';
}
*wstr='\0';
strreverse(str, wstr-1);
return (size_t)(wstr - str);
}
次の2つの大きな問題があります。
- ビット表現を文字列に変換する
- 文字を格納するのに十分なメモリを割り当てます。
2番目の部分を解決する最も簡単な方法は、可能なすべての回答に十分な大きさのチャンクを割り当てることです。それから始めましょう。後でもっと賢くなりたいと思うでしょうが、問題の数値部分を解決するまで気にしないでください。
問題の数値部分を処理するために利用可能なツールの2つのセットがあります：直接ビット操作（マスキング、シフトなど）と算術演算（*、+、/、およびおそらく数学関数link log()） 。
原則として、ビット単位の表現に直接取り組むことができますが、将来、浮動小数点表現の形式が変更された場合、移植性はなくなります。 edgar.holleisによって提案されたメソッド は移植可能でなければなりません。
これが私が思いついたものです。それは非常に効率的で非常に簡単です。システムにitoaがあることを前提としています。
#include <math.h>
#include <string.h>
/* return decimal part of val */
int dec(float val)
{
int mult = floor(val);
while (floor(val) != ceil(val)) {
mult *= 10;
val *= 10;
}
return floor(val) - mult;
}
/* convert a double to a string */
char *ftoa(float val, char *str)
{
if (isnan(n)) {
strcpy(str, "NaN");
return str;
} else if (isinf(n)) {
strcpy(str, "inf");
return str;
}
char leading_integer[31] = {0}; // 63 instead of 31 for 64-bit systems
char trailing_decimal[31] = {0}; // 63 instead of 31 for 64-bit systems
/* fill string with leading integer */
itoa(floor(val), leading_integer, 10);
/* fill string with the decimal part */
itoa(dec(val), trailing_decimal, 10);
/* set given string to full decimal */
strcpy(str, leading_integer);
strcat(str, ".");
strcat(str, trailing_decimal);
return str;
}