Strange !!!

Do you think the output of this code alright???

Code:

---

#include<iostream.h>
#include<math.h>


inline double round(double X, int k)
{
        return ( floor( X*pow10(k) + 0.5) / pow10(k) );
}



int main()
{
        double x;

  while(cin >> x)
          cout << " Round of " << x << " is :  " << round(x,2) << endl;

  return 0;
}

---

Quote:

---

9.005
Round of 9.005 is : 9.01

---

Yes, it is ok? Didn´t understand what happens?

Hmm...if it is OK!
Then can you tell me...why this same function fails in this section???

Which one is correct then? I want the first one (above) but why this is behaving strangley in this ???

Code:

---

#include<iostream.h>
#include<math.h>


inline double round(double X, int k)
{
        return ( floor( X*pow10(k) + 0.5) / pow10(k) );
}



int main()
{
  int n = 0;

  while(cin >> n)
  {
          if(n == 0)
              return 0;

      double trip[1000] = {0};
      double sum = 0,ans = 0;

            for(int i=0;i<n;++i)
      {
              cin >> trip[i];
        sum += trip[i];
      }

      double avg = sum/double(n);
      cout << " AVG: " << avg << endl;
      avg = round(avg,2);

      cout << " AVG: " << avg << endl;

      for(int i=0;i<n;++i)
              if(trip[i] > avg)
                ans += trip[i]-avg;

                cout.setf(ios::fixed);
      cout.precision(2);

      cout << '$' << ans << endl;
  }

        return 0;
}

---

Here is input?

Quote:

---

4
15.01
15.00
3.00
3.01

---

And the output is:

Quote:

---

4
15.01
15.00
3.00
3.01
AVG: 9.005
AVG: 9
$12.01

---

If I am not mistaken, floor returns an int. This function pow10 is not supported by my compiler, but if just gives 10 power, then you have two integers. So, you have integer division.

Hmm...you can change pow10(2) by pow(10.00,2)

And about that floor:

You may see this :rolleyes:

Then what might be the answer :confused:

Sorry! My answer was wrong!
I read this defition:
The function floor() returns the largest integer not greater than arg. For example,

y = 6.04;
x = floor( y );

would result in x being set to 6.0.

But in place of that "not greater" could be "nor greater nor equal"...

Sorry, I did not see your post.

Hmm...I also know about that floor and ceil but when I went in programming field I found this! (the link above!) But if you now compile, can you explain about its strange behaviour ???

In your example the floor function was receiving the number 901. Well, the next integer not greater and not equal to 901 is 900.
I am trying to think a solution. I tryied to cast the number to an integer, but didn´t worked and this is reaaaally a strange behavior, look:

Code:

---

double round(double X, int k)
{
  return ( static_cast<int>(X*pow(10.0,k) + 0.5) / pow(10.0,k) );
}

---

The cast is acting like the floor function, when it should only "remove" the float point numbers (I do not konw how to say in english the numbers after the ".").

Hmm...but the previous (my first post) code is behaving normally...isn't it :rolleyes:

Ok, I give up! I don´t know... this is too bizarre!

http://docs-pdf.sun.com/800-7895/800-7895.pdf
A rounded float is still an approximation, so 12.34 may still be 12.399999 no matter what you do.

And what could be the solution? I mean... static_cast<int> didn´t work too...

May be:

Code:

---

cout.setf(ios::fixed);
cout.precision(2);

---

