Hi,
My OS is:
cronos:jdiaz:tm p>uname -a
HP-UX cronos B.11.11 U 9000/800 820960681 unlimited-user license
I compile in 64-bits mode the program below:
cronos:jdiaz:tm p>cat kk.C
#include <iostream.h>
#include <limits>
int main()
{
long l_min = numeric_limits< long>::min();
long l_max = numeric_limits< long>::max();
double d_min = numeric_limits< double>::min();
double d_max = numeric_limits< double>::max();
cout << sizeof(long) << " " << sizeof(double) << endl;
cout << l_min << " " << l_max << " " << d_min << " " << d_max <<
endl;
return 0;
}
cronos:jdiaz:tm p>a.out
8 8
-922337203685477 5808 922337203685477 5807 2.22507e-308 1.79769e+308
The double and long types have the same size, but the double limits
are bigger. Can anyone explein this to me ?
Thanks,
Jose Luis. 12 2980
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
jose luis fernandez diaz wrote: Hi,
My OS is:
cronos:jdiaz:tm p>uname -a HP-UX cronos B.11.11 U 9000/800 820960681 unlimited-user license
I compile in 64-bits mode the program below:
cronos:jdiaz:tm p>cat kk.C #include <iostream.h> #include <limits>
int main() { long l_min = numeric_limits< long>::min(); long l_max = numeric_limits< long>::max();
[snip]
Well, since you are using a different language from C, we in the comp.lang.c
newsgroup cannot assist you. Your question does not relate to C, and should be
(presumably, from the crossposting, was) asked in a forum related to the
language in which you wrote your example. This appears to be C++, so that forum
would be comp.lang.c++.
- --
Lew Pitcher
IT Consultant, Enterprise Application Architecture,
Enterprise Technology Solutions, TD Bank Financial Group
(Opinions expressed are my own, not my employers')
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (MingW32)
iD8DBQFAljf6agV FX4UWr64RAnujAJ wJ4mOsZZ9THxxul 4vwzrvTo/acYwCcDLiJ
+EqfYBtEqbJjlf/u1b7p2DQ=
=7HZL
-----END PGP SIGNATURE-----
jose luis fernandez diaz wrote: Hi,
My OS is:
cronos:jdiaz:tm p>uname -a HP-UX cronos B.11.11 U 9000/800 820960681 unlimited-user license
I compile in 64-bits mode the program below:
cronos:jdiaz:tm p>cat kk.C #include <iostream.h> #include <limits>
int main() { long l_min = numeric_limits< long>::min(); long l_max = numeric_limits< long>::max(); double d_min = numeric_limits< double>::min(); double d_max = numeric_limits< double>::max(); cout << sizeof(long) << " " << sizeof(double) << endl; cout << l_min << " " << l_max << " " << d_min << " " << d_max << endl;
return 0; } cronos:jdiaz:tm p>a.out 8 8 -922337203685477 5808 922337203685477 5807 2.22507e-308 1.79769e+308
The double and long types have the same size, but the double limits are bigger. Can anyone explein this to me ?
Well.
1.79769E308
does not mean that the number is accurate to the last digit. It means
179769000000000 0000000....0000 00.....000000
and the next smallest number is probably something like
179768000000000 0000000....0000 00.....000000
so there are large gaps between numbers. Those gaps get smaller when
the numbers get smaller.
--
Karl Heinz Buchegger kb******@gascad .at
jose luis fernandez diaz wrote: Hi,
My OS is:
cronos:jdiaz:tm p>uname -a HP-UX cronos B.11.11 U 9000/800 820960681 unlimited-user license
I compile in 64-bits mode the program below:
cronos:jdiaz:tm p>cat kk.C #include <iostream.h>
#include <iostream> // No ".h" extension.
#include <limits>
int main() {
using namespace std;
long l_min = numeric_limits< long>::min(); long l_max = numeric_limits< long>::max(); double d_min = numeric_limits< double>::min(); double d_max = numeric_limits< double>::max(); cout << sizeof(long) << " " << sizeof(double) << endl; cout << l_min << " " << l_max << " " << d_min << " " << d_max << endl;
return 0; } cronos:jdiaz:tm p>a.out 8 8 -922337203685477 5808 922337203685477 5807 2.22507e-308 1.79769e+308 The double and long types have the same size, but the double limits are bigger. Can anyone explein this to me ?
Typically, some of the bits representing a double are interpreted as an
exponent, and the rest as a multiplier. Floating-point math results in
approximate results, whereas any operation closed over the field of
integers will give an exact result when applied to long int's (if we
discount {over,under}flo w). http://en.wikipedia.org/wiki/IEEE_fl...point_standard
<posted & mailed>
The code below isn't C language code, but the question still applies.
A double can represent larger numbers because it lacks the resolution of the
long type. For a long integer, you have one number with absolute precision
for each integer within the range. For a double, you have exactly the same
number of values as the long, but on average, the difference between each
individual value and the next is much greater. Instead of counting by 1's,
you are counting by tens of thousands.
It may be easier to understand if you think about it this way, a integer
simply stores a number. A double uses the same number of bits to store two
numbers: one an integer, and one to tell it where to stick the decimal
point. The range of integers (where there is precision) is much smaller
because only a portion of the double is used to store the integral part
(mantissa) while another portion of the bits is used to store the position
of the decimal point (exponent). That's a simplification, but you get the
idea.
Integers are perfectly precise with a narrow range, and doubles are, on
average, very imprecise but cover a much wider range. Both doubles and
integers (in this case, since they are the same number of bits on your
system) have the same number of values.
jose luis fernandez diaz wrote: Hi,
My OS is:
cronos:jdiaz:tm p>uname -a HP-UX cronos B.11.11 U 9000/800 820960681 unlimited-user license
I compile in 64-bits mode the program below:
cronos:jdiaz:tm p>cat kk.C #include <iostream.h> #include <limits>
int main() { long l_min = numeric_limits< long>::min(); long l_max = numeric_limits< long>::max(); double d_min = numeric_limits< double>::min(); double d_max = numeric_limits< double>::max(); cout << sizeof(long) << " " << sizeof(double) << endl; cout << l_min << " " << l_max << " " << d_min << " " << d_max << endl;
return 0; } cronos:jdiaz:tm p>a.out 8 8 -922337203685477 5808 922337203685477 5807 2.22507e-308 1.79769e+308 The double and long types have the same size, but the double limits are bigger. Can anyone explein this to me ?
Thanks, Jose Luis.
--
remove .spam from address to reply by e-mail.
"Lew Pitcher" <Le*********@td .com> wrote in message
news:MH******** ************@ne ws20.bellglobal .com... -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1
jose luis fernandez diaz wrote: Hi,
My OS is:
cronos:jdiaz:tm p>uname -a HP-UX cronos B.11.11 U 9000/800 820960681 unlimited-user license
I compile in 64-bits mode the program below:
cronos:jdiaz:tm p>cat kk.C #include <iostream.h> #include <limits>
int main() { long l_min = numeric_limits< long>::min(); long l_max = numeric_limits< long>::max(); [snip]
Well, since you are using a different language from C, we in the
comp.lang.c newsgroup cannot assist you. Your question does not relate to C, and
should be (presumably, from the crossposting, was) asked in a forum related to the language in which you wrote your example. This appears to be C++, so that
forum would be comp.lang.c++.
- -- Lew Pitcher IT Consultant, Enterprise Application Architecture, Enterprise Technology Solutions, TD Bank Financial Group
Not very helpful.
Regards
jose luis fernandez diaz wrote: I compile in 64-bits mode the program below:
cronos:jdiaz:tm p>cat kk.C #include <iostream.h> #include <limits>
int main() { long l_min = numeric_limits< long>::min(); long l_max = numeric_limits< long>::max(); double d_min = numeric_limits< double>::min(); double d_max = numeric_limits< double>::max(); cout << sizeof(long) << " " << sizeof(double) << endl; cout << l_min << " " << l_max << " " << d_min << " " << d_max << endl;
return 0; }
C++ is off topic on c.l.c. Please refrain from any such
cross-postings.
--
Some useful references:
<http://www.ungerhu.com/jxh/clc.welcome.txt >
<http://www.eskimo.com/~scs/C-faq/top.html>
<http://benpfaff.org/writings/clc/off-topic.html>
<http://anubis.dkuug.dk/jtc1/sc22/wg14/www/docs/n869/> (C99)
CBFalconer wrote: jose luis fernandez diaz wrote: I compile in 64-bits mode the program below:
cronos:jdiaz:tm p>cat kk.C #include <iostream.h> #include <limits>
int main() { long l_min = numeric_limits< long>::min(); long l_max = numeric_limits< long>::max(); double d_min = numeric_limits< double>::min(); double d_max = numeric_limits< double>::max(); cout << sizeof(long) << " " << sizeof(double) << endl; cout << l_min << " " << l_max << " " << d_min << " " << d_max << endl;
return 0; }
C++ is off topic on c.l.c. Please refrain from any such cross-postings.
-- Some useful references: <http://www.ungerhu.com/jxh/clc.welcome.txt > <http://www.eskimo.com/~scs/C-faq/top.html> <http://benpfaff.org/writings/clc/off-topic.html> <http://anubis.dkuug.dk/jtc1/sc22/wg14/www/docs/n869/> (C99)
Well, the question doesn't have anything to do with unix, either, but
you might see whether your sompiler has sizeof() in it. That could tell
you the size of long and of double, and might provide a clue.
The best place to persue this sort of thing is a textbook. There are
very few newsgroups that devote themselves to trying to run down
questions relating to problems that probably pertain to a specific
compiler/platform issue such as this one. Too bad, but that's the
way it is.
Speaking only for myself,
Joe Durusau
Hi,
I have made the program below to try to understand how a floating
point number is made by my computer (HP-UX cronos B.11.11 U 9000/800):
#include <stdio.h>
#include <math.h>
union
{
float f;
unsigned char uc[sizeof(float)];
} f_union;
int main()
{
f_union.f=1.0F;
unsigned char u1=1, u2;
u1 <<= sizeof(unsigned char)*8-1;
for (int i=0; i < sizeof(float); ++i)
{
u2=f_union.uc[i];
for(int j=0; j<sizeof(unsign ed char)*8; j++)
{
printf("%d", ((u1 & u2)!=0));
u2 <<= 1;
}
}
printf("\n");
int exp;
double man = frexp(f_union.f , &exp);
printf("%lf %d\n%f\n", man, exp,f_union.f);
return 0;
}
but I didn't. Perhaps the program is wrong. Here are some outputs:
001111111000000 000000000000000 00
0.500000 1
1.000000
010000000000000 000000000000000 00
0.500000 2
2.000000
010000000100000 000000000000000 00
0.750000 2
3.000000
010000001000000 000000000000000 00
0.500000 3
4.000000
010000001010000 000000000000000 00
0.625000 3
5.000000
010000010000000 000000000000000 00
0.500000 4
8.000000
Any hint are welcome.
Thanks,
Jose Luis. jo************* *********@yahoo .es (jose luis fernandez diaz) wrote in message news:<c2******* *************** ****@posting.go ogle.com>... Hi,
My OS is:
cronos:jdiaz:tm p>uname -a HP-UX cronos B.11.11 U 9000/800 820960681 unlimited-user license
I compile in 64-bits mode the program below:
cronos:jdiaz:tm p>cat kk.C #include <iostream.h> #include <limits>
int main() { long l_min = numeric_limits< long>::min(); long l_max = numeric_limits< long>::max(); double d_min = numeric_limits< double>::min(); double d_max = numeric_limits< double>::max(); cout << sizeof(long) << " " << sizeof(double) << endl; cout << l_min << " " << l_max << " " << d_min << " " << d_max << endl;
return 0; } cronos:jdiaz:tm p>a.out 8 8 -922337203685477 5808 922337203685477 5807 2.22507e-308 1.79769e+308 The double and long types have the same size, but the double limits are bigger. Can anyone explein this to me ?
Thanks, Jose Luis. This thread has been closed and replies have been disabled. Please start a new discussion. Similar topics |
by: f |
last post by:
I have this
double sum, a, b, c;
sum = a + b + c;
printf("%.20f = %.20f, %.20f, %.20f", sum, a, b, c);
I found that the debug version and release version of the same code
give me different result. I am using VC++ 6.0.
In debug version, the print out is:
|
by: jose luis fernandez diaz |
last post by:
Hi,
My OS is:
cronos:jdiaz:tmp>uname -a
HP-UX cronos B.11.11 U 9000/800 820960681 unlimited-user license
I compile in 64-bits mode the program below:
|
by: Michael Mair |
last post by:
Hi there,
actually, I have posted the same question in g.g.help.
As there were no answers, I am still not sure whether this
is a bug or only something open to the compiler that is
seemingly inconsistent or whether my understanding of C
is not complete enough.
I would appreciate answers or pointers to answers very much.
|
by: Erick-> |
last post by:
hi all...
I've readed some lines about the difference between float and double
data types... but, in the real world, which is the best? when should we
use float or double??
thanks
Erick
|
by: aisling.cronin |
last post by:
Hi
I am using ctime to convert the following string 1144412677847 ....
Please could some one to double check if they get the same result as
me (The Time is Sun Nov 02 09:11:51 2031). It seems incorrect and
would like a second opion.
#include <time.h>
#include <stdio.h>
| |
by: mrajanikrishna |
last post by:
Hi Friends,
I am accepting a number from the user entered in a textbox.
I want to assign to a variable in my code and assignt this to that
variable.
double num1 = (double)txtNum1.text;
this produced an error
|
by: Steven Woody |
last post by:
long i = nnn;
long j;
double d;
d = i;
j = ( long )d;
in this case, i == j ?
thanks.
|
by: md |
last post by:
Hi
Does any body know, how to round a double value with a specific number
of digits after the decimal points?
A function like this:
RoundMyDouble (double &value, short numberOfPrecisions)
It then updates the value with numberOfPrecisions after the decimal
|
by: Charles Coldwell |
last post by:
James Kanze <james.kanze@gmail.comwrites:
True, with some additional considerations. The commonly used IEEE 754
floating point formats are
single precision: 32 bits including 1 sign bit, 23 significand bits
(with an implicit leading 1, for 24 total), and 8 exponent bits
double precision: 64 bits including 1 sign bit, 52 significand bits
|
by: marktang |
last post by:
ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However, people are often confused as to whether an ONU can Work As a Router. In this blog post, we’ll explore What is ONU, What Is Router, ONU & Router’s main usage, and What is the difference between ONU and Router. Let’s take a closer look !
Part I. Meaning of...
|
by: Oralloy |
last post by:
Hello folks,
I am unable to find appropriate documentation on the type promotion of bit-fields when using the generalised comparison operator "<=>".
The problem is that using the GNU compilers, it seems that the internal comparison operator "<=>" tries to promote arguments from unsigned to signed.
This is as boiled down as I can make it.
Here is my compilation command:
g++-12 -std=c++20 -Wnarrowing bit_field.cpp
Here is the code in...
| |
by: jinu1996 |
last post by:
In today's digital age, having a compelling online presence is paramount for businesses aiming to thrive in a competitive landscape. At the heart of this digital strategy lies an intricately woven tapestry of website design and digital marketing. It's not merely about having a website; it's about crafting an immersive digital experience that captivates audiences and drives business growth.
The Art of Business Website Design
Your website is...
|
by: Hystou |
last post by:
Overview:
Windows 11 and 10 have less user interface control over operating system update behaviour than previous versions of Windows. In Windows 11 and 10, there is no way to turn off the Windows Update option using the Control Panel or Settings app; it automatically checks for updates and installs any it finds, whether you like it or not. For most users, this new feature is actually very convenient. If you want to control the update process,...
|
by: tracyyun |
last post by:
Dear forum friends,
With the development of smart home technology, a variety of wireless communication protocols have appeared on the market, such as Zigbee, Z-Wave, Wi-Fi, Bluetooth, etc. Each protocol has its own unique characteristics and advantages, but as a user who is planning to build a smart home system, I am a bit confused by the choice of these technologies. I'm particularly interested in Zigbee because I've heard it does some...
|
by: isladogs |
last post by:
The next Access Europe User Group meeting will be on Wednesday 1 May 2024 starting at 18:00 UK time (6PM UTC+1) and finishing by 19:30 (7.30PM).
In this session, we are pleased to welcome a new presenter, Adolph Dupré who will be discussing some powerful techniques for using class modules.
He will explain when you may want to use classes instead of User Defined Types (UDT). For example, to manage the data in unbound forms.
Adolph will...
|
by: adsilva |
last post by:
A Windows Forms form does not have the event Unload, like VB6. What one acts like?
|
by: 6302768590 |
last post by:
Hai team
i want code for transfer the data from one system to another through IP address by using C# our system has to for every 5mins then we have to update the data what the data is updated we have to send another system
| |
by: muto222 |
last post by:
How can i add a mobile payment intergratation into php mysql website.
| |