modifying help plz ( int to float )

can someone please help me modify this program to read floats instead of ints?

im getting lost in my code :S

if this is not a quick fix, i guess i just have to follow each data type being passed into each function always keeping track of the data types being sent/received?

Code:

---

#include <stdio.h>

#define YESNUM              1
#define NONUM              0
#define MAX_NUM_PROCESSED  20
#define MAX_LINE_LEN        127


int GetArray(int [], int);
int GetInt(int *);
int StoI(const char *, int *);
void BSort(int [], int);
void DumpArray(const int [], int);



int main(void)
{
        int intArray[MAX_NUM_PROCESSED];
        int numRead;

        printf("This program stops reading numbers after &#37;d ", MAX_NUM_PROCESSED);
        printf("values\nor if EOF is encountered.\n\n");

        numRead=GetArray(intArray, MAX_NUM_PROCESSED);                // Load the integer array

        printf("Before sort:\n");
        DumpArray(intArray, numRead);                                                // Print the pre-sorted contents
        BSort(intArray, numRead);                                                        // Sort them

        printf("After sort:\n");
        DumpArray(intArray, numRead);                                                // Print the sorted contents

        return(0);
}



/*****************************************************************************
 * FUNCTION:        GetArray
 *
 * DESCRIPTION:        This function loads the integers read into an integer array.
 *                                It prints a message informing if an integer can be loaded
 *                                into the array.
 *
 * INPUT:                numArray                - (int []) the address of the integer array
 *                                maxNumAllowed        - (int)    the maximum number of integers
 *                                                                                  allowed
 *
 * OUTPUT                numArray                - (int []) On completion, this array is
 *                                                                                  modified
 *
 * RETURNS:                an integer indicating the actual number of integers read
 *                                and loaded into the arra
 *
 *****************************************************************************/
int GetArray(int numArray[], int maxNumAllowed)
{
        int arrayIndex=0;
        int status;


        while (arrayIndex<maxNumAllowed &&
        (status=GetInt(&numArray[arrayIndex]))!=EOF) {

                if (status==YESNUM)
                        printf("%d has been accepted\n", numArray[arrayIndex++]);
                else
                        printf("Invalid number detected, re-enter\n\a");
        }

        if (arrayIndex>=maxNumAllowed)
                printf("Maximum number of inputs reached\a\n\n");

        return(arrayIndex);
}





/*****************************************************************************
 * FUNCTION:        GetInt
 *
 * DESCRIPTION:        This function reads an integer value from the computer
 *                                standard input.
 *
 * INPUT:                pnum - (int *) the address of an integer variable
 *
 * OUTPUT:                pnum - (int *) on completion, the integer pointed by
 *                                                          this pointer will be modified.
 *
 * RETURNS:                a tri-state status code
 *                                        EOF    - on end of file
 *                                        YESNUM - a valid integer read
 *                                        NONUM  - an invalid data detected
 *               
 *****************************************************************************/
int GetInt(int *pnum)
{
        char buf[MAX_LINE_LEN+1];

        printf("Enter a number:  ");
        return( gets(buf)==NULL ? EOF : StoI(buf, pnum) );
}





/*****************************************************************************
 * FUNCTION:        StoI
 *
 * DESCRIPTION:        This function takes an ASCII-Z and converts it to an integer.
 *                                it is similar to the standard runtime library function atoi
 *
 * INPUT:                but  - (const char *) the address of an ASCII-Z
 *                                iPtr - (int *) the address of an integer variable used to
 *                                                          store the converted value.
 *
 * OUTPUT:                iPtr - (int *) On completion, the integer variable pointed
 *                                                          by this pointer is modified.
 *
 * RETURNS:                A binary status indicating the successfulness of the conversion
 *                                        NONUM  - bad conversion
 *                                        YESNUM - good conversion
 *
 *****************************************************************************/
int StoI(const char *buf, int *iPtr)
{
        int        divisor=10;
        int signBit=1;
        int arrayIndex=0;
        int conversionStatus;


        while (buf[arrayIndex]==' ')                // Strips leading spaces
                arrayIndex++;

        // Remember sign
        if (buf[arrayIndex]=='+' || buf[arrayIndex]=='-')
                signBit= (buf[arrayIndex++]=='-') ? -1 : 1;


        *iPtr=0;                                                        // Initialize the integer variable

        // This loop exploits the standard decomposition of an integer
        // For example, 123 = 1 * 10^2 + 2 * 10^1 + 3 * 10^0, etc.
        // To convert a single character digit to its numeric value,
        // simply subtract '0' from it.  This is exploitation of its
        // ASCII table behaviour.
        while(buf[arrayIndex]>='0' && buf[arrayIndex]<='9')
                *iPtr= *iPtr*10 + (buf[arrayIndex++]-'0');


        if (buf[arrayIndex]=='\0') {
                *iPtr *= signBit;
                conversionStatus=YESNUM;
        }
        else
                conversionStatus=NONUM;

        return(conversionStatus);
}





