Is there a standard function?

Hello everybody,

I recently started studying C, and so far I didn't find a function to format
integer numbers with thousand comma separators:

30000000 value to format
30,000,000 formatted value.

Do you know if there is a standard function to do this kind of formatting?

Thank you

There is no standard function to do that as far as I know but you can read here how to do it manually, although it may be a little too much to handle if you have just started learning the language.
Question 12.11

Quote:

---

Originally Posted by claudiu

There is no standard function to do that as far as I know but you can read here how to do it manually, although it may be a little too much to handle if you have just started learning the language.
Question 12.11

---

Thanks claudiu, I'll give it a look.
If I cannot grasp the meaning, I'll try to build a function to do that.

I tried to assemble a routine for the formatting task, but it looks like
I missed something:

Code:

---

// ----------------------------------------------------------------------------------------------
// Prog_name: comma_sep.c / ver 0.0
// Date: 27 june 2010
// Author: frktons @ cprogramming forum.
//-----------------------------------------------------------------------------------------------
// A routine for separating integer numbers with thousands comma separator.
// Created with Pelles C for Windows 6.00.4
//-----------------------------------------------------------------------------------------------
#include <stdio.h>
#undef getchar
#pragma comment(lib, "\\masm32\\lib\\msvcrt.lib")

int main(int argc, char *argv[])
{
    int num1 = 30000;
    int num2 = 50000;
    int result = (num1 * num2);
    int num = result;
    char buffer[14] = {' '};
    int len_str = 14;
    int x;
    int remain = 0;
    int count = 0;
    char digit[10] = {'0','1','2','3','4','5','6','7','8','9'};   


    printf("\nThe value of result is: %d\n",result);

    for (x = len_str; x > 0; x--)
      {
        if (num == 0)
          break;       

        if (count == 3)
          {
            count = 0;
            buffer[x] = ',';
            x--;
          }

      remain = num % 10;
      num = num / 10;
      buffer[x] = digit[remain];
      count++;
   
      } 

    printf("\nThe formatted value of result is: %s\n",buffer);
    getchar();
    return 0;
}

---

What did I miss?

Thanks

I don't know if you just prefer //s or something, but you may find /**/s helpful.

What are you missing? What's wrong with the output?

Quote:

---

Originally Posted by User Name:

I don't know if you just prefer //s or something, but you may find /**/s helpful.

What are you missing? What's wrong with the output?

---

Well, // and /* */ are quite the same in C99, no problem with that.

What's missing? the printf of the final string array doesn't show up.

Code:

---

    printf("\nThe formatted value of result is: %s\n",buffer);

---

Quote:

---

Originally Posted by frktons

What did I miss?

Thanks

---

A C string is formally defined as a sequence of characters ending with and including zero. If you are going to fill a string backwards you have to take care to do it correctly:

Code:

---

int next , x;

for (x = len_str - 1 , next = 0; x > -1 && next < len_str; x-- ) {
  ... determine grouping ...

  if (comma) {
      buffer[x - next] = ',';
      next++;
  }

  buffer[x - next] = digits[remain];
  next++;

  ... update num ...
 
  if (num == 0) {
      buffer[next] = '\0';
      break;
  }
}

---

No nudging of x should be necessary; let the loop count backward.

While, in the program you wrote, result will never be negative, it is also impractical to think that always. You'll have to tweak it a bit for that.

Quote:

---

Originally Posted by whiteflags

A C string is formally defined as a sequence of characters ending with and including zero. If you are going to fill a string backwards you have to take care to do it correctly:

Code:

---

int next , x;

for (x = len_str - 1 , next = 0; x > -1 && next < len_str; x-- ) {
  ... determine grouping ...

  if (comma) {
      buffer[x - next] = ',';
      next++;
  }

  buffer[x - next] = digits[remain];
  next++;

  ... update num ...
 
  if (num == 0) {
      buffer[next] = '\0';
      break;
  }
}

---

No nudging of x should be necessary; let the loop count backward.

While, in the program you wrote, result will never be negative, it is also impractical to think that always. You'll have to tweak it a bit for that.

---

Thanks whiteflags.

I have to meditate for a while in order to understand the syntax of your code,
in the meanwhile I came up with a crumpled working solution:

Code:

---

// ----------------------------------------------------------------------------------------------
// Prog_name: comma_sep.c / ver 0.0
// Date: 27 june 2010
// Author: frktons @ cprogramming forum.
//-----------------------------------------------------------------------------------------------
// A routine for separating integer numbers with thousands comma separator.
// Created with Pelles C for Windows 6.00.4
//-----------------------------------------------------------------------------------------------
#include <stdio.h>
#undef getchar
#pragma comment(lib, "\\masm32\\lib\\msvcrt.lib")

int main(int argc, char *argv[])
{
    int num1 = 30000;
    int num2 = 50000;
    int result = (num1 * num2);
    int num = result;
    char buffer[14] = {' '};
    int len_str = 13;
    int x;
    int remain = 0;
    int count = 0;
    char digit[10] = {'0','1','2','3','4','5','6','7','8','9'};   


    printf("\nThe value of result is: %d\n",result);

    for (x = len_str; x > 0; x--)
      {
        if (num == 0)
          break;       

        if (count == 3)
          {
            count = 0;
            buffer[x] = ',';
            x--;
          }

      remain = num % 10;
      num = num / 10;
      buffer[x] = digit[remain];
      count++;
   
      } 

    printf("\nThe formatted value of result is: ");
    for (x = 0; x < 14; x++)
        printf("%c",buffer[x]);       
    getchar();
    return 0;
}

---

And the output:

Code:

---


The value of result is: 1500000000

The formatted value of result is:  1,500,000,000

---

You are totally right about the number being always positive, and I'm
going to complete the logic of the code, as soon as I know how to do it.

This is only a simple exercise I'm doing in order to learn some C syntax, nothing
more for the time being. :-)

Actually, I'm lucky you're still here cause I made a mistake. Instead of using x, you should be using the len_str variable. We don't even need x:

Code:

---

int next;

for (next = 0; next < len_str; ) {
  ... determine grouping ...

  if (comma) {
      buffer[len_str - next - 1] = ',';
      next++;
  }

  buffer[len_str - next - 1] = digits[remain];
  next++;

  ... update num ...
 
  if (num == 0) {
      buffer[next] = '\0';
      break;
  }
}

---

Sorry for the inconvenience.

Quote:

---

Originally Posted by whiteflags

Actually, I'm lucky you're still here cause I made a mistake. Instead of using x, you should be using the len_str variable. We don't even need x:

Code:

---

int next;

for (next = 0; next < len_str; ) {
  ... determine grouping ...

  if (comma) {
      buffer[len_str - next - 1] = ',';
      next++;
  }

  buffer[len_str - next - 1] = digits[remain];
  next++;

  ... update num ...
 
  if (num == 0) {
      buffer[next] = '\0';
      break;
  }
}

---

Sorry for the inconvenience.

---

Thanks again.

I'm not going anywhere, I've just arrived here and I hope I'll stay for a while. :-)

>>#undef getchar
getchar is a function, not a macro. Therefore, you cannot undefine it. The line is pointless.

>>#pragma comment(lib, "\\masm32\\lib\\msvcrt.lib")
This is implicit. The linker will always link to the standard C runtime library by default. It should be safe to remove this.

You point me to a source that says it's a macro?

But some compilers have macro and function versions
So undef line is not necessarily pointless.
Eg
IBM...
MSDN :D
Edit: sorry about double post. Internet's slow here... ;(

