FPU
Control & Exception Handling
See Also: Error Handling
The FPU -- Floating Point Unit -- has configurable settings that allow you to control the precision of calculations, the rounding mode, and exception handling. These settings are defined as part of the IEEE 754 standard, and are implemented in today's computers at the hardware level by various PC chipmakers. This help file topic is mainly concerned with explaining how to implement these settings from uCalc Fast Math Parser, and not so much with why or when to use them. For a detailed explanation of the FPU, see the IA-32 Intel Architecture Software Developer’s Manual, which is available at www.intel.com. Also consult documentation for the IEEE 754 standard. Visit www.ieee.org to find out more.
uCalc Fast Math Parser keeps two separate FPU control word settings, which are insulated one from the other. One is for uCalc Fast Math Parser, and the other is for your host program. If you have another DLL component that uses a different FPU setting, this will not affect uCalc Fast Math Parser or vice-versa. Things run most efficiently if uCalc's FPU word is the same as that of your host program.
If you mask a particular exception, then instead of raising an error when this exception is encountered, a special value will be returned. For instance, if the division by 0 exception is masked (with uc_FPU_Mask_ZeroDivide), then 1/0 would return Inf (for Infinity) instead of raising a Divison by 0 error.
Note: Managed code under Visual Studio 2012 does not work well with unmasked settings. Therefore, it is best to leave the FPU control word with the default settings in C#, VC++, and VB.NET.
Here is the list of uCalc FPU commands:
uc_SetFPU
uc_SetFPU_HostProg
uc_GetFPU
uc_GetFPU_HostProg
uc_ToggleFPU
uc_ToggleFPU_HostProg
Here is the list of FPU Control word settings:
uc_FPU_Mask_InvalidOp
uc_FPU_Mask_DenormalOp
uc_FPU_Mask_ZeroDivide
uc_FPU_Mask_Overflow
uc_FPU_Mask_Underflow
uc_FPU_Mask_PrecisionLoss
uc_FPU_Precision_Single
uc_FPU_Precision_Double
uc_FPU_Precision_Extended
uc_FPU_Round_Even
uc_FPU_Round_Down
uc_FPU_Round_Up
uc_FPU_Round_Toward
If you wanted to toggle the Division by 0 bit for instance, you'd do it like this (in VB):
ucFPU(uc_ToggleFPU, uc_FPU_Mask_ZeroDivide)
where the first argument is a command, the second argument is always 0, and the third argument is the particular setting you want to toggle. If the ZeroDivide mask was off, uc_ToggleFPU would turn it on. If it was on, uc_ToggleFPU would turn it off. If you wanted to set multiple bits instead of toggling just one, then you would add them together, like this (using uc_SetFPU instead of uc_ToggleFPU):
ucFPU(ucSetFPU, uc_FPU_Mask_PrecisionLoss + uc_FPU_Precision_Extended
+ uc_FPU_Round_Even)
The default start-up FPU setting is arbitrarily configured as follows:
uc_FPU_Mask_InvalidOp
+ uc_FPU_Mask_DenormalOp
+ uc_FPU_Mask_ZeroDivide
+ uc_FPU_Mask_Overflow
+ uc_FPU_Mask_Underflow
+ uc_FPU_Mask_PrecisionLoss
+ uc_FPU_Precision_Extended
The following three Visual Basic examples assume that you are starting with the default setting. If you have a different setting, you can start each example with the following line:
ucFPU(ucSetFPU, uc_FPU_Mask_InvalidOp _
+ uc_FPU_Mask_DenormalOp _
+ uc_FPU_Mask_ZeroDivide +
uc_FPU_Mask_Overflow _
+ uc_FPU_Mask_Underflow + uc_FPU_Mask_PrecisionLoss _
+ uc_FPU_Precision_Extended)
The demo files for the various supported compilers contain source code examples for toggling the FPU in those programming languages.
Example 1: Division by 0 vs Inf
Visual Basic
|
Print ucEvalStr("1/0")
' This returns Inf ucFPU(uc_ToggleFPU, uc_FPU_Mask_ZeroDivide) Print ucEvalStr("1/0")
' This returns a Division by 0 error ucFPU(uc_ToggleFPU, uc_FPU_Mask_ZeroDivide) Print ucEvalStr("1/0")
' This returns Inf again |
Visual Basic
|
Print ucEvalStr("100!^150")
' This returns Inf ucFPU(uc_ToggleFPU, uc_FPU_Mask_Overflow) Print ucEvalStr("100!^150")
' This returns a Floating point overflow error ucFPU(uc_ToggleFPU, uc_FPU_Mask_Overflow) Print ucEvalStr("100!^150")
' This returns Inf again |
Visual Basic
|
Print ucEvalStr("Sqr(-5)") ' This returns NaN ucFPU(uc_ToggleFPU, uc_FPU_Mask_InvalidOp) Print ucEvalStr("Sqr(-5)") ' This returns an Invalid operation
error ucFPU(uc_ToggleFPU, uc_FPU_Mask_InvalidOp) Print ucEvalStr("Sqr(-5)") ' This returns NaN
again |
Example 4: Allowing your compiler to catch an exception
In this example, a uCalc error handler is defined, which returns ucReRaise in order to allow the host Delphi compiler to catch the exception, using try / except. If you enter an expression such as 1/0, and the Division by 0 FPU setting is not masked, then a message box will display: This is handled by Try/Except in Delphi.
Delphi
|
function MyErrorHandlerB(t:
Longword): Longword; stdcall; begin
// Additional code may go here if necessary Result :=
ucReRaise; end; procedure TForm1.btnEvalClick(Sender: TObject); begin try txtResult.Text := ucEvalStr(txtExpression.Text); except ShowMessage('This is handled by Try/Except in Delphi'); end; end; // The following line can go in
TForm1.FormCreate() uCalc(uc_AddErrorHandler, 0, Longword(@MyErrorHandlerB)); |
What’s different in
version 3.0
· Instead of setting the FPU using the general uCalc() function, you should now use the provided ucFPU() function. Also, it now takes two arguments instead of three (the second argument was unused).