Printable View
Write a program to determine the ranges of char , short , int , and long variables, both signed and unsigned , by printing appropriate values from standard headers and by direct computation. Harder if you compute them: determine the ranges of the various floating-point types.
What is direct computation? Does it means using INT_MAX?
How can i determine ranges of floating types on my machine? Using C?
1) Get the number of bits using sizeof.
2) Consider the sign.
3) Set the bits to represent the highest possible value: for unsigned, that's all of them, for signed, all but the MSB.
4) The lowest value of a signed type is just the MSB set, ie, the inverse of the highest value.
What they want you to do is to use the standard header files to print out the ranges of these data types. Yes, INT_MAX is one of them.Quote:
Originally Posted by Tool
You'll want to include headers like limits.h
Then the second part of your assignment is to find these values yourself, on your system, using direct computation.
pseudo code for find char limit would be something like this:
For larger data types, you can speed it up a great deal by having the variable increment by say, 10,000 each time, then use a while loop to back it down, instead of just subtracting one. Big time saver.Code:
#include <stdio.h>
int main() {
char limit = 0;
while(++limit > 0);
now limit has passed it's limit, and gone negative,
so back it up by 1
just for the heck of it, print the negative value of limit, before you
back it up by 1
--limit;
limit should now be at it's maximum value.
You can use similar logic to find the max value of any data type. If the type is
unsigned, the specifics change a bit, but not much.
return 0;
}
The sizeof method mentioned above is good, and much faster. Since there would still be some multiplication involved, I think that would also be a "direct computation".
It's great to know how your data type is laid out in bits and bytes, and learning about MSB, and such.
Overflowing signed integers is not defined by the standard, that is it is undefined. And using bitwise operations on signed integers is either undefined or implementation defined. As well as signed integers could be excess-k, two's complement, signed magnitude... anything!
The above of course means nothing if your implementation defines such behaviour. limits.h does exist for a reason.
OK, but how would the OP "directly compute" the maximum value of these data types?Quote:
Originally Posted by zacs7
Your point is well taken, but what does that leave us with? I'm not talking about getting the values from limits.h. That is the FIRST part of the assignment. I'm talking about the second part of the assignment where the instructor asks for a program requiring "direct computation".
MK27's bit method, and my overflow method, are the only two ways I know of to directly compute these maximum (or minimum), values.
What do you recommend then?
A bad assignment question? :DQuote:
Originally Posted by Adak
The instructor probably should have stated that the number representations can be assumed as is convenient.
-infinity to +infinity -> done! :pQuote:
Originally Posted by Tool
Or if you include NANs: "To infinity and beyond!"
Presumably the instructor would mean to exclude infinities...
How is SizeOf implemented? That's obviously what he wants to know, unless that question can't be answered?
edit; never mind, looks like it's something the compiler does. OP; you should find the place in the standard where it talks about sizeof as support for why you have to use sizeof and vola, you can use sizeof and you're done.
Take the number of bytes which is the result of some sizeof(type), and fill that unsigned type with that many number of '1' bits and print the number, same for unsigned and just don't set the most significant bit.
Tip: http://www.cprogramming.com/faq/cgi-...wer=1074727388
What do you guys think about this? http://www.dreamincode.net/code/snippet1134.htm
Two other forum posts suggest it's undefined behavior, but apparently it works reliably, seems like the list of exceptions where this would fail is few or uncommon?
Which if you took the time to read a thread instead of just the first post, you wouldn't have to waste your time giving the EXACT same answer as post #2 -- and, further, someone explains why that answer isn't so satisfactory anyway in post #4.Quote:
Originally Posted by since
A lot of people do this ( iMalc comes immediately to mind...;) ), I always find it very strange...I don't have time to learn about the wheel, I'm too busy re-inventing it? :p
Thx Adak and the rest, that explained it. Overflowing is undefined but it works normal with my compiler (the values seem to be ok).
What about for unsigned chars:
is it enough to just initialize a unsigned char test = 0; and then decrement test, and we get the MAX_SIZE of unsigned char? Is that considered a 'direct computation'? The values seem to be good for me...
And what about floating types.
Can they even have a max value? If so why isnt it defined in limits.h? What should i do with this part of the assignment?
What do you mean Tool?
hmmm....Code:unsigned int a = 0;
a--;
printf("%u\n",a);
Cheat.Code:union foo
{
unsigned type bar;
signed type baz;
} yay;
yay.bar = 0;
yay.bar--;
output( yay.baz );
Quzah.
You are allowed to convert any pointer to character type and examine the object byte by byte. You are allowed to subtract an array from one past the end of the array (single objects count as an array of one object for this purpose). Are you allowed to combine them? I don't know. I can't imagine there are too many, if any, systems where this won't work, but it doesn't matter too much because you can just use sizeof instead.Quote:
What do you guys think about this? Sizeof operator implementation - C - Source Code | DreamInCode.net
If you've gotten the max and min values these 3 ways:
1) Gotten them from the standard library macro's (like INT_MAX), in limits.h).
2) Used the sizeof() method (where 2^n - 1 is max, +- the MSB number).
3) Incremented or decremented the variable to the max or min value.
Then you've done all you can.
Every variable has a maximum and minimum value, no matter what the type. It might take adjustments to the #2 and #3 methods listed above, but there definitely ARE max and min limits.
So if i want a min value of a char using sizeof(), this is how it should go?
int tmp = 0;
tmp = pow(2, (sizeof(char)*8)-1)*-1;
And for the char max value:
tmp = pow(2, (sizeof(char)*8)-1) - 1;
Is this the correct way?
Should be unsigned int .
Code:printf("%u", UINT_MAX);
Oh! Yeah, works fine now.
@ Adak
Ok, i printed the values of char, short, int, and long variables in all 3 ways: from the standard header, incrementing them (overflowing) and using sizeof() operator.
I also did print the max value of a float by using the header float.h which contains max float/double values.
But i dont know how to do the last part of this assignment which tells to compute floats. How can i compute floats, what do i need to do to get the max / min value?
For signed, I'd use the increment method and just keep comparing to 0.0f to find out when the value wraps around.
For unsigned, you can use fabsf(signed min) + signed max. Eg, with a char, that the absolute value of the signed minimum is 128, and the signed max is 127, so the unsigned max is 128+127=255.
I cant declare a unsigned float tho. I assume float/double types dont support it? Why? This is logical since the values represented from float.h say min value of a float is 0, so basicaly the float is itself an unsigned type?
Also:
the first line prints: -0.0000000Code:printf("Min long double value: %f\n", LDBL_MIN);
printf("Max long double value: %f\n", LDBL_MAX);
the second line prints: -1.#QNAN0
What on earth is that?
Oh yeah. Guess I've never tried.Quote:
Originally Posted by Tool
BTW floats and doubles are SIGNED, for sure.
Floats are different - they don't overrun and go negative (at least not on my system). They crash the program when they overrun their maximum value - BUT they have a little "elbow room" above the maximum value, that we can use.Quote:
Originally Posted by Tool
To my surprise, using addition, even addition of huge numbers, did not work for this. So, multiplication and division, to the rescue! :)
This is an example of finding the float maximum. Since it doesn't overflow back to negative values, you have to use the maximum float value from your header file, to make it work.
With the help of the "elbow room" above the maximum float value but not crashing the program, this works fine on my system.Code:/*find the largest float value on this system
*/
#include <stdio.h>
#include <values.h> //MAXFLOAT, MINFLOAT your header file will be different
int main(void) {
int i, n;
float fnum = 2.0;
n = 34;
for(i = 0; i < 10; i++)
printf("\n\n\n");
printf("maximum float value to reach: %e\n", MAXFLOAT);
do {
fnum *= --n;
if(n % 10 == 0)
printf("\nThe float is now: %e", fnum); //3.87e15
}while(n > 1);
printf("\nThe float is now: %e", fnum);
while(fnum < MAXFLOAT) {
fnum *= 1.000001;
}
printf("\nThe float is now: %e", fnum);
while(fnum > MAXFLOAT) {
fnum /= 1.000001;
}
printf("\nThe float is now: %e", fnum);
while(fnum < MAXFLOAT) {
fnum *= 1.0000001;
}
printf("\nThe float is now: %e", fnum);
printf("\n\n\t Maximum float value is %e", fnum);
printf("\n\n\t\t\t Press Enter When Ready ");
n = getchar();
return 0;
}
You may need (probably will need), to adjust n and other numbers, to make it run correctly AND in a reasonably short amount of time.
Could you please explain the above code a bit further?
This really seems puzzling.
Wouldnt this crash the program? A float passing its max limit...Code:while(fnum > MAXFLOAT) {
fnum /= 1.000001;
}
And my program seems to get stuck counting after the first loop.
What number should i then put instead of 1.00001 to be faster?
Code:while(fnum < MAXFLOAT) {
fnum *= 1.000001;
}
Take out a zero - maybe two, to speed it up! Each zero you remove will make it 10X faster. (larger)Quote:
Originally Posted by Tool
The first thing is to look at your MAXFLOAT number. In the first while loop, you put n to the highest number it can go, without erroring, but still bringing fnum up very high.
You want fnum is > MAXFLOAT, but not enough to cause an error.
Now you need to bring fnum DOWN, so you divide by something > 1.0, to make it smaller. Start with 1.001 (sort of a mid value in this case), and adjust as needed by adding or removing a zero, from the right side of the decimal place.
You want to "ramp" the magnitude of the multiplier's and divisor's, so the granularity goes from very coarse, (big), to fine (small).
1.01
1.001
1.0001
etc., as needed
Code:int i, n;
float fnum = 2.0;
n = 34;
do {
fnum *= --n;
if(n % 10 == 0)
printf("\nThe float is now: %e", fnum);
}while(n > 1);
printf("\n\nThe float is now: %e\n", fnum);
while(fnum < FLT_MAX) {
fnum *= 1.0000001;
}
printf("\nThe float is now: %e", fnum); // prints 1.#INF00e+000, why?
Edit: i tried printing the values while computing them. And when i put
while(fnum < FLT_MAX) {
fnum *= 1.001; (the only way for it to work fast enough, else id have to wait for ages)
}
I always end up with a #INF00e+000
Maybe its my compiler?
INF is compiler abbreviation for "Infinite".
so at that point, you have gone beyond the highest float number, but you've gone too far.
Here's something to do. Try and print FLT_MAX + 1, and see what it shows.
It shows the same number as for FLT_MAX.
Should i replace
then?Code:while(fnum < FLT_MAX) {
fnum *= 1.0000001;
}
with fnum < FLT_MAX - 1
Or maybe multiply with a lower number?
Sorry, you already did the one past FLT_MAX.
And you got the SAME number as FLT_MAX???
OK, that's your compiler's version of "elbow room", I would suppose.
Now we need to know two things:
1) Can you "use" that number that was above FLT_MAX? I mean, can you lower it back down by some number, and have the lower number be correct, or will it just keep spitting out it's value as FLT_MAX?
So try either dividing the number fnum = (FLT_MAX + 1) / 10, and then print fnum and see if it shows the decimal point having been moved over 1 place.
2) How much "room" can we use above FLT_MAX, before it goes to INF and can't be used as a number, any more?
So fnum = (FLT_MAX + 1) * 1.0001, and then
fnum = fnum / 10
Then print fnum, and see if it's what it should be.
1) Can you "use" that number that was above FLT_MAX? I mean, can you lower it back down by some number, and have the lower number be correct, or will it just keep spitting out it's value as FLT_MAX?
(see the attachment)
I can use it.
2) see attachment
Alright, so you've proven that your system can go OVER the FLT_MAX, and still come back down, with good data, intact.
Now all you have to do is adjust your while loops to take advantage of that. Remember the sequence:
1) go UP, initially rather fast, in your first loop. Don't go over the FLT_MAX, by much, because the amount you can safely go over FLT_MAX, will be limited.
2) go down with your next loop, until you're fnum is less than FLT_MAX
3) go up about 10 x slower than you did before (and that 10 x is very adjustable, but should be at least 10 X smaller steps than before, until you're again back up and greater than the FLT_MAX number).
4) go down, again cutting the step size down by a factor of 10 x or more, compared to the last loop, until once again, your fnum is less than FLT_MAX
5) go up, again cutting the step size down by a factor of 10 or more, compared to the last loop.
About this time, after 5 loops, you should be able to stop right on FLT_MAX, by either subtracting one, or by adding one, to fnum. If you get close enough on the go down loop, then you'll add one. If it's on the up loop, you'll subtract one, on the end.
Or in my case, the system just reports fnum is at the maximum float value.
And you're done.
This is where my problem lies:
no matter what number i pick it constantly says its an INF. And when i pick fnum *= 1.00000001;, then i have to wait a long time, which im doing right now. Maybe that'll work. But for all the others it instantly writes INF.
(still waiting lol).
I waited over 2 hours now and nothing happens so...
You're bringing fnum UP still. You WANT it to read fnum as #INF...
Then you bring fnum back DOWN.
if ever
1.00000001 is too slow, when multiplying, then replace it with
1.000000015
1.00000002 through 9, or
1.00000010 , or even
1.00000100
You have to be a bit creative to find what works for your system.
1.0000006 - 1.00000009 seems to be working for me, and i can alter the value after ive gotten the max value.
I guess i dont have to do any more computing after this, since im geting the direct value right after the first loop:
You've got it!
Some persistence required, but successful and educational as well. I had no idea there was "elbow room" above the FLT_MAX value.
:D. Thanks for all the help.
It was sure worth it.
Altho, there is still one thing im interested about.
Minimum float value is -FLT_MAX, and maximum float value is +FLT_MAX, but how come my program shows FLT_MIN on 0? Wouldnt this mean minimum FLT value is 0? I mean, why are they defined as 0 in float.h.(header im using).
Also, if i try printing long double max value, it says INF. Im using %e while trying to print it on
stdout.
Unless there was an unnoticed typo error in the program, I have no idea why any signed limit would print out as zero!
The limits for floats are in a separate header file "float.h", while the integral data type limits are in "limits.h". Do you need to include a different header file?
I'd hate to think it was a feature you'd only get if you bought the "professional" version of the compiler. That would just be wrong.
This is a part of my compiler's data in floats.h:
Code:/* smallest positive IEEE normal numbers */
#define DBL_MIN 2.2250738585072014E-308
#define FLT_MIN 1.17549435E-38F
#define LDBL_MIN _tiny_ldble
#define DBL_MAX _huge_dble
#define FLT_MAX _huge_flt
#define LDBL_MAX _huge_ldble
#define DBL_MAX_EXP +1024
#define FLT_MAX_EXP +128
#define LDBL_MAX_EXP +16384
#define DBL_MAX_10_EXP +308
#define FLT_MAX_10_EXP +38
#define LDBL_MAX_10_EXP +4932
#define DBL_MIN_10_EXP -307
#define FLT_MIN_10_EXP -37
#define LDBL_MIN_10_EXP -4931
#define DBL_MIN_EXP -1021
#define FLT_MIN_EXP -125
#define LDBL_MIN_EXP -16381
and clearly includes negative numbers.
So that's a great question for your instructor - hah! :)