MSVC AFAIK does not have macro versions. But whatever floats your boat, I suppose.

I'm hoping ALL of the weird stuff is actually default project "junk".

Quote:

---

Originally Posted by Elysia

>>#undef getchar
getchar is a function, not a macro. Therefore, you cannot undefine it. The line is pointless.

>>#pragma comment(lib, "\\masm32\\lib\\msvcrt.lib")
This is implicit. The linker will always link to the standard C runtime library by default. It should be safe to remove this.

---

I'm using Pelles C, as you can see in the comments I put at the beginning of the pgm.

getchar is defined as a macro in Pelles C, and tends to give problems, so better not to use that.

the #pragma directive points to the old msvcrt.lib [not to the standard new one] for downsizing
the EXE.

:-)

Quote:

---

Originally Posted by Bayint Naung

But some compilers have macro and function versions
So undef line is not necessarily pointless.
Eg
IBM...
MSDN :D
Edit: sorry about double post. Internet's slow here... ;(

---

This is the case :-)

Quote:

---

Originally Posted by whiteflags

I'm hoping ALL of the weird stuff is actually default project "junk".

---

I'm afraid this is not the case. :-(

I added some extra code to this version in order to check for negative or positive
numbers, and to choose the separator.

Any improvement you can suggest?

Code:

---

// ----------------------------------------------------------------------------------------------
// Prog_name: comma_sep.c / ver 0.1
// This version takes into account the sign and the possibility to have different
//  separator like space, comma, point, and so on.
// Date: 27 june 2010
// Author: frktons @ cprogramming forum.
//-----------------------------------------------------------------------------------------------
// A routine for separating integer numbers with thousands separator.
// Created with Pelles C for Windows 6.00.4
//-----------------------------------------------------------------------------------------------
#include <stdio.h>
#include <stdbool.h>
#undef getchar
#pragma comment(lib, "\\masm32\\lib\\msvcrt.lib")

int main(int argc, char *argv[])
{
    bool sign = true;              // if the number has to be displayed with sign
    bool neg = false;            // if the number is negative
    bool zero = false;
    char sep = ',';                  // here I choose the separator
    int num = -12715;            // test number

    char buffer[15] = {' '};        // string array for the formatted number
    int len_str = 14;                // string lenght less the terminator NULL
    int x;                                  // generic integer counters
    int remain = 0;                  // integer variable to store the remainder
    int count = 0;                    // integer counter for positioning the separator 
    char digit[10] = {'0','1','2','3','4','5','6','7','8','9'};  // the digit to display in char shape 


    printf("\n The value of result is: %d\n",num);

    if (num == 0)
      {
          buffer[len_str] = '0';
          zero = true;
          goto pgm_end;       
      }

    if (num < 0)
      {
        neg = true;
        num = num * -1 ; // transform number to positive if negative
      }
    for (x = len_str; x >= 0; x--)
      {
        if (num == 0)
        break;

        if (count == 3)
          {
            count = 0;
            buffer[x] = sep;
            x--;
          }

      remain = num % 10;
      num = num / 10;
      buffer[x] = digit[remain];
      count++;
   
      } 

pgm_end:

    if (sign == true && neg == true)
      buffer[x] = '-';
    else if (sign == true && zero == false)
        buffer[x] = '+';
//  end if

    printf("\n The formatted value of result is: ");
    for (x = 0; x < 15; x++)
      {
        if (buffer[x] == '+' || buffer[x] == '-' || buffer[x] == sep || buffer[x] >= '0' && buffer[x] <= '9')
          printf("%c",buffer[x]);       
      }
    getchar();
    return 0;
}

---

And the output:

Code:

---


 The value of result is: -12715

 The formatted value of result is: -12,715

---

Enjoy

The most glaring problem is goto. You need to get rid of it. Use loops instead.

Quote:

---

Originally Posted by Elysia

The most glaring problem is goto. You need to get rid of it. Use loops instead.

---

It looks clear in this way, before entering any loop, to check if the value is zero and skipping
the whole routine at once.

The GOTO sin is not so unforgiveable after all. Let me do it at least once ;-)

If you have a better idea, show me your code and I'll think about it and
I'll enjoy more as well. :-)

Code:

---

// ----------------------------------------------------------------------------------------------
// Prog_name: comma_sep.c / ver 0.1
// This version takes into account the sign and the possibility to have different
//  separator like space, comma, point, and so on.
// Date: 27 june 2010
// Author: frktons @ cprogramming forum.
//-----------------------------------------------------------------------------------------------
// A routine for separating integer numbers with thousands separator.
// Created with Pelles C for Windows 6.00.4
//-----------------------------------------------------------------------------------------------
#include <stdio.h>
#include <stdbool.h>
#undef getchar
#pragma comment(lib, "\\masm32\\lib\\msvcrt.lib")

int main(int argc, char *argv[])
{
    bool sign = true;              // if the number has to be displayed with sign
    bool neg = false;            // if the number is negative
    bool zero = false;
    char sep = ',';                  // here I choose the separator
    int num = -12715;            // test number

    char buffer[15] = {' '};        // string array for the formatted number
    int len_str = 14;                // string lenght less the terminator NULL
    int x;                                  // generic integer counters
    int remain = 0;                  // integer variable to store the remainder
    int count = 0;                    // integer counter for positioning the separator 
    char digit[10] = {'0','1','2','3','4','5','6','7','8','9'};  // the digit to display in char shape 


    printf("\n The value of result is: %d\n",num);

    if (num != 0)
    {
        if (num < 0)
        {
            neg = true;
            num = num * -1 ; // transform number to positive if negative
        }
        for (x = len_str; x >= 0; x--)
      {
            if (num == 0)
                break;
            if (count == 3)
          {
              count = 0;
              buffer[x] = sep;
              x--;
            }

            remain = num % 10;
            num = num / 10;
            buffer[x] = digit[remain];
            count++;
        } 
    }
    else
    {
        buffer[len_str] = '0';
        zero = true;
    }

    if (sign == true && neg == true)
        buffer[x] = '-';
    else if (sign == true && zero == false)
        buffer[x] = '+';

    printf("\n The formatted value of result is: ");
    for (x = 0; x < 15; x++)
    {
        if (buffer[x] == '+' || buffer[x] == '-' || buffer[x] == sep || buffer[x] >= '0' && buffer[x] <= '9')
        printf("%c",buffer[x]);       
    }
    return 0;
}

---

Apologies if the indentation is poor in places. I don't have an editor to properly do it here.
This gets rid of goto. Difficult, wasn't it?
It's best not to rely on goto at all, since it's a good training to make proper logic using loops instead.

Quote:

---

Originally Posted by Elysia

Code:

---

// ----------------------------------------------------------------------------------------------
// Prog_name: comma_sep.c / ver 0.1
// This version takes into account the sign and the possibility to have different
//  separator like space, comma, point, and so on.
// Date: 27 june 2010
// Author: frktons @ cprogramming forum.
//-----------------------------------------------------------------------------------------------
// A routine for separating integer numbers with thousands separator.
// Created with Pelles C for Windows 6.00.4
//-----------------------------------------------------------------------------------------------
#include <stdio.h>
#include <stdbool.h>
#undef getchar
#pragma comment(lib, "\\masm32\\lib\\msvcrt.lib")

