C++ anamaly

[puzzlecracker]

If you run this program, it gives very unexpected results. Can anyone
explain the nature of this anamaly? (also what is the function call
[and library to include linux/windows] to execute 'pause');

#include<iostre am>
using namespace std;
//void pause(){ unsigned long i=0; while(i++<10000 000); }

int main(){
int counter=0;
for(float i=1;i<100;i+=0. 1) // pay attention
{ // pause();
std::cout<<i<<" \n";
}

cout<<endl;
return 0;
}

[Ioannis Vranos]

puzzlecracker wrote:

If you run this program, it gives very unexpected results. Can anyone
explain the nature of this anamaly? (also what is the function call
[and library to include linux/windows] to execute 'pause');

#include<iostre am>
using namespace std;
//void pause(){ unsigned long i=0; while(i++<10000 000); }

int main(){
int counter=0;
for(float i=1;i<100;i+=0. 1) // pay attention
{ // pause();
std::cout<<i<<" \n";
}

cout<<endl;
return 0;
}

I guess the float gets printed as a double (there is no operator<<
overload for float). Use double instead.


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[puzzlecracker]

Ioannis Vranos wrote:

puzzlecracker wrote:

If you run this program, it gives very unexpected results. Can anyone explain the nature of this anamaly? (also what is the function call
[and library to include linux/windows] to execute 'pause');

#include<iostre am>
using namespace std;
//void pause(){ unsigned long i=0; while(i++<10000 000); }

int main(){
int counter=0;
for(float i=1;i<100;i+=0. 1) // pay attention
{ // pause();
std::cout<<i<<" \n";
}

cout<<endl;
return 0;
}

I guess the float gets printed as a double (there is no operator<<
overload for float). Use double instead.


--
Ioannis Vranos

http://www23.brinkster.com/noicys

SAME THING - I think it has to do with the way floating point numbers
are represented.

[James Aguilar]

"puzzlecrac ker" <ir*********@gm ail.com> wrote in message
news:11******** *************@z 14g2000cwz.goog legroups.com...

If you run this program, it gives very unexpected results. Can anyone
explain the nature of this anamaly? (also what is the function call
[and library to include linux/windows] to execute 'pause');

It works just fine for me on gcc 3.3.3.

Can you describe the anomaly that happens on your system?

James

[puzzlecracker]

what is the last number being printed in your case?

James Aguilar wrote:

"puzzlecrac ker" <ir*********@gm ail.com> wrote in message
news:11******** *************@z 14g2000cwz.goog legroups.com...

If you run this program, it gives very unexpected results. Can anyone explain the nature of this anamaly? (also what is the function call
[and library to include linux/windows] to execute 'pause');

It works just fine for me on gcc 3.3.3.

Can you describe the anomaly that happens on your system?

James

[Gianni Mariani]

puzzlecracker wrote:

If you run this program, it gives very unexpected results.
What do you think is unexpected about it ?

Can anyone explain the nature of this anamaly?
Round off error, more than likely.

0.1 is a number that can't be represented exactly.

In binary to 23 digits it is represented as the following approximation:

0.0001100110011 0011001100

Which is 1 10 millionth (approx) in error or more accurately.
1/10485760

When you multiply that error by 1000 you get an error of:
25/262144

i.e. 1 in 100,000 (approx).
(also what is the function call [and library to include linux/windows] to execute 'pause');

What is pause ? Why do you need it ?

[puzzlecracker]

Gianni Mariani wrote:

puzzlecracker wrote:

If you run this program, it gives very unexpected results.
What do you think is unexpected about it ?

Can anyone

explain the nature of this anamaly?

Round off error, more than likely.

0.1 is a number that can't be represented exactly.

In binary to 23 digits it is represented as the following

approximation:
0.0001100110011 0011001100

Which is 1 10 millionth (approx) in error or more accurately.
1/10485760

When you multiply that error by 1000 you get an error of:
25/262144

i.e. 1 in 100,000 (approx).
(also what is the function call

[and library to include linux/windows] to execute 'pause');

What is pause ? Why do you need it ?

how to correct this problem?

[Gianni Mariani]

puzzlecracker wrote:

Gianni Mariani wrote: ....

Round off error, more than likely.

....
how to correct this problem?
Change the order of operations to minimize the round-off error
accumulation and/or use higher precision (double) numbers.

You can use exact numbers as well - like a quotient type.

