print double in scientific format with no integer part

Question

A simple problem but I can't get documentation about this kind of format: I want to print a float in a Fortran scientific notation, with its integer part always being zero.

 printf("%0.5E",data); // Gives 2.74600E+02

I want to print it like this:

 .27460E+03

How can I get this result as clean as possible?

Answer 1

A string manipulation approach:

int printf_NoIntegerPart(double x, int prec) {
  char buf[20 + prec];
  sprintf(buf, "%+.*E", prec - 1, x * 10.0);  // use + for consistent width output
  if (buf[2] == '.') {
    buf[2] = buf[1];
    buf[1] = '.';
  }
  puts(buf);
}

int main(void) {
  printf_NoIntegerPart(2.74600E+02, 5);  // --> +.27460E+03
}

This will print "INF" for |x| > DBL_MAX/10

Answer 2

I tried doing this with log10() and pow(), but ended up having problems with rounding errors. So as commented by @Karoly Horvath, string manipulation is probably the best approach.

#include <stdlib.h>

char *fortran_sprintf_double(double x, int ndigits) {
  char format[30], *p;
  static char output[30];

  /* Create format string (constrain number of digits to range 1–15) */
  if (ndigits > 15) ndigits = 15;
  if (ndigits < 1) ndigits = 1;
  sprintf(format, "%%#.%dE", ndigits-1);

  /* Convert number to exponential format (multiply by 10) */
  sprintf(output, format, x * 10.0);

  /* Move the decimal point one place to the left (divide by 10) */
  for (p=output+1; *p; p++) {
    if (*p=='.') {
      *p = p[-1];
      p[-1] = '.';
      break;
    }
  }

  return output;
}

Answer 3

If you only care about the integer part being 0 and not really leaving out the 0, i.e. if you're fine with 0.27460E+03 instead of .27460E+03 you could do something similar to this:

#include <stdio.h>
#include <stdlib.h>

void fortran_printf();

int main(void)
{
        double num = 274.600;
        fortran_printf(num);

        exit(EXIT_SUCCESS);
}

void fortran_printf(double num)
{
        int num_e = 0;
        while (num > 1.0) {
                num /= 10;
                num_e++;
        }

        printf("%.5fE+%02d", num, num_e);
}

Otherwise you have to take a detour over strings. Note that the code above is only meant to get you started. It certainly doesn't handle any involved cases.

Answer 4

printf() will not meet OP’s goal in one step using some special format. Using sprintf() to form the initial textual result is a good first step, care must be exercised when trying to do “math” with string manipulation.

Akin to @user3121023 deleted answer.

#include <assert.h>
#include <stdlib.h>
#include <stdio.h>

int printf_NoIntegerPart(double x, int prec) {
  assert(prec >= 2 && prec <= 100);
  char buffer[prec + 16];  // Form a large enough buffer.
  sprintf(buffer, "%.*E", prec - 1, x);

  int dp = '.'; // Could expand code here to get current local's decimal point.
  char *dp_ptr = strchr(buffer, dp);
  char *E_ptr = strchr(buffer, 'E');
  // Insure we are not dealing with infinity, Nan, just the expected format.
  if (dp_ptr && dp_ptr > buffer && E_ptr) {
    // Swap dp and leading digit
    dp_ptr[0] = dp_ptr[-1];
    dp_ptr[-1] = dp;
    // If x was not zero …
    if (x != 0) {
      int expo = atoi(&E_ptr[1]);  // Could use `strtol()`
      sprintf(&E_ptr[1], "%+.02d", expo + 1);
    }
  }
  return puts(buffer);
}

int main(void) {
  printf_NoIntegerPart(2.74600E+02, 5); // ".27460E+03"
  return 0;
}

Answer 5

Faced same issue while fortran porting. DId not found std C format :( Implemented both approaches - with log10/pow and with string manipulation.

#include <ansi_c.h>
#define BUFFL  16    

// using log10 , 3 digits after "."
char* fformat1(char* b, double a) {
int sign = 1;
double mant;              
double order;
int ord_p1;

if (a<0) {  
        sign =-1;
        a = -a;
    }
order=log10 (a);
if (order >=0) ord_p1 = (int) order +1; // due sto property of int
    else       ord_p1 = (int) order;

mant=a/(pow(10,ord_p1));

sprintf(b,"%.3fE%+03d",mant,ord_p1);

if (sign==-1) b[0]='-';
return b;      
}


// using string manipulation
char* fformat2(char* b, double a) {;    
int sign = 1;
int i;
int N=3;

if (a<0) {  
        sign =-1;
        a = -a;
    }

sprintf(b,"%0.3E",a*10); // remember - we *10 to have right exponent

b[1]=b[0];              // 3.123 => .3123 
b[0]='.';
for (i=N; i>=0; i--)        // and shif all left
    b[i+1]=b[i];
b[0]='0';               // pad with zero   0.312            
if (sign==-1) b[0]='-';  // sign if needed
return b;
}




int main () {
char b1[BUFFL];     // allocate buffer outside. 
char b2[BUFFL];
char b3[BUFFL];
char b4[BUFFL];   
char b5[BUFFL];   


printf("%s %s %s   %s %s \n", fformat(b1,3.1), fformat(b2,-3.0), fformat(b3,3300.), 
        fformat(b4,0.03), fformat(b5,-0.000221));

printf("%s %s %s   %s %s \n", fformat2(b1,3.1), fformat2(b2,-3.0), fformat2(b3,3300.), 
        fformat2(b4,0.03), fformat2(b5,-0.000221));


return 1;

}