int main(int argc, char *argv[])
{
    bool sign = true;              // if the number has to be displayed with sign
    bool neg = false;            // if the number is negative
    bool zero = false;
    char sep = ',';                  // here I choose the separator
    int num = -12715;            // test number

    char buffer[15] = {' '};        // string array for the formatted number
    int len_str = 14;                // string lenght less the terminator NULL
    int x;                                  // generic integer counters
    int remain = 0;                  // integer variable to store the remainder
    int count = 0;                    // integer counter for positioning the separator 
    char digit[10] = {'0','1','2','3','4','5','6','7','8','9'};  // the digit to display in char shape 


    printf("\n The value of result is: %d\n",num);

    if (num != 0)
    {
        if (num < 0)
        {
            neg = true;
            num = num * -1 ; // transform number to positive if negative
        }
        for (x = len_str; x >= 0; x--)
      {
            if (num == 0)
                break;
            if (count == 3)
          {
              count = 0;
              buffer[x] = sep;
              x--;
            }

            remain = num % 10;
            num = num / 10;
            buffer[x] = digit[remain];
            count++;
        } 
    }
    else
    {
        buffer[len_str] = '0';
        zero = true;
    }

    if (sign == true && neg == true)
        buffer[x] = '-';
    else if (sign == true && zero == false)
        buffer[x] = '+';

    printf("\n The formatted value of result is: ");
    for (x = 0; x < 15; x++)
    {
        if (buffer[x] == '+' || buffer[x] == '-' || buffer[x] == sep || buffer[x] >= '0' && buffer[x] <= '9')
        printf("%c",buffer[x]);       
    }
    return 0;
}

---

Apologies if the indentation is poor in places. I don't have an editor to properly do it here.
This gets rid of goto. Difficult, wasn't it?
It's best not to rely on goto at all, since it's a good training to make proper logic using loops instead.

---

Good!!! I like it. I have to say that not only you got rid of GOTO but of
getchar() as well :-)

This example is one the many to come before this routine will be ready.
Just a toy to learn some C syntax. And after all I wonder why after more than 30 years
no standard C function does this work.

I got rid of getchar because it was at the end of the main function. It is usually used to pause the console, but not in a good way. This article describes some ways, the ones near the top being the best alternatives: SourceForge.net: Pause console - cpwiki

Regarding the function, probably because the standard committee had more important things to spend their time on. They have a limited time and a lot of things to do. And there are probably libraries to do this sort of stuff. And I guess the usage is not near enough to demand the need to implement this stuff.
Most financial applications aren't done in C. They're done in high-level languages that are very secure.

Quote:

---

Originally Posted by Elysia

I got rid of getchar because it was at the end of the main function. It is usually used to pause the console, but not in a good way. This article describes some ways, the ones near the top being the best alternatives: SourceForge.net: Pause console - cpwiki

Regarding the function, probably because the standard committee had more important things to spend their time on. They have a limited time and a lot of things to do. And there are probably libraries to do this sort of stuff. And I guess the usage is not near enough to demand the need to implement this stuff.
Most financial applications aren't done in C. They're done in high-level languages that are very secure.

---

I agree with you. About the alternatives to getchar() I think I'll wait until the Windows APIs
will show me something better to do, if any exists at all. All the possible ways to halt the console
waiting for a key press are not what I really need, to do some serious coding, but fortunately it'll
be not very soon in the near future. :-)

What, exactly, do you need to do?

Quote:

---

Originally Posted by Elysia

What, exactly, do you need to do?

---

Scan the keystrokes one at a time, without having them displayed on the screen,
checking them, deciding if they are worth considering for the input field, and then
display them at a row,col position, with selected attributes, filling an input variable
with the bytes after validation, and so on.

I mean a [simple] input/output routine like the ones we used in DOS age, but with the
win32 console features.

As far as I know only Windows API will give me the fine control I need over the steps that
I briefly mentioned.

Before going into that, I think it's better to know some basic-intermediate C syntax, and
this is the reason I started studying it some weeks ago.

Of course the input/output routine is just one of the million steps forward. :-)

I selected it for the variety of thinks needed to accomplish the task. A good and maybe
useful exercise. Who knows, I can even use the routine when it is finished. ;-)

Displaying numbers with a thousands separator is a tiny part of the whole.

After a little experimentation, I came out with this 0.3 release that
is a major step towards the definitive version, next co come :-)
In this version the code for formatting is inside a function, and it is tested
for performance as well.

On my pc Core duo Intel it takes about 12 seconds to perform 100 million
formatting of a long integer, with sign and thousand separator.

I'd like some comment on possible improvement both in style, and in performance
if anybody would be so kind to point out some deficiency or better coding.

Thanks

Code:

---

// ----------------------------------------------------------------------------------------------
// Prog_name: comma_sep.c / ver 0.3
// A routine for separating integer numbers with thousands separator.
// Created with Pelles C for Windows 6.00.4
//-----------------------------------------------------------------------------------------------
// This version takes into account the sign and the possibility to have different
// separator like space, comma, point, and so on.
// Moveover this version creates a function that can be tested for performance.
//-----------------------------------------------------------------------------------------------
// Date: 03 july 2010
// Author: frktons @ cprogramming forum.
//-----------------------------------------------------------------------------------------------

#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#undef getchar
#pragma comment(lib, "\\masm32\\lib\\msvcrt.lib")

//-----------------------------------------------------------------------------------------------
// Global variables. In future versions will go into an header file
//-----------------------------------------------------------------------------------------------
    bool sign = true;              // if the number has to be displayed with sign
    bool neg = false;              // if the number is negative this flag will be set
                                              // from the function to reflect the state
    bool zero = false;            // if the number is zero the function sets this
                                              // flag for its decisions
    char sep = ',';                  // here I choose the separator
    char buffer[15] = {' '};        // string array for the formatted number

//-----------------------------------------------------------------------------------------------
// Function prototype for int_format(). Takes the number to format
// and the address of the string to fill. Returns nothing.
//-----------------------------------------------------------------------------------------------

void int_format(int num);

//-----------------------------------------------------------------------------------------------

int main(int argc, char *argv[])
{
 
    int num = -1234567153;  // test number to format
    int cycles = 0;


    int x;                                  // generic integer counter
    time_t init_time = 0;          // initial time
    time_t end_time = 0;        // end time
 
    int times = 100000000;              // for testing performance set this number for repetitions


    printf("\n The value of num is: %d\n",num);

    time(&init_time);


    printf("\n init_time =%d\n",init_time);   

    for (cycles = 0; cycles < times; cycles++) {
        int_format(num);
        for (x=0; x < 15; x++)
            buffer[x] = ' ';
    } // end for
    int_format(num);
    printf("\n The formatted value of result is: ");
    for (x = 0; x < 15; x++)
    {
        if (buffer[x] == '+' || buffer[x] == '-' || buffer[x] == sep || buffer[x] >= '0' && buffer[x] <= '9')
        printf("%c",buffer[x]);       
    }
    printf("\n");
    time(&end_time);
    printf(" end_time =%d\n",end_time);   

    printf("\n\n The routine has taken about %d seconds\n", end_time - init_time);
    getchar();
    return 0;
}
//--------------------------------------------------------------------------------------------------------------------
// Function int_format()
//--------------------------------------------------------------------------------------------------------------------