/*****************************************************************************
 * F........ION:        BSort
 *
 * DESCRIPTION:        This function uses the basic bubble sort algorithm to sort
 *                                an array of integers.
 *       
 * INPUT:                numArray  - (int []) base address of the integer array to sort.
 *                                arraySize - (int) the actual number of elements in the array.
 *
 * OUTPUT:                numArray - (int []) this array is modified on function
 *                                  completion
 *
 * RETURNS:                None
 *
 *****************************************************************************/
void BSort(int numArray[], int arraySize)
{
        int i,
                j;
        int temp;

        for (i=0; i<arraySize-1; i++)
                for (j=arraySize-1; j>i; j--)
                        if (numArray[i]>numArray[j]) {
                                temp=numArray[i];
                                numArray[i]=numArray[j];
                                numArray[j]=temp;
                        }
}





/*****************************************************************************
 * FUNCTION:        DumpArray
 *
 * DESCRIPTION:        This function prints the contents of an integer array
 *
 * INPUT:                numArray  - (int []) base address of the array to be dumped
 *                                arraySize - (int) the actual number of elements in the array.
 *
 * OUTPUT:                None
 *
 *****************************************************************************/
void DumpArray(const int numArray[], int arraySize)
{
        int arrayIndex;

        printf("The list is:\n\n");
        for (arrayIndex=0; arrayIndex<arraySize; arrayIndex++)
                printf("%#3d:  %d\n", arrayIndex+1, numArray[arrayIndex]);
}

---

Oh, come on! You have such a nice code, sure you can make this little change.

Yes, change appropriate ints to floats and don't forget I/O format flags.

ive been staring at this for the past hour and cant seem to figure it out..
i keep running circles i think ...

maybe i shouldnt have eaten so many burritos for lunch
i think the beans are affecting my ability to concentrate

This isn't that difficult. Make a new copy of the source code, and start hacking it up. Change the declarations and the format flags as was already stated.

If you can't do this, I am seriously in doubt you wrote the code.

> If you can't do this, I am seriously in doubt you wrote the code.
I'd have to agree, it looks like teachers code given to the students to convert.

However, said "teacher" needs a damn good slapping for using gets().

It also seems like the language filter had a go at one of the comments ;)

ok... i did most of the dirty work, but now im getting some undesired output.

when i enter in an integer, the program converts it to a float...

but the problem is now, when i enter in a float, for ex. 2.1... the program converts it to 1.2

and if i enter in a float with more than one digit before the decimal, then i get a whole bunch of undesired outputs.

here is my code:

Code:

---


#include <stdio.h>

#define YESNUM              1
#define NONUM              0
#define MAX_NUM_PROCESSED  20
#define MAX_LINE_LEN        127


int GetArray(float [], int);
int GetInt(float *);
int StoI(const char *, float *);
void BSort(float [], int);
void DumpArray(const float [], int);



int main(void)
{
        float intArray[MAX_NUM_PROCESSED];
        int numRead;

        printf("This program stops reading numbers after %d ", MAX_NUM_PROCESSED);
        printf("values\nor if EOF is encountered.\n\n");

        numRead=GetArray(intArray, MAX_NUM_PROCESSED);                // Load the integer array

        printf("Before sort:\n");
        DumpArray(intArray, numRead);                                                // Print the pre-sorted contents
        BSort(intArray, numRead);                                                        // Sort them

        printf("After sort:\n");
        DumpArray(intArray, numRead);                                                // Print the sorted contents

        return(0);
}



/*****************************************************************************
 * FUNCTION:        GetArray
 *
 * DESCRIPTION:        This function loads the integers read into an integer array.
 *                                It prints a message informing if an integer can be loaded
 *                                into the array.
 *
 * INPUT:                numArray                - (float []) the address of the integer array
 *                                maxNumAllowed        - (int)    the maximum number of integers
 *                                                                                  allowed
 *
 * OUTPUT                numArray                - (float []) On completion, this array is
 *                                                                                  modified
 *
 * RETURNS:                an integer indicating the actual number of integers read
 *                                and loaded into the arra
 *
 *****************************************************************************/