This is causing the ERROR :(

Are you sure? The error happens before these statements :-(

It is not a good solution, but you can add a small fraction to the number that will be rounded. Then, the floor function will return that number and ignore the small fraction.

Code:

---

inline double round(double X, int k)
{
  double tempDouble = X*pow(10.0,k) + 0.5 + 0.000000001;
  return ( floor(tempDouble) / pow(10.0,k) );
}

---

Hmm...but why? this strange things happenning???
I am really looking for the answer.............
I've manged to get another solution of the problem...so now only I need to just WHY ???

Salem already gave you guys the answer... it's the innaccuracy of a float... decimal math is very innacurate (in my experience to the tenth, or +/- 0.01)... if you keep running it, eventually you'll probably end up with the right answer... either way, it'll be hard to ensure the right answer every single time.

I modded your code a bit and came out with this output:

Code:

---

4
15.01
15
3
3.01
 AVG: 9.005
 AVG: 9.00488
$12.00

---

I used the same input as you... here's the code I used:

Code:

---

#include<iostream>
#include<cmath>

using namespace std;

inline double round(double X, int intk)
{
        double k=static_cast<double>(intk);
        return ( floor( X*pow(k,10.0) + 0.5) / pow(k,10) );
}



int main()
{
  int n = 0;

  while(cin >> n)
  {
          if(n == 0)
              return 0;

      double trip[1000] = {0};
      double sum = 0,ans = 0;

            for(int i=0;i<n;++i)
      {
              cin >> trip[i];
        sum += trip[i];
      }

      double avg = sum/double(n);
      cout << " AVG: " << avg << endl;
      avg = round(avg,2);

      cout << " AVG: " << avg << endl;

      for(int i=0;i<n;++i)
              if(trip[i] > avg)
                ans += trip[i]-avg;

                cout.setf(ios::fixed);
      cout.precision(2);

      cout << '$' << ans << endl;
  }

        return 0;
}

---

------------------------------------------------------------------------------------
EDIT 2:
------------------------------------------------------------------------------------
I rewrote your code to actually do some real rounding... the only thing is that it doesn't clear out the number it acutually rounded... my brain is fried and I've been working at it for 20 minutes, so I'm giving up on that part... here's what I have:

Code:

---

inline double round(double X, int k)
{
        double decimal=X-static_cast<int>(X);        //take out whole numbers
        double half=(5.0/(pow(10.0,k)));        //half of the requested decimal place
        double decimaltemp;
       
        //cout<<"K: "<<k<<endl<<"DECIMAL: "<<decimal<<endl<<"HALF: "<<half<<endl;
       
        if(decimal>=half)        //if it's bigger than that
          {
                  //cout<<"ROUND UP"<<endl;
                  decimal+=1.0/(pow(10.0,k-1));        //add one to next biggest decimal
                  //cout<<"DECIMAL: "<<decimal<<endl;
                 
                  /*

                              NOTE: do something here to get rid of the decimal that was just rounded.
                              you have to find out it's value and delete it from itself, leaving a zero in it's place.               
             
                decimaltemp=static_cast<int>(decimal*(pow(10.0,k)));
                cout<<"DECMIALTEMP: "<<decimaltemp<<endl;
                decimaltemp-=decimaltemp/pow(10.0,k);
                cout<<"DECIMALTEMP: "<<decimaltemp<<endl;
                decimal-=decimaltemp;
                cout<<"DECIMAL: "<<decimal<<endl;
                */
               
          return (static_cast<int>(X)+decimal);        //return the next decimal + 1
          }
        else        //if it's smaller
          {
                  //cout<<"ROUND DOWN"<<endl;
                  //decimal=zeroout(decimal,k);        //kill rounded to zero
          return (static_cast<int>(X)+decimal);//return the next decimal
        }
}

---

all the couts that I commented out are for debugging... you can just ignore those. this code gives me this output:

Code:

---

4
15
15.1
3
3.1
 AVG: 9.05
 AVG: 9.15
$11.80
4
15
15.1
3
3
 AVG: 9.025
 AVG: 9.025
$12.05

---

I'll leave it up to you to find out how to get rid of the .05 in there.

Yeah, what major_small just said :D

Seriously, you need a good understanding of what all the constants in float.h mean, and back that up with reading at least some of the document I referenced in my previous reply.

Any serious attempt at using floats should not be attempted without it IMO

For those with an interest in such things, this is an example of what can happen if you don't appreciate how computers store numbers:

http://www.ima.umn.edu/~arnold/disasters/patriot.html