This is one example I whipped up to come up with that bit pattern...
template <typename w_T>
w_T gcd( w_T i_v1, w_T i_v2 )
{
w_T l_vl;
w_T l_vs;
if ( i_v1 > i_v2 )
{
l_vl = i_v1;
l_vs = i_v2;
}
else
{
l_vl = i_v2;
l_vs = i_v1;
}

w_T l_t;
w_T l_t2;

do {

l_t2 = l_vl % l_vs;

l_t = l_vl;
l_vl = l_vs;
l_vs = l_t2;
} while( l_t2 );

return l_vl;
}
struct quotient
{
typedef unsigned long long t_type;

bool m_sign;
t_type m_numerator;
t_type m_denominator;

quotient(
bool i_sign,
t_type i_numerator,
t_type i_denominator
)
: m_sign( i_sign ),
m_numerator( i_numerator ),
m_denominator( i_denominator )
{
Simplify();
}

void Simplify()
{
t_type l_gcd = gcd( m_numerator, m_denominator );

if ( l_gcd != 1 )
{
m_numerator /= l_gcd;
m_denominator /= l_gcd;
}
}

quotient operator-() const
{
return quotient( !m_sign, m_numerator, m_denominator );
}

};

quotient operator+( const quotient & i_lhs, const quotient & i_rhs )
{
quotient::t_typ e l_demgcd = gcd( i_lhs.m_denomin ator,
i_rhs.m_denomin ator );

quotient::t_typ e l_mul_rhs = i_lhs.m_denomin ator / l_demgcd;
quotient::t_typ e l_mul_lhs = i_rhs.m_denomin ator / l_demgcd;
quotient::t_typ e l_den = l_mul_lhs * i_lhs.m_denomin ator;

if ( i_lhs.m_sign == i_rhs.m_sign )
{
return quotient(
i_lhs.m_sign,
i_lhs.m_numerat or * l_mul_lhs + i_rhs.m_numerat or * l_mul_rhs,
l_den
);
}
else
{
quotient::t_typ e l_num_lhs = i_lhs.m_numerat or * l_mul_lhs;
quotient::t_typ e l_num_rhs = i_rhs.m_numerat or * l_mul_rhs;

if ( l_num_lhs > l_num_rhs )
{
return quotient(
i_lhs.m_sign,
l_num_lhs - l_num_rhs,
l_den
);
}
else
{
return quotient(
i_rhs.m_sign,
l_num_rhs - l_num_lhs,
l_den
);
}
}

}

quotient operator-( const quotient & i_lhs, const quotient & i_rhs )
{
return i_lhs + - i_rhs;
}

quotient operator*( const quotient & i_lhs, const quotient & i_rhs )
{
return quotient(
i_rhs.m_sign != i_rhs.m_sign,
i_lhs.m_numerat or * i_rhs.m_numerat or,
i_lhs.m_denomin ator * i_rhs.m_denomin ator
);
}

quotient operator/( const quotient & i_lhs, const quotient & i_rhs )
{
return quotient(
i_rhs.m_sign != i_rhs.m_sign,
i_lhs.m_numerat or * i_rhs.m_denomin ator,
i_lhs.m_denomin ator * i_rhs.m_numerat or
);
}

template<
typename i_char_type,
class i_traits

basic_ostream<i _char_type, i_traits>& operator << (
basic_ostream<i _char_type, i_traits> & i_ostream,
const quotient & i_value
) {

if ( i_value.m_sign )
{
i_ostream << '-';
}

i_ostream << i_value.m_numer ator;

if ( i_value.m_denom inator != 1 )
{
i_ostream << '/' << i_value.m_denom inator;
}

return i_ostream;
}

//////////////////// example of you to use quotient this //////////////

int main()
{
quotient m_value( false, 1, 10 ); // 1/10th or 0.1

quotient m_bit( false, 1, 2 ); // 1/2 or 0,5 - the first bit.

for ( int i = 23; i --; )
{
quotient m_diff = m_value - m_bit;

if ( m_diff.m_sign )
{
std::cout << '0';
}
else
{
std::cout << '1';
m_value = m_diff;
}

m_bit.m_denomin ator <<= 1;
}

std::cout << " " << m_value << " " << quotient( false, 1000, 1 ) *
m_value;
}

[David Harmon]

On 29 Jan 2005 22:58:24 -0800 in comp.lang.c++, "puzzlecrac ker" <ir*********@gm ail.com> wrote,

how to correct this problem?

Don't use floating point types for loop counters.
Use long.

[James Aguilar]

"puzzlecrac ker" <ir*********@gm ail.com> wrote in message
news:11******** **************@ c13g2000cwb.goo glegroups.com.. .

what is the last number being printed in your case?

99.999 -- the correct number, or, at least, the behavior I would expect.

As I'm sure you know, there is calculation error in all floating point
numbers -- both float, double, and long double. The extent of the error is
dependent upon the hardware, but I'm sure that your teachers have told you
the danger of comparing fps as equal. How is it different if you do 10000
ops on one?