arbitrary floating precision number to string - c

Question

I am new to c programming language.
What I am trying to do is to get store pi in arbitary precision and turn that to string.
int calculatePIConst (int preciznost)
{
//init var
mpfr_t x;
mpfr_init2 (x, preciznost);
//populate pi
mpfr_const_pi (x, MPFR_RNDN);
//turn to string
char abc[preciznost];
int i;
//error RUN FINISHED; Segmentation fault; core dumped; real time: 90ms; user: 0ms; system: 0ms
// mpfr_get_str (abc, i, 50, 50, x, MPFR_RNDN);
//write pi
mpfr_printf ("PI = %1.1024RNf\n", x);
mpfr_clear (x);
return *abc;
}
Here is mpfr lib documentation documentation http://www.mpfr.org/mpfr-current/mpfr.html#Miscellaneous-Functions

Answer 1

The simplest way would be to let the MPFR to allocate the string:
char* abc = NULL;
abc = mpfr_get_str (NULL, i, 10, 50, x, MPFR_RNDN);
printf ("PI = %s\n", abc);
mpfr_clear(x);
mpfr_free_str(abc);
Also check this member function from C++ wrapper for the MPFR for example:
inline std::string mpreal::toString(const std::string& format) const
{
char *s = NULL;
std::string out;
if( !format.empty() )
{
if(!(mpfr_asprintf(&s, format.c_str(), mpfr_srcptr()) < 0))
{
out = std::string(s);
mpfr_free_str(s);
}
}
return out;
}
The thing is to use mpfr_asprintf, it allocates and returns the string automatically (same as mpfr_get_str) but also lets you use the format specification.

Answer 2

From the documentation you linked to:
If str is not a null pointer, it should point to a block of storage large enough for the significand, i.e., at least max(n + 2, 7). The extra two bytes are for a possible minus sign, and for the terminating null character, and the value 7 accounts for -#Inf# plus the terminating null character.
Also, I assume you want your result in base 10, not base 50.
Try this:
char abc[preciznost + 2]; /* assuming preciznost >= 5 */
:
mpfr_get_str (abc, i, 10, 50, x, MPFR_RNDN);

Answer 3

What value are you passing for preciznost? I see that the calls can handle very large bit precision, and there is a danger that you have broken the stack with the declaration
char abc[preciznost];
I suggest you allocate memory on the heap instead, remembering to free() it later.
char *abc = malloc(preciznost);
Although it is unclear what you will be using this array for. If it is a char array of '0' or '1' bit values you will need an extra byte for the nul termintor, so
char *abc = malloc(preciznost+1);

Answer 4

The prototype is:
char *mpfr_get_str (char *str, mpfr_exp_t *expptr, int b, size_t n, mpfr_t op, mpfr_rnd_t rnd)
There are two wrong things in your code:
The array is not large enough. See the answer by squeamish ossifrage. But if you choose to use n equal to 0, it is better to let MPFR allocate the string (also suggested by Pavel Holoborodko in all cases).
The second argument must be a pointer to mpfr_exp_t. For instance:
mpfr_exp_t e;
mpfr_get_str (abc, &e, 10, 50, x, MPFR_RNDN);

Answer 5

Based on Pavel's answer, I created this function to output the string.
string Autozoom::mpfrToString(const mpfr_t& in) {
int decimalLocation;
char* outChar = NULL;
mpfr_exp_t mpfrDecimalLocation;
outChar = mpfr_get_str(NULL, &mpfrDecimalLocation, 10, 0, in, MPFR_RNDN);
decimalLocation = mpfrDecimalLocation;
string out(outChar);
if (out[0] == '-') {
out.insert(decimalLocation + 1, ".");
}
else {
out.insert(decimalLocation, ".");
}
return out;
}
This will actually take the number for the decimal point, insert it into a string and return that.