The first bit is the sign (0 for positive, 1 for negative). The bit numbers are counting from the least-significant bit. It defines several standard representations of floating-point numbers, all of which have the following basic pattern (the specific layout here is for 32-bit floats): The IEEE-754 floating-point standard is a standard for representing and manipulating floating-point quantities that is followed by all modern computer systems. This conversion loses information by throwing away the fractional part of f: if f was 3.2, i will end up being just 3. You can convert floating-point numbers to and from integer types explicitly using casts. Mixed uses of floating-point and integer types will convert the integers to floating-point. These are % (use modf from the math library if you really need to get a floating-point remainder) and all of the bitwise operators ~, >, &, ^, and |. Some operators that work on integers will not work on floating-point types. Casts can be used to force floating-point division (see below). Be careful about accidentally using integer division when you mean to use floating-point division: 2/3 is 0. Unlike integer division, floating-point division does not discard the fractional part (although it may produce round-off error: 2.0/3.0 gives 0.66666666666666663, which is not quite exact). If you mix two different floating-point types together, the less-precise one will be extended to match the precision of the more-precise one this also works if you mix integer and floating point types as in 2 / 3.0. You can specific a floating point number in scientific notation using e for the exponent: 6.022e23.įloating-point types in C support most of the same arithmetic and relational operators as integer types x > y, x / y, x + y all make sense when x and y are floats. Note that you have to put at least one digit after the decimal point: 2.0, 3.75, -12.6112. Negative values are typically handled by adding a sign bit that is 0 for positive numbers and 1 for negative numbers.Īny number that has a decimal point in it will be interpreted by the compiler as a floating-point number. For this reason it is usually dropped (although this requires a special representation for 0). Note that for a properly-scaled (or normalized) floating-point number in base 2 the digit before the decimal point is always 1. So (in a very low-precision format), 1 would be 1.000*2 0, 2 would be 1.000*2 1, and 0.375 would be 1.100*2 -2, where the first 1 after the decimal point counts as 1/2, the second as 1/4, etc. The mantissa is usually represented in base b, as a binary fraction. This is done by adjusting the exponent, e.g.
On modern computers the base is almost always 2, and for most floating-point representations the mantissa will be scaled to be between 1 and b.
The core idea of floating-point representations (as opposed to fixed point representations as used by, say, ints), is that a number x is written as m*b e where m is a mantissa or fractional part, b is a base, and e is an exponent. Most math library routines expect and return doubles (e.g., sin is declared as double sin(double), but there are usually float versions as well ( float sinf(float)). The three floating point types differ in how much space they use (32, 64, or 80 bits on x86 CPUs possibly different amounts on other machines), and thus how much precision they provide. The difference is that the integer types can represent values within their range exactly, while floating-point types almost always give only an approximation to the correct value, albeit across a much larger range. Just as the integer types can't represent all integers because they fit in a bounded number of bytes, so also the floating-point types can't represent all real numbers. Real numbers are represented in C by the floating point types float, double, and long double.
0 kommentar(er)