void  int_format(int num){

    int x = 0;
    int remain = 0;                  // integer variable to store the remainder
    int count = 0;                    // integer counter for positioning the separator 
    char digit[10] = {'0','1','2','3','4','5','6','7','8','9'};  // the digits to display in char shape
    int len_str = 14;                // string lenght less the terminator NULL

    if (num != 0)
    {
        if (num < 0)
        {
            neg = true;
            num = num * -1 ; // transform number to positive if negative
        }
        for (x = len_str; x >= 0; x--)
        {
            if (num == 0)
                break;
            if (count == 3)
          {
              count = 0;
              buffer[x] = sep;
              x--;
            }

            remain = num % 10;
            num = num / 10;
            buffer[x] = digit[remain];
            count++;
          } 
    }
    else
    {
        buffer[len_str] = '0';
        zero = true;
    }

    if (sign == true && neg == true)
        buffer[x] = '-';
    else if (sign == true && zero == false)
        buffer[x] = '+';

    return;

}

---

Quote:

---

Originally Posted by frktons

I'd like some comment on possible improvement both in style, and in performance
if anybody would be so kind to point out some deficiency or better coding.

---

Is there any reason that you are using global variables for values that are specific to each call of the int_format function? They should be local variables instead; some of them should be function parameters.

Quote:

---

Originally Posted by laserlight

Is there any reason that you are using global variables for values that are specific to each call of the int_format function? They should be local variables instead; some of them should be function parameters.

---

They will be part of a header file, so I was thinking about the scope of the
variables, and I decided to set them as Global.
Maybe I'm wrong, but I think variables in header are Global.

It sounds like you have the reasoning backwards. If you decide that the variable should be global, then you would likely place an extern declaration of that variable in a header. But if you started by deciding that "they will be part of a header file"... what motivated that decision?

Quote:

---

Originally Posted by laserlight

It sounds like you have the reasoning backwards. If you decide that the variable should be global, then you would likely place an extern declaration of that variable in a header. But if you started by deciding that "they will be part of a header file"... what motivated that decision?

---

I've taken into account the fact that this is an evolving function that
will be ready some weeks forward in the future. The final idea is that I'll use a structure
with these variables, and the prototype of the function, and all of them
will be in a header.

The function will be called with a pointer to the structure.

I'm reasoning this way because I'm learning C syntax but I already have in
my mind what I want. So while I develop the function, I learn the syntax
and implement new versions of the same function.

It's a kind of exercise to put into practice what I learn. :-)

Quote:

---

Originally Posted by frktons

I've taken into account the fact that this is an evolving function that
will be ready some weeks forward in the future. The final idea is that I'll use a structure
with these variables, and the prototype of the function, and all of them
will be in a header.

The function will be called with a pointer to the structure.

---

Good to hear, but as you evolve the design, avoid evolving it to a worse state. A such, if you need to give the function many parameters for now, go ahead.

Quote:

---

Originally Posted by laserlight

Good to hear, but as you evolve the design, avoid evolving it to a worse state. A such, if you need to give the function many parameters for now, go ahead.

---

Am I going to evolve it to a worse state? Sorry I did not understand your suggestion/warning. :o

By using global variables unnecessarily, you would be evolving it to a worse state.

Quote:

---

Originally Posted by laserlight

By using global variables unnecessarily, you would be evolving it to a worse state.

---

I have to pass the function these parameters:

1) bool sign - to tell the function if I want the sign or not in the formatted string
2) char buffer[15] - the workspace to prepare my integer formatted (10 digits, 3 thousand separators,
and 1 optional sign).
3) char sep - the separator to use (comma for british, point for latin, and so on)
4) the integer to format
5) maybe something else that I'm still thinking about

How would you do that?

Code:

---

void  int_format(int num, bool sign, char sep)
{
    char buffer[15];
    // ...
}

---

What is so difficult?

Ignore part 5 for the time being. You then only need 4 parameters.

EDIT:
Elysia's example probably will not work: you should pass a pointer to the first character of the buffer to the function so that you can write to it, with the result reflected in the caller. You can assume that the caller provides a string with sufficient space.

Quote:

---

Originally Posted by Elysia

Code:

---

void  int_format(int num, bool sign, char sep)
{
    char buffer[15];
    // ...
}

---

What is so difficult?

---

If the function is declared void of a return value, how am I going to have
the char buffer[] back?

Ah, then I misinterpreted what you needed it for.
Then more correct would be:

Code:

---

void  int_format(int num, bool sign, char sep, char buffer[], size_t size_of_buffer)
{
    // ...
}

---

Quote:

---

Originally Posted by Elysia

Ah, then I misinterpreted what you needed it for.
Then more correct would be:

Code:

---

void  int_format(int num, bool sign, char sep, char buffer[], size_t size_of_buffer)
{
    // ...
}

---

---

I'm thinking about pros and cons of passing arguments by value and by reference.
If I am concerned with performance, I'd avoid passing arguments by value.
This is the reason I was thinking about passing only a pointer to a structure, that
is passing arguments by reference as you know.
The global variables are faster, but there are some drawbacks:
you have to pay extra attention to what you modify, and data hiding is over
as well.

Deciding what's best depends on what you're going to decide is better:
performance, sticking to standard coding, style, whatever.

In your opinion what comes first?

Code:

---

size_t size_of_buffer

---

the above are not clear, could you explain them please?

Quote:

---

Originally Posted by frktons

I'm thinking about pros and cons of passing arguments by value and by reference.
If I am concerned with performance, I'd avoid passing arguments by value.

---

You only need to be concerned about this when passing arguments that are struct objects. Since you have not even defined your struct yet, do not be concerned about this as it would be pre-mature optimisation.

Quote:

---

Originally Posted by laserlight

You only need to be concerned about this when passing arguments that are struct objects. Since you have not even defined your struct yet, do not be concerned about this as it would be pre-mature optimisation.

---

Some programmers put comments in parts of their programs to remember that
in those points of the code they need to make some change/improvement.

I'm just doing the same, using both comments and declarations of variables
that I'm going to move elsewhere. Thinking about the present, I chose global
variables because they are faster, and I'd like the function would be 2 - 3 times
faster when I'm finished.

You can call it pre-mature optimization, or you can call it the direction you intend
to follow? Maybe both.

By the way, any other suggestion about performance or anything else?
How would you move if you wamt to have a better performance?

Well I actually need also point 5: I need to tell the function if I'd like the
formatted number being right or left aligned as well.

Quote:

---

Originally Posted by frktons

Thinking about the present, I choosed global
variables because they are faster

---

That is maybe okay if:
1) the scale of the whole program is not too big
2) this is the central operation of the whole program
3) the function in question is very short and called many times repeatedly

Otherwise, the use of globals is no optimization at all, it's just messy and pointless. It seems to me you are developing a general purpose function which you might use in some other, larger project, so in fact the use of globals here is very inappropriate.

Listen, you don't know if it's a bottleneck or not. Premature optimizations leads to bad code. Just don't do it.
It is better to create readable and easy-to-understand code and stick to standards when coding. You can then measure with a profiler to find real bottlenecks later if performance is an issue.
Just for the sake of it, I can give you some more info to make you doubt:
- Global variables aren't necessarily better. Why? Because they can be modified everywhere, the compiler cannot assume certain things that it can on local variables. Hence it cannot perform some optimizations.
- Passing things by address also causes overhead because you must dereference the pointer everytime you use it. Variables passed by value does not have this overhead.
- Of course, passing by value means that a copy of the variables needs to be made, which costs time. But pointers also has to be copied.
So you see, it isn't as black and white as you would like it.

As for the size_t size_of_buffer:
It's the size of your buffer that you pass in. Use it to make sure you don't cause a buffer overrun.
I highly recommend that you write routines for all kinds of copying that makes an assertion if you are trying to copy more data than there is room for. It will save you time hunting down bugs and will increase the security of your application.