int GetArray(float numArray[], int maxNumAllowed)
{
        int arrayIndex=0;
        int status;


        while (arrayIndex<maxNumAllowed &&
        (status=GetInt(&numArray[arrayIndex]))!=EOF) {

                if (status==YESNUM)
                        printf("%f has been accepted\n", numArray[arrayIndex++]);
                else
                        printf("Invalid number detected, re-enter\n\a");
        }

        if (arrayIndex>=maxNumAllowed)
                printf("Maximum number of inputs reached\a\n\n");

        return(arrayIndex);
}


/*****************************************************************************
 * FUNCTION:        GetInt
 *
 * DESCRIPTION:        This function reads an integer value from the computer
 *                                standard input.
 *
 * INPUT:                pnum - (float *) the address of an integer variable
 *
 * OUTPUT:                pnum - (float *) on completion, the integer pointed by
 *                                                          this pointer will be modified.
 *
 * RETURNS:                a tri-state status code
 *                                        EOF    - on end of file
 *                                        YESNUM - a valid integer read
 *                                        NONUM  - an invalid data detected
 *               
 *****************************************************************************/
int GetInt(float *pnum)
{
        char buf[MAX_LINE_LEN+1];

        printf("Enter a number:  ");
        return( gets(buf)==NULL ? EOF : StoI(buf, pnum) );
}



/*****************************************************************************
 * FUNCTION:        StoI
 *
 * DESCRIPTION:        This function takes an ASCII-Z and converts it to an integer.
 *                                it is similar to the standard runtime library function atoi
 *
 * INPUT:                but  - (const char *) the address of an ASCII-Z
 *                                iPtr - (float *) the address of an integer variable used to
 *                                                          store the converted value.
 *
 * OUTPUT:                iPtr - (int *) On completion, the integer variable pointed
 *                                                          by this pointer is modified.
 *
 * RETURNS:                A binary status indicating the successfulness of the conversion
 *                                        NONUM  - bad conversion
 *                                        YESNUM - good conversion
 *
 *****************************************************************************/
int StoI(const char *buf, float *iPtr)
{
        int divisor=10;
        int signBit=1;
        int arrayIndex=0;
        int conversionStatus;

        while (buf[arrayIndex]==' ')                // Strips leading spaces
                arrayIndex++;

        // Remember sign
        if (buf[arrayIndex]=='+' || buf[arrayIndex]=='-')
                signBit= (buf[arrayIndex++]=='-') ? -1 : 1;


        *iPtr=0;                                                        // Initialize the integer variable

        // This loop exploits the standard decomposition of an integer
        // For example, 123 = 1 * 10^2 + 2 * 10^1 + 3 * 10^0, etc.
        // To convert a single character digit to its numeric value,
        // simply subtract '0' from it.  This is exploitation of its
        // ASCII table behaviour.
        //int isDecimal = 0;
        while(buf[arrayIndex]>='0' && buf[arrayIndex]<='9' && buf[arrayIndex] != '\0')
        {

                if( buf[arrayIndex]>='0' && buf[arrayIndex]<='9' && buf[arrayIndex]!='.')
                {
                        *iPtr= *iPtr*10 + (buf[arrayIndex++]-'0'); // turning char into int... taking ascii value and subtracting char 0, to get a numeric value
                }
       
                if(buf[arrayIndex]=='.')
                {
                        arrayIndex++;
               
                        while(buf[arrayIndex]>='0' && buf[arrayIndex]<='9' && buf[arrayIndex] !='\0')
                        {
                                        *iPtr = *iPtr/10 + (buf[arrayIndex++]-'0');
                        }
                               
                }
        }
       

        if (buf[arrayIndex]=='\0') {
                *iPtr *= signBit;
                conversionStatus=YESNUM;
        }
        else
                conversionStatus=NONUM;

        return(conversionStatus);
}


/*****************************************************************************
 * F........ION:        BSort
 *
 * DESCRIPTION:        This function uses the basic bubble sort algorithm to sort
 *                                an array of integers.
 *       
 * INPUT:                numArray  - (float []) base address of the integer array to sort.
 *                                arraySize - (int) the actual number of elements in the array.
 *
 * OUTPUT:                numArray - (float []) this array is modified on function
 *                                  completion
 *
 * RETURNS:                None
 *
 *****************************************************************************/
void BSort(float numArray[], int arraySize)
{
        int i,j;
        float temp;

        for (i=0; i<arraySize-1; i++)
                for (j=arraySize-1; j>i; j--)
                        if (numArray[i]>numArray[j]) {
                                temp=numArray[i];
                                numArray[i]=numArray[j];
                                numArray[j]=temp;
                        }
}


