Homework: Floating Point

Learning objective: hands-on experience with floating point special values.
(Hint: some of what you might learn is that things don't work as you'd expect. Don't spend too much time if you hit a figurative brick wall; ask staff for help at office hours if that happens to you. We've found that even very small version changes for compilers and libraries can produce significant changes for how exceptional floating point values are handled.)

Write a program that exercises 32-bit floating point math edge cases in C or C++ as described below.

Ground rules:This software can be as simple as you like. For example, you can hard-code test input values in const declarations. However, we want you to create a SINGLE function that is used for ALL the test cases and the function needs to do some computation that creates special values, not just return special values. So, for example, to generate infinity you might divide two inputs and in the test set one of them to zero.

Important hint: some systems have trouble generating, propagating, and printing some cases, especially signed NaN (some only do +NaN while others do -NaN) and negative zero. If you get stuck on this ask a TA to make sure it is the library and not you. If your system is "broken" in that way hand in and explain the issue. (And take this as a practical lesson on why floating point is so tricky to use for life critical systems.) We do not intend for you to spend multiple hours chasing this down for the homework.

• Plan your time to spend no more than about 1 hour on this assignment. If you get stuck, write down what you tried that did not work, and move on to the next part. For some systems, some outputs might be impossible to generated. For example some systems might only support -NaN and not +NaN (or the reverse). The point of this assignment is to get some experience, not spend multiple hours in frustration.
• We want you to understand the guts of what really happens, so you are NOT permitted to call ANY library functions to EXCEPT for I/O handling (reading inputs in, printf for output) and functions to generate a special result. This means, for example, you shall not call "isnan()" and you shall not call "fpclassify()" because we want you to get a bit under the hood for this stuff and not just blindly rely on library functions. (You can and perhaps should write your own comparable function for isnan() and provide source code when handing in.)
• You can paste code from a library function such as isnan() into your program if you cite the source (so you can see how it actually gets done).
• You ARE allowed to call library functions for the purpose of using computations that might special values (e.g., OK to call a square root function or tangent function).
• We strongly suggest you use defined standard types for values that you might need. (See float.h)
• You can just do this homework at a Unix command line or however you want on a non-Unix system -- there is no need to involve ROS or the virtual machine mechanisms.
• The example run outputs SHALL be formatted as indicated to make grading practical. In other words, the answer to each "show a computation result" question must be printed out by the program itself, including the purpose of the run (e.g., "Positive NaN"), the inputs, the function called, and the resultant output. The output should be pasted as-is into a homework hand-in slide.
• Do NOT simply convert binary values in hex to floats to create special values to be put into the tested function. (You might need to use hex values when deciding how to print outputs.) We want you to generate special values as the result of using normal floating point computations so you see how that works..
• Feed ONLY normal (non special values) as inputs to your function. For example, creating a NaN and then feeding it into a function that returns NaN is NOT what we want. So this means that special values should be created within the function itself based on normal (non-special) floating point values.
• Create ONE function that is used by all the tests. The calculation inside the function doesn't really need to make sense for any particular application.

As an example, if you have some function that takes three input parameters a, b, c, the computation result to produce NaN using Function A might be:
25-1-d4 Positive NaN: a=17 b=34 c=59==> FuncA(a,b,c)==> result=+NaN (0x7FC00000)

25-1. Create one function that takes at least one floating point input and returns one floating point output. For example, something that computes (b + sqrt(a)) / c (which might or might not be enough for all test cases). Tell us what the function does (normal human-readable math description is OK). A function with a switch statement that returns hard-coded special values is NOT acceptable.

25-2. Create one function called " PrintResult(float r)" that takes a floating point number as input and prints an output including the special values that you need to produce. If simply calling "printf" from within that function does the whole job, good for you. If not, do what you need to do for things to work. You can ONLY use one or more "printf" calls as your output function with whatever functionality is supported by printf-- no other library formatting helper routines accessed via function/procedure calls. It is OK to have internal decision logic and multiple different printf calls if you need to.

25-3. Create one function called " PrintHex(float r) " that takes a floating point number as input and prints an output indicating the hexadecimal value of the floating point variable.

25-4. Create a .c or .cpp file with the function, output printing functions, and test routines using 32-bit floating point variables. As mentioned, don't use standard templates and only use libraries for I/O and generating special floating point values. Also implement enough tests to complete the following (one test per result). We encourage you to use Cunit, but that is not required. Make sure that the code compiles with gcc on a course platform. It should compile warning free with default command line parameters, although the float to hex conversion might generate an unavoidable warning depending upon your compiler and how you write the code.

25-5. Your code, when run, shall produce the following output values using your floating point output function. Show the input variable values (floats) and the output variable values (both float and hex) as printed out from your program (a screenshot is fine). Some creativity might be required to display the values properly depending upon your runtime environment.

• 25-5a. A non-special result (e.g., 1 /3=0.333333)
• 25-5b. Positive infinity
• 25-5c. Negative infinity
• 25-5d. Positive NaN
• 25-5e. Negative NaN
• 25-5f. Positive zero
• 25-5g. Negative zero
• 25-5h. Largest positive denormalized value (i.e., the largest value that can be stored in a floating point number that is still a denorm). (If you're not quite sure what this is, see the supplemental material.)

Rubric:

• One slide for 25-1 (the function you created) with the c code pasted onto the slide
• One slide for 25-2 PrintResult
• One slide for 25-3 PrintHex
• One or more slides with the rest of the code (25-4) pasted into the slides big enough to be legible so we have all the source code you used
• One slide with the output containing all elements required by 25-5
• One slide -- only if needed: if you couldn't get a particular value to work, show what you could get to work on the previous slides and explain what you think went wrong.
• You do not need to hand in the .cpp file separately. Just hand in the slides per above.

Supplemental Material:

• Computerphile video on floating point numbers: https://youtu.be/PZRI1IfStY0
• What every programmer should know about floating-point arithmetic: http://floating-point-gui.de
• What Every Computer Scientist Should Know about FP Math https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
• Live calculator for floating point values: https://evanw.github.io/float-toy/