Quote:

---

Originally Posted by MK27

That is maybe okay if:
1) the scale of the whole program is not too big
2) this is the central operation of the whole program
3) the function in question is very short and called many times repeatedly

Otherwise, the use of globals is no optimization at all, it's just messy and pointless. It seems to me you are developing a general purpose function which you might use in some other, larger project, so in fact the use of globals here is very inappropriate.

---

Yes MK27, you are absolutely right.

1) a program that print numbers, a lot of, I mean on real paper.
2) in practice yes, other than read a file and print it.
3) maybe 5 times for each data record, thousands of them

Quote:

---

Originally Posted by Elysia

Listen, you don't know if it's a bottleneck or not. Premature optimizations leads to bad code. Just don't do it.
It is better to create readable and easy-to-understand code and stick to standards when coding. You can then measure with a profiler to find real bottlenecks later if performance is an issue.
Just for the sake of it, I can give you some more info to make you doubt:
- Global variables aren't necessarily better. Why? Because they can be modified everywhere, the compiler cannot assume certain things that it can on local variables. Hence it cannot perform some optimizations.
- Passing things by address also causes overhead because you must dereference the pointer everytime you use it. Variables passed by value does not have this overhead.
- Of course, passing by value means that a copy of the variables needs to be made, which costs time. But pointers also has to be copied.
So you see, it isn't as black and white as you would like it.

As for the size_t size_of_buffer:
It's the size of your buffer that you pass in. Use it to make sure you don't cause a buffer overrun.
I highly recommend that you write routines for all kinds of copying that makes an assertion if you are trying to copy more data than there is room for. It will save you time hunting down bugs and will increase the security of your application.

---

Thanks Elysia, I'll think about these things.

I added the possibility of choice between Right-alignment and Left-alignment
of the formatted number. We are at version 0.4 so far.
The new version:

Code:

---

// ----------------------------------------------------------------------------------------------
// Prog_name: comma_sep.c / ver 0.4
// A routine for formatting integer numbers with thousand separators.
// Created with Pelles C for Windows 6.00.4
//-----------------------------------------------------------------------------------------------
// This version takes into account the sign and the possibility to have different
// separator like space, comma, point, and so on.
// Moveover this version creates a function that can be tested for performance.
// Added the choice for right and left alignment.
//-----------------------------------------------------------------------------------------------
// Date: 03 july 2010
// Author: frktons @ cprogramming forum.
//-----------------------------------------------------------------------------------------------

#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#undef getchar
#pragma comment(lib, "\\masm32\\lib\\msvcrt.lib")

//-----------------------------------------------------------------------------------------------
// Global variables. In future versions will go into an header file
//-----------------------------------------------------------------------------------------------
    bool sign = true;              // if the number has to be displayed with sign
    bool neg = false;              // if the number is negative this flag will be set
                                              // from the function to reflect the state
    bool zero = false;            // if the number is zero the function sets this
                                              // flag for its decisions
    char sep = ',';                  // here I choose the separator
    char buffer[15] = {' '};        // string array for the formatted number
    char alignment = 'R';      // choice to [R]ight-align or [L]eft-align the number 

//-----------------------------------------------------------------------------------------------
// Function prototype for int_format(). Takes the number to format
// and the address of the string to fill. Returns nothing.
//-----------------------------------------------------------------------------------------------

void int_format(int num);

//-----------------------------------------------------------------------------------------------

int main(int argc, char *argv[])
{
 
    int num = -123456;          // test number
    int cycles = 0;


    int x;                                  // generic integer counter
    time_t init_time = 0;          // initial time
    time_t end_time = 0;        // end time
    alignment = 'L';              // the formatted number will be Left-aligned
 
    int times = 50000000;      // for testing performance set this number for repetitions


    printf("\n The value of num is: %d\n",num);

    time(&init_time);

    printf("\n init_time = %d \n",init_time);   

    for (cycles = 0; cycles < times; cycles++) {
        for (x=0; x < 14; x++)
            buffer[x] = ' ';
        int_format(num);
    } // end for
   
    printf("\n The formatted value of num is: ");
    for (x = 0; x < 14; x++)
    {
        if (buffer[x] == '+' || buffer[x] == '-' || buffer[x] == sep || buffer[x] >= '0' && buffer[x] <= '9')
        printf("%c",buffer[x]);       
    }
    printf("\n\n");
    time(&end_time);
    printf(" end_time  = %d \n",end_time);   

    printf("\n\n The routine test has taken about %d seconds\n", end_time - init_time);
    for (x=0; x < 14; x++)
        buffer[x] = ' ';
//    buffer[14] = '\0';
    neg = false;
    sign = false;
    int_format(times);
    printf("\n to perform ");
    for (x = 0; x < 14; x++)
    {
        if (buffer[x] == '+' || buffer[x] == '-' || buffer[x] == sep || buffer[x] >= '0' && buffer[x] <= '9')
        printf("%c",buffer[x]);       
    }       
    printf(" cycles of the formatting function");
    getchar();
    return 0;
}
//------------------------------------------------------------------------------------------------
// Function int_format()
//------------------------------------------------------------------------------------------------

void  int_format(int num){

    int x = 0;
    int y = 0;
    int remain = 0;                  // integer variable to store the remainder
    int count = 0;                    // integer counter for positioning the separator 
    char digit[10] = {'0','1','2','3','4','5','6','7','8','9'};  // the digits to display in char shape
    int len_str = 14;                // string lenght less the terminator NULL

    if (num != 0)
    {
        if (num < 0)
        {
            neg = true;
            num = num * -1 ; // transform number to positive if negative
        }
        for (x = len_str; x >= 0; x--)
        {
            if (num == 0)
                break;
            if (count == 3)
          {
              count = 0;
              buffer[x] = sep;
              x--;
            }

            remain = num % 10;
            num = num / 10;
            buffer[x] = digit[remain];
            count++;
          } 
    }
    else
    {
        buffer[len_str] = '0';
        zero = true;
    }

    if (sign == true && neg == true)
        buffer[x] = '-';
    else if (sign == true && zero == false)
        buffer[x] = '+';

    if  (alignment  == 'L') {
        if (x == 0)
            return;
        for (y = 0; y < 15; y++, x++) {
            buffer[y] = buffer[x];
            if (buffer[y] == '\0')
                return;
        } // end for

    }

    return;

}

---

The actual performance, before optimization, is:

Code:

---


 The value of num is: -123456

 init_time = 1278177849

 The formatted value of num is: -123,456

 end_time  = 1278177853


 The routine test has taken about 4 seconds

 to perform 50,000,000 cycles of the formatting function

---

Looking forward for version 0.5 :-)

Looking forward to eliminated global variables.
Also, there is a trick in the book. If you want to convert a digit to a char, just do '0' + digit. No need for a lookup array.

Quote:

---

Originally Posted by Elysia

Looking forward to eliminated global variables.
Also, there is a trick in the book. If you want to convert a digit to a char, just do '0' + digit. No need for a lookup array.

---

Good to know. Thanks again. There will be a version with local variables
as well, not so far in the future. :-)
I'll use a char + an integer, but it surely works. This should be slower than
copying a byte from the lookup array to the string array.
If I were concerned with the performance issue I'd not use it.
I'm probably done with the new features of the function, so from now
on I can take care of the optimization and standardization task.