/*****************************************************************************
 * FUNCTION:        DumpArray
 *
 * DESCRIPTION:        This function prints the contents of an float array
 *
 * INPUT:                numArray  - (float []) base address of the array to be dumped
 *                                arraySize - (int) the actual number of elements in the array.
 *
 * OUTPUT:                None
 *
 *****************************************************************************/
void DumpArray(const float numArray[], int arraySize)
{
        int arrayIndex;

        printf("The list is:\n\n");
        for (arrayIndex=0; arrayIndex<arraySize; arrayIndex++)
                printf("%#3d:  %f\n", arrayIndex+1, numArray[arrayIndex]);
}

---

AHH! Use pastebin please.

1. do not use gets - use fgets (see faq)
2. your conversion after the '.' is encountered is wrong

1.2 is not 1/10.0 + 2
it is (1* 10.0 + 2) / 10.0

32.45 = (((3*10.0 +2)*10.0 + 4)*10.0+5)/100.0

BTW why not to use strtod?

That's not bubble sort you've implemented there. "Bubble Sort" is stable.
What you've written is what some would call "Simple Sort" and is not stable.

For your purposes however, it will also do just fine.

Don't forget to change also: variable and function names, and comments. float intArray is rather scary...

A similar program to do the work is the following. This is made for integers not float numbers, but i want to give you the idea of thinking what i did and if you get it right you will get it work out.

PHP Code:

---

[code]

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

//Reads a string from input, the string should be a number.

int* GetInt(int Size, int *Asize, int *Sign)
{
      if(Size > 0)
      {
              //For loop.
              
              int i;
              int j = 0;
              char c;
              int sign = 1;
              int number = 0;
              
              //Buffer to hold data.
              
              char *buffer = NULL;
              
              //Array to hold the return digits.
              
              int *A = NULL;
              
              //Work it.
              
              buffer = (char *)malloc(sizeof(char) * Size);
              if(buffer == NULL)
              {
                        printf("Error no memory available.\n");
                        return NULL;
              }
              
              if(fgets(buffer, Size, stdin) == NULL)
              {
                                printf("Error, in fgets().\n");
                                return NULL;
              }
              if(buffer[strlen(buffer) - 1] == '\n')
                                       buffer[strlen(buffer) - 1] = '\0';
              
                                       
              //Loop now to get the number.
              
              for(i = 0; i < strlen(buffer); i++)
              {
                    c = buffer[i];
                    if(!i && (c == '+' || c == '-'))
                          sign = (c == '+') ? 1 : -1;
                    if(isalpha(c) || isspace(c))
                    {
                         printf("Error in input in place %d, incorrect symbol %c.\n", i, c);
                         break;
                    }
                    if(isdigit(c))
                    {
                                  //Use of realloc here.
                                  
                                  number = c - '0';
                                  A = (int *)realloc(A, sizeof(int));
                                  if(A)
                                       A[j++] = number;
                                  else
                                      break;
                    }
              }
              if(i == strlen(buffer) && j)
              {
                   *Asize = j;
                   *Sign = sign;
                   free(buffer);
                   return A;
              }
              else
              {
                  *Asize = 0;
                  free(buffer);
                  free(A);
                  return NULL;
              }
      }
      else
      return NULL;
}
                  
void DumpArray(int *A, int Asize)
{
     if(A)
     {
          int i;
          for(i = 0; i < Asize && printf(i != Asize -1 ? "%d " : "%d\n" , A[i]); i++);
     }
}
int GetNumberFromArray(int *A, int Asize, int Sign)
{
    if(A)
    {
         //Return Value.
         
         int n = 0;
         
         //Index.
         
         int i = 0;
         int j = 0;
         
         //BASE
         
         int BASE  = 1;
         
         //Start from the end of the array, advance base * 10 and go on.
         
         for(i = Asize-1; i >=0; i--)
         {
               n += A[i] * BASE;
               
               BASE *= 10;
         }
         if(i < 0)
              return n * Sign;
         else
             return -1;
    }
    else
        return -1;
}   
int main(int argc, char *argv[])
{
    int Asize = 0;
    int Sign = 0;
    int n = 0;
    int *A = NULL;
    printf("Enter the number:");
    A = GetInt(1024, &Asize, &Sign);
    DumpArray(A, Asize);
    printf("\n\n");
    n = GetNumberFromArray(A, Asize, Sign);
  
    printf(n != -1 ? "Number is: %d\n" : "Error in GetNumberFromArray {Check it}\n", n);
  
    system("PAUSE");    
    return 0;
}

[/code] 


---

Bokarinho don't do that, and use pastebin for goodness sake!

* I don't like scrolling ;)