And now we are about half-way: 0.5 version.
I've implemented the suggestions given by some of you
about global and local variables, and replaced the lookup array
with the 'trick of the tale' Elysia pointed to.

The performances are different, but only with CPU cycles
counting I'll be sure about that.

Code:

---

// ----------------------------------------------------------------------------------------------
// Prog_name: comma_sep.c / ver 0.5
// A routine for formatting integer numbers with thousand separators.
// Created with Pelles C for Windows 6.00.4
//-----------------------------------------------------------------------------------------------
// This version takes into account the sign and the possibility to have different
// separator like space, comma, point, and so on.
// Moveover this version creates a function that can be tested for performance.
// Added the choice for right and left alignment.
// In this version Global variables have been removed.
//-----------------------------------------------------------------------------------------------
// Date: 04 july 2010
// Author: frktons @ cprogramming forum.
//-----------------------------------------------------------------------------------------------

#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#undef getchar
#pragma comment(lib, "\\masm32\\lib\\msvcrt.lib")



//-----------------------------------------------------------------------------------------------
// Function prototype for int_format(). Takes the number to format,
// the address of the string to fill, some switches and thousand separator.
// Returns nothing.
//-----------------------------------------------------------------------------------------------

void int_format(int num, char *, bool sign, bool neg, char sep, char alignment);

//-----------------------------------------------------------------------------------------------

int main(int argc, char *argv[])
{

//-----------------------------------------------------------------------------------------------
// Local variables.
//-----------------------------------------------------------------------------------------------
    bool sign = true;              // if the number has to be displayed with sign
    bool neg = false;              // if the number is negative this flag will be set
                                              // from the function to reflect the state

    char sep = ',';                  // here I choose the separator
    char buffer[15] = {' '};        // string array for the formatted number
    char alignment = ' ';        // choice to [R]ight-align or [L]eft-align the number 
    int num = -123456;          // test number
    int cycles = 0;


    int x;                                  // generic integer counter
    time_t init_time = 0;          // initial time
    time_t end_time = 0;        // end time
    alignment = 'L';              // the formatted number will be Left-aligned
 
    int times = 50000000;      // for testing performance set this number for repetitions


    printf("\n The value of num is: %d\n",num);

    time(&init_time);

    printf("\n init_time = %d \n",init_time);   

    for (cycles = 0; cycles < times; cycles++) {
        for (x=0; x < 14; x++)
            buffer[x] = ' ';
        int_format(num, buffer, sign, neg, sep, alignment);
    } // end for
   
    printf("\n The formatted value of num is: ");
    for (x = 0; x < 14; x++)
    {
        if (buffer[x] == '+' || buffer[x] == '-' || buffer[x] == sep || buffer[x] >= '0' && buffer[x] <= '9')
        printf("%c",buffer[x]);       
        if (buffer[x] == '\0')
          break;
    }
    printf("\n\n");
    time(&end_time);
    printf(" end_time  = %d \n",end_time);   

    printf("\n\n The routine test has taken about %d seconds\n", end_time - init_time);
    for (x=0; x < 14; x++)
        buffer[x] = ' ';
//    buffer[14] = '\0';
    neg = false;
    sign = false;
    int_format(times, buffer, sign, neg, sep, alignment);
    printf("\n to perform ");
    for (x = 0; x < 14; x++)
    {
        if (buffer[x] == '+' || buffer[x] == '-' || buffer[x] == sep || buffer[x] >= '0' && buffer[x] <= '9')
          printf("%c",buffer[x]);       
        if (buffer[x] == '\0')
          break;
    }       
    printf(" cycles of the formatting function");
    getchar();
    return 0;
}
//--------------------------------------------------------------------------------------------------------------------
// Function int_format()
//--------------------------------------------------------------------------------------------------------------------

void  int_format(int num, char *buffer, bool sign, bool neg, char sep, char alignment){

    int x = 0;
    int y = 0;
    int remain = 0;                  // integer variable to store the remainder
    int count = 0;                    // integer counter for positioning the separator 
    bool zero = false;            // if the number is zero the function sets this
                                              // flag for its decisions
//    char digit[10] = {'0','1','2','3','4','5','6','7','8','9'};  // the digits to display in char shape
    int len_str = 14;                // string lenght less the terminator NULL

    if (num != 0)
    {
        if (num < 0)
        {
            neg = true;
            num = num * -1 ; // transform number to positive if negative
        }
        for (x = len_str; x >= 0; x--)
        {
            if (num == 0)
                break;
            if (count == 3)
          {
              count = 0;
              buffer[x] = sep;
              x--;
            }

            remain = num % 10;
            num = num / 10;
//            buffer[x] = digit[remain];
            buffer[x] = '0' + remain;
            count++;
          } 
    }
    else
    {
        buffer[len_str] = '0';
        zero = true;
    }

    if (sign == true && neg == true)
        buffer[x] = '-';
    else if (sign == true && zero == false)
        buffer[x] = '+';

    if  (alignment  == 'L') {
        if (x == 0)
            return;
        for (y = 0; y < 15; y++, x++) {
            buffer[y] = buffer[x];
            if (buffer[y] == '\0')
                return;
        } // end for

    }

    return;

}

---

The performance gap:

Code:

---


                        Testing version : 0.40

                        ----------------------

 The value of num is: -1234567890

 init_time = 1278231197

 The formatted value of num is: -1,234,567,890

 end_time  = 1278231263


 The routine test has taken about 66 seconds

 to perform 500,000,000 cycles of the formatting function

---

versus:

Code:

---


                        Testing version : 0.50

                        ----------------------

 The value of num is: -1234567890

 init_time = 1278231354

 The formatted value of num is: -1,234,567,890

 end_time  = 1278231447


 The routine test has taken about 93 seconds

 to perform 500,000,000 cycles of the formatting function

---

It looks like version 0.4 is about 35% faster than version 0.5.

Your best version is still to come. It will feature the result of several keypresses on that big key with the left facing arrow on it. (Yes, on the upper right hand side of the keyboard).

Not only will it improve the performance, and make your program smaller, but it will remove redundancies like alignment, that are already a part of the printf() format specifiers.

You're still missing the sizeof_buffer argument. That is a no-no. You MUST have it or you must not use C.

Quote:

---

Originally Posted by Adak

Your best version is still to come. It will feature the result of several keypresses on that big key with the left facing arrow on it. (Yes, on the upper right hand side of the keyboard).

Not only will it improve the performance, and make your program smaller, but it will remove redundancies like alignment, that are already a part of the printf() format specifiers.

---

Ah! Ah! I really like your sense of humour. :-)
I think I've already heard that. Aren't you, by any chance, reinventing the joke? ;-)

You are a very experienced C coder, and I'd appreciate some more constructive
suggestions for my learning path, if you don't bother.

Quote:

---

Originally Posted by Elysia

You're still missing the sizeof_buffer argument. That is a no-no. You MUST have it or you must not use C.

---

Sorry about that, but if I MUST than I WILL :-)
Let me study the matter, I'm still a very beginner in C syntax, I don't know yet.

By the way, except from deleting the program as Adak suggested, what kind
of performance improvement could you suggest to make the function faster?
My actual objective is to reduce the elapsed time from 66'' to 32'' or less.

First off: do you absolutely have to optimize this further?
We're hitting micro optimizations soon. This means that the optimizations may be subjective to different machines and can hurt code readability and involve assembly, even.

Quote:

---

Originally Posted by Elysia

First off: do you absolutely have to optimize this further?
We're hitting micro optimizations soon. This means that the optimizations may be subjective to different machines and can hurt code readability and involve assembly, even.

---

I'm afraid I'm going that way, but not before trying to write a better algorithm
or using better C options. Optimization is, in reality, the main aim of this experiment.
As you surely know, you are a far more experienced C programmer than me, there are
already many itoa() implementations and the like. Nothing as complete as the function I'm
trying to assemble, but close enough.

I'm using Windows, and I'm going to study and implement win32 APIs.
Assembly, when needed, should be used as well. If you are not concerned
about portability, those are viable options as well.

After looking at the source in a profiler, a few lines come up as bottlenecks.
Three specific lines are:

remain = num % 10;
num = num / 10;
buffer[x] = '0' + (char)remain;

This requires some intense assembly or bit manipulation to optimize. I'm not sure how.

Quote:

---

Originally Posted by Elysia

After looking at the source in a profiler, a few lines come up as bottlenecks.
Three specific lines are:

remain = num % 10;
num = num / 10;
buffer[x] = '0' + (char)remain;

This requires some intense assembly or bit manipulation to optimize. I'm not sure how.

---

Well for the third one we already know:
better to use a lookup array.
The others are a little bit more tricky to manage.
I'll think about that. Maybe the C function that divide an integer and returns
the remainder as well could be faster?

Quote:

---

Originally Posted by frktons

better to use a lookup array.

---

Not necessarily. It takes up 4% with the integer math which translates to one instruction.

Quote:

---

Originally Posted by Elysia

Not necessarily. It takes up 4% with the integer math which translates to one instruction.

---

Let's find another solution then. :-)

With the lookup array, the 0.5 version, with local variables, takes 79''
versus 93'' of buffer[x] = '0' + (char)remain;. Better to stick with
the array then.

Code:

---


                        Testing version : 0.50

                        ----------------------

 The value of num is: -1234567890

 init_time = 1278265691

 The formatted value of num is: -1,234,567,890

 end_time  = 1278265770


 The routine test has taken about 79 seconds

 to perform 500,000,000 cycles of the formatting function

---

About the parameter you were referring in a previous post, I assumed:

Code:

---

    int len_str = 14;                // string lenght less the terminator NULL

---

in the body of the function, because I already know the max lenght the
string can be.

Did you run that test sufficiently many times? The results may spook.
It also depends heavily if the array is put into the cache or not.
Another idea is to use log10 to get the length of the number and skip the whole aligning step. I don't know if it's faster.
Another idea is that try using dynamic programming by taking your number, dividing by 10, storing into a double or float, save the reminder and the result into an array. All the while also determining the length of the number to skip the aligning step.
Then use these arrays instead of performing the calculations later. These 3 combined might save time.
The only problem is getting the reminder easily.

Base 10 is a huge problem in computers. Were it base 16, it would be very easy.

You can also check for 0 right away, and if it is, copy "0" into the buffer and return.
That means you don't have to keep a zero variable and you can safely code without having to keep in mind that the number may be 0.

Quote:

---

Originally Posted by Elysia

Did you run that test sufficiently many times? The results may spook.
It also depends heavily if the array is put into the cache or not.
Another idea is to use log10 to get the length of the number and skip the whole aligning step. I don't know if it's faster.
Another idea is that try using dynamic programming by taking your number, dividing by 10, storing into a double or float, save the reminder and the result into an array. All the while also determining the length of the number to skip the aligning step.
Then use these arrays instead of performing the calculations later. These 3 combined might save time.
The only problem is getting the reminder easily.

Base 10 is a huge problem in computers. Were it base 16, it would be very easy.

You can also check for 0 right away, and if it is, copy "0" into the buffer and return.
That means you don't have to keep a zero variable and you can safely code without having to keep in mind that the number may be 0.

---

Well, yes Elysia. As far as I know typecasting is quite a resource consuming
process when compared to simply moving a byte from a location to another.

I'd keep away from float for similar reasons.

Let me try something with register and I'll tell you if it produces any result at all.

Typecasting isn't always expensive. The
buffer[x] = '0' + (char)result;
Pretty much just moved the result into the register ax. So no type was lost in the cast there.

Also, results show that fmod is significantly slower than just perform a % b.

In this case, lookup table is faster because adding involves 2 instructions (move and add), whereas memory read only takes one (since the indexing is done by the addressing circuitry and doesn't cost clock cycles).

But this is x86 specific. Some CPUs take 2 cycles for indirect addressing.

And it also means the lookup table must be in cache, otherwise we are talking about a few hundred cycles for a cache-miss.

By the way, you didn't turn on optimizations did you?

Code:

---

The value of num is: -1234567890

 init_time = 1278267321

 The formatted value of num is: -1,234,567,890

 end_time  = 1278267324


 The routine test has taken about 3 seconds

 to perform 500,000,000 cycles of the formatting function

---

This is on 64-bit Linux, GCC 4.4.1, with -O3.

I don't think my computer is THAT much faster than yours :).

In Visual Studio, you would want to compile in Release mode.

Quote:

---

Originally Posted by Elysia

Typecasting isn't always expensive. The
buffer[x] = '0' + (char)result;
Pretty much just moved the result into the register ax. So no type was lost in the cast there.

Also, results show that fmod is significantly slower than just perform a % b.

---

The timings have to be considered when optimization matters.
I used these instructions instead of the previous ones and I got a 8-9% boost:

Code:

---

void  int_format(int number, char *buffer, bool sign, bool neg, char sep, char alignment){

    register int num = number;
    int x = 0;
    int y = 0;
    const int ten = 10;
    register int remain = 0;    // integer variable to store the remainder

---

Now the timings are:

Code:

---


                        Testing version : 0.50

                        ----------------------

 The value of num is: -1234567890

 init_time = 1278267430

 The formatted value of num is: -1,234,567,890

 end_time  = 1278267503


 The routine test has taken about 73 seconds

 to perform 500,000,000 cycles of the formatting function

---

Slightly better :-)

Using registers, when possible, gives some performance boost.

Oops, just noticed you are using something else.

You'll need to find out how to turn on optimizations, then.

Then you must not have enabled optimizations. The compiler is usually smarter than you to figure out where to use registers.
Oh, and it seems that 64-bit mode improves the performance of the code significantly.
I get 1 second with x64, from 2-3 seconds on x86 with the default number of loops.
It went to 10 from 35 when I added an extra 0. So there is a great optimization for you.
(Speed impact of using the register keyword: 0.)

Unless you are using an ancient compiler (I've never heard of Pelles C), AFAIK, all modern compilers ignore the register keyword altogether.

It's strange that 64-bit speeds things up because there is no 64-bit arithmetics, and the number of variables shouldn't be enough to cause register pressure (64-bit has a few more registers).

Well, Pelles' C should not be that bad, it takes into account the
suggestion to use register in fact the speed improved, and the
switch for optimization is on by default.

Maybe Linux has a better management of the processes, or 64 bit
has something to do as well, I actually don't know. I have to use what
I have and try to improve it. :-)

And can process more data per clock cycle, don't forget.

Quote:

---

Originally Posted by cyberfish

It's strange that 64-bit speeds things up because there is no 64-bit arithmetics, and the number of variables shouldn't be enough to cause register pressure (64-bit has a few more registers).

---

Better to speak about what processor your machine uses than the
32 or 64 bit mode.

What cpu it is is largely irrelevant. What matters if it's 64-bit capable or not.
And according to my tests, it does indeed speed it up.
Here is my test code:

Code:

---

// ----------------------------------------------------------------------------------------------
// Prog_name: comma_sep.c / ver 0.5
// A routine for formatting integer numbers with thousand separators.
// Created with Pelles C for Windows 6.00.4
//-----------------------------------------------------------------------------------------------
// This version takes into account the sign and the possibility to have different
// separator like space, comma, point, and so on.
// Moveover this version creates a function that can be tested for performance.
// Added the choice for right and left alignment.
// In this version Global variables have been removed.
//-----------------------------------------------------------------------------------------------
// Date: 04 july 2010
// Author: frktons @ cprogramming forum.
//-----------------------------------------------------------------------------------------------

#include <stdio.h>
#include <time.h>
#include <math.h>
#include <string.h>

//-----------------------------------------------------------------------------------------------
// Function prototype for int_format(). Takes the number to format,
// the address of the string to fill, some switches and thousand separator.
// Returns nothing.
//-----------------------------------------------------------------------------------------------

void int_format(int num, char *, bool sign, bool neg, char sep/*, char alignment*/);

//-----------------------------------------------------------------------------------------------

int main()
{

        //-----------------------------------------------------------------------------------------------
        // Local variables.
        //-----------------------------------------------------------------------------------------------
        bool sign = true;              // if the number has to be displayed with sign
        bool neg = false;              // if the number is negative this flag will be set
        // from the function to reflect the state

        char sep = ',';                  // here I choose the separator
        char buffer[15] = {' '};        // string array for the formatted number
        //char alignment = ' ';        // choice to [R]ight-align or [L]eft-align the number 
        int num = -123456;          // test number
        int cycles = 0;


        int x;                                  // generic integer counter
        time_t init_time = 0;          // initial time
        time_t end_time = 0;        // end time
        //alignment = 'L';              // the formatted number will be Left-aligned

        int times = 500000000;      // for testing performance set this number for repetitions


        printf("\n The value of num is: %d\n",num);

        time(&init_time);

        printf("\n init_time = %d \n",init_time);   

        for (cycles = 0; cycles < times; cycles++) {
                for (x=0; x < 14; x++)
                        buffer[x] = ' ';
                int_format(num, buffer, sign, neg, sep/*, alignment*/);
        } // end for

        printf("\n The formatted value of num is: ");
        for (x = 0; x < 14; x++)
        {
                if (buffer[x] == '+' || buffer[x] == '-' || buffer[x] == sep || buffer[x] >= '0' && buffer[x] <= '9')
                        printf("%c",buffer[x]);       
                if (buffer[x] == '\0')
                        break;
        }
        printf("\n\n");
        time(&end_time);
        printf(" end_time  = %d \n",end_time);   

        printf("\n\n The routine test has taken about %d seconds\n", end_time - init_time);
        for (x=0; x < 14; x++)
                buffer[x] = ' ';
        //    buffer[14] = '\0';
        neg = false;
        sign = false;
        int_format(times, buffer, sign, neg, sep/*, alignment*/);
        printf("\n to perform ");
        for (x = 0; x < 14; x++)
        {
                if (buffer[x] == '+' || buffer[x] == '-' || buffer[x] == sep || buffer[x] >= '0' && buffer[x] <= '9')
                        printf("%c",buffer[x]);       
                if (buffer[x] == '\0')
                        break;
        }       
        printf(" cycles of the formatting function");
        getchar();
        return 0;
}
//--------------------------------------------------------------------------------------------------------------------
// Function int_format()
//--------------------------------------------------------------------------------------------------------------------

void  int_format(int num, char *buffer, bool sign, bool neg, char sep/* char alignment*/){

        register int x = 0;
        //int y = 0;
        register int remain = 0;                  // integer variable to store the remainder
        register int count = 0;                    // integer counter for positioning the separator 
        // flag for its decisions
        //char digit[10] = {'0','1','2','3','4','5','6','7','8','9'};  // the digits to display in char shape

        if (num == 0)
        {
                strcpy(buffer, "0");
                return;
        }
        if (num < 0)
        {
                neg = true;
                num = -num; // transform number to positive if negative
        }
        int len_str = (int)log10((double)num);                // string lenght less the terminator NULL
        len_str += len_str / 3 + (sign ? 1 : 0) + (neg ? 1 : 0);
        for (x = len_str; ; x--, count++)
        {
                if (num == 0)
                        break;
                if (count == 3)
                {
                        count = 0;
                        buffer[x] = sep;
                        x--;
                }

                remain = num % 10;
                num /= 10;
                buffer[x] = '0' + (char)remain;
        } 
        //else
        //{
        //        buffer[len_str] = '0';
        //        zero = true;
        //}

        if (sign == true && neg == true)
                buffer[x] = '-';
        else if (sign == true)
                buffer[x] = '+';

        //if  (alignment  == 'L') {
        //        if (x == 0)
        //                return;
        //        for (y = 0; y < 15; y++, x++) {
        //                buffer[y] = buffer[x];
        //                if (buffer[y] == '\0')
        //                        return;
        //        } // end for

        //}

        return;

}

---

EDIT: Using a lookup array for the digits proves to significantly slow down the program for some reason.

Quote:

---

Well, Pelles' C should not be that bad, it takes into account the
suggestion to use register in fact the speed improved, and the
switch for optimization is on by default.

---

Well, the reason all modern compilers ignore the keyword is because they can all make better decisions than people who think they can :).

If the optimized version runs 30 times slower than GCC's, I would be worried.

Quote:

---

Maybe Linux has a better management of the processes, or 64 bit
has something to do as well, I actually don't know. I have to use what
I have and try to improve it. :-)

---

Maybe. Certainly not 30 times better, though :).

32-bit mode takes 2 seconds for me.

From what little I could find, it seems GCC optimizes better than LCC, the compiler used by Pelles C.
So, if you are concerned about performance, then switch to Visual C++/GCC. Both provide excellent binaries in terms of speed.

For some reason, your version (#72) runs in 44 seconds for me.

x64 or x86?

45 seconds on 64, 36 seconds (!) on 32.

Weird. It's probably attributed to the use of a specific compiler.
Or perhaps it's the cpu?

The value of num is: -123456

init_time = 1278269704

The formatted value of num is: -123,456

end_time = 1278269714


The routine test has taken about 10 seconds

to perform 500,000,000 cycles of the formatting function
Press any key to continue . . .

EDIT: My binary: Filebeam - Beam up that File Scottie!

Quote:

---

Originally Posted by cyberfish

Well, the reason all modern compilers ignore the keyword is because they can all make better decisions than people who think they can :).

If the optimized version runs 30 times slower than GCC's, I would be worried.


Maybe. Certainly not 30 times better, though :).

32-bit mode takes 2 seconds for me.

---

So far it's never happened that a compiler was smarter than me regarding
the matter of choosing a register :-)

I always test the program with and without the register keyword.
This case is not an exception, with the register keyword it runs faster
than without, on my pc.

The real problem is CPU + 64/32 bit mode + OS + Compiler.

Probably the combinations you are using are better than the one I am.
I have tried Elysia version, and it is much slower than mine on my pc.
By the way the test should be done with the number -1234567890 like
the one I'm using now to be relevant.

I'm going to install a Win port of GCC, just to verify if and to what extend it
depends on the compiler, even if I doubt a lot about that.

My pc is a Core Duo, 32 bit, but with Win / 64 bit installed.

Can you post the exact version you are running so we can all run the same thing?