From d282252b3043c6e81e24a0133803f26df934f81d Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Sun, 8 Aug 2021 18:01:43 +0200 Subject: [PATCH 01/17] add link to epsilon --- docs/nodes/analyzer/points_inside_mesh.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/nodes/analyzer/points_inside_mesh.rst b/docs/nodes/analyzer/points_inside_mesh.rst index 36fb6ab62..6113c8cd1 100644 --- a/docs/nodes/analyzer/points_inside_mesh.rst +++ b/docs/nodes/analyzer/points_inside_mesh.rst @@ -20,6 +20,8 @@ The node determines if points are inside a mesh. I has two modes, 2D and 3D * Warning. This is only a first implementation, likely it will be more correct after a few iterations. + * *Multisample* has an Epsilon parameter, which alows you to relax precision. More information about that can be found here: :doc:`Epsilon <../epsilon>` + see https://github.com/nortikin/sverchok/pull/1703 Examples of use -- GitLab From 2a24d86b9246756c4d7a79aaa677df350f525ac5 Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Sun, 8 Aug 2021 18:05:21 +0200 Subject: [PATCH 02/17] add file for epsilon --- docs/epsilon.rst | 74 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 docs/epsilon.rst diff --git a/docs/epsilon.rst b/docs/epsilon.rst new file mode 100644 index 000000000..d10c81133 --- /dev/null +++ b/docs/epsilon.rst @@ -0,0 +1,74 @@ +An explanation of Epsilon (and the computational limits imposed by 32bit floating point arithmetic) +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + This explanation is directed at the newcomer, for more elaborate + explanations consult the links below. + +Blender’s ``Vector`` +-------------------- + +A ``float`` is number with a decimal point and one or more digits behind +the decimal point. Blender’s ``Vector`` datatypes are currently *32bit +floats*, the same is true for regular ``Python`` floats. The limit of +the 32bit float precision is approximately 5 to 6 digits of +significance. The reason for this limited precision is purely down to +the amount of memory that 32bit floats are stored in. The choice to use +32bit floats in Blender is about lower memory usage and the non-critical +/ non-engineering “Artistic” nature of Blender’s origins. + +Numpy ``datatypes`` +------------------- + +``Numpy`` offers 32bit and 64bit floats. 64bit floats store more +information (more significant digits) and therefore take up more memory +to store the value. They are a lot more precise. + +What does this mean for Sverchok? +--------------------------------- + +Sverchok uses ``numpy`` extensively, but for some functionality we +import Blender functions and they use ``Vector`` datatypes internally +based around 32bit floats, those functions will have limited internal +precision. To get the most accuracy out of these kinds of calculations +the numbers need to be in the same order of magnitude throughout the +whole calculation. Most users will rarely run into issues, but you might +have if you are reading this. + +How does this effect Sverchok? To begin to answer that, some context is needed. +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +For example if you have vectors with an ``x`` component of ``4000m``, +then that number is ultimately accurate only to about a centimeter. + +.. code:: python + + 4000.01 + +You might see more numbers behind the decimal point, but consider those +an illusion (an artifact) - only the first 5 or 6 numbers in the 32bit +float will be considered significant. + +In non-engineering tolerances in the real world what sense does it make +to have a tolerance of centimeters on something that is 4 kilometer +long. Especially if the end product is going to be a render. If you are +rendering something that is 4km long, like a bridge, how many pixels +would the render need to be wide to make a detail (like a weld-seam) of +1 centimeter thick appear in the render? That’s a big render. + +If we think more about architectural structures, something like 40 +meters, well then the precision behind the decimal is 6-2 = 4, a tenth +of a millimeter. If you are rendering a 40m tall building, how many +pixels would the render need to be high to see a details of a tenth of a +millimeter? That’s a big render, it’s the same as the previous example. + +.. code:: python + + 40.0001 + +Calculations and Epsilon +~~~~~~~~~~~~~~~~~~~~~~~~ + +The core concept is: if your geometry uses big numbers, you can increase +``Epsilon`` to allow the tolerance in the calculations to be more in +line with the magnitude of the numbers. If you have really small numbers +(like millimeters) in your vectors, you want ``epsilon`` to be as small -- GitLab From fc0b38369358c4ee9867185cbbf0838983975e73 Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Sun, 8 Aug 2021 18:07:44 +0200 Subject: [PATCH 03/17] path relative fix? --- docs/nodes/analyzer/points_inside_mesh.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/nodes/analyzer/points_inside_mesh.rst b/docs/nodes/analyzer/points_inside_mesh.rst index 6113c8cd1..fa6f99235 100644 --- a/docs/nodes/analyzer/points_inside_mesh.rst +++ b/docs/nodes/analyzer/points_inside_mesh.rst @@ -20,7 +20,7 @@ The node determines if points are inside a mesh. I has two modes, 2D and 3D * Warning. This is only a first implementation, likely it will be more correct after a few iterations. - * *Multisample* has an Epsilon parameter, which alows you to relax precision. More information about that can be found here: :doc:`Epsilon <../epsilon>` + * *Multisample* has an Epsilon parameter, which alows you to relax precision. More information about that can be found here: :doc:`Epsilon <../../epsilon>` see https://github.com/nortikin/sverchok/pull/1703 -- GitLab From 8b5059909372780db0b8ea5767466c86282b521b Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Sun, 8 Aug 2021 18:08:42 +0200 Subject: [PATCH 04/17] one level deeper --- docs/nodes/analyzer/points_inside_mesh.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/nodes/analyzer/points_inside_mesh.rst b/docs/nodes/analyzer/points_inside_mesh.rst index fa6f99235..32478fb27 100644 --- a/docs/nodes/analyzer/points_inside_mesh.rst +++ b/docs/nodes/analyzer/points_inside_mesh.rst @@ -20,7 +20,7 @@ The node determines if points are inside a mesh. I has two modes, 2D and 3D * Warning. This is only a first implementation, likely it will be more correct after a few iterations. - * *Multisample* has an Epsilon parameter, which alows you to relax precision. More information about that can be found here: :doc:`Epsilon <../../epsilon>` + * *Multisample* has an Epsilon parameter, which alows you to relax precision. More information about that can be found here: :doc:`Epsilon <../../../epsilon>` see https://github.com/nortikin/sverchok/pull/1703 -- GitLab From 34af2bd70e55e9321278dabbae40121b61d2c1ff Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Sun, 8 Aug 2021 18:23:38 +0200 Subject: [PATCH 05/17] add to exclude? --- docs/conf.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/docs/conf.py b/docs/conf.py index 115c06cab..46cd2e868 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -94,7 +94,12 @@ release = version # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. -exclude_patterns = ['_build', 'pull_request_template.rst', 'issue_template.rst'] +exclude_patterns = [ + '_build', + 'pull_request_template.rst', + 'issue_template.rst', + 'epsilon.rst' +] # The reST default role (used for this markup: `text`) to use for all # documents. -- GitLab From 14745db008bb531452ecad817609865da7b734de Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Sun, 8 Aug 2021 18:25:13 +0200 Subject: [PATCH 06/17] path correct now? --- docs/nodes/analyzer/points_inside_mesh.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/nodes/analyzer/points_inside_mesh.rst b/docs/nodes/analyzer/points_inside_mesh.rst index 32478fb27..fa6f99235 100644 --- a/docs/nodes/analyzer/points_inside_mesh.rst +++ b/docs/nodes/analyzer/points_inside_mesh.rst @@ -20,7 +20,7 @@ The node determines if points are inside a mesh. I has two modes, 2D and 3D * Warning. This is only a first implementation, likely it will be more correct after a few iterations. - * *Multisample* has an Epsilon parameter, which alows you to relax precision. More information about that can be found here: :doc:`Epsilon <../../../epsilon>` + * *Multisample* has an Epsilon parameter, which alows you to relax precision. More information about that can be found here: :doc:`Epsilon <../../epsilon>` see https://github.com/nortikin/sverchok/pull/1703 -- GitLab From 46e9dbc0e9d9f74f94064f7686dd6d9693eb40eb Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Sun, 8 Aug 2021 18:27:56 +0200 Subject: [PATCH 07/17] add private directive --- docs/conf.py | 3 +-- docs/epsilon.rst | 3 +++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index 46cd2e868..cdf0b09d8 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -97,8 +97,7 @@ release = version exclude_patterns = [ '_build', 'pull_request_template.rst', - 'issue_template.rst', - 'epsilon.rst' + 'issue_template.rst' ] # The reST default role (used for this markup: `text`) to use for all diff --git a/docs/epsilon.rst b/docs/epsilon.rst index d10c81133..049ae780a 100644 --- a/docs/epsilon.rst +++ b/docs/epsilon.rst @@ -1,3 +1,6 @@ +.. meta:: + :scope: private_version + An explanation of Epsilon (and the computational limits imposed by 32bit floating point arithmetic) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- GitLab From 842e3d42fd26a959aa8371653ecdbe49f07d19f6 Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Sun, 8 Aug 2021 18:43:00 +0200 Subject: [PATCH 08/17] path higher up --- docs/nodes/analyzer/points_inside_mesh.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/nodes/analyzer/points_inside_mesh.rst b/docs/nodes/analyzer/points_inside_mesh.rst index fa6f99235..32478fb27 100644 --- a/docs/nodes/analyzer/points_inside_mesh.rst +++ b/docs/nodes/analyzer/points_inside_mesh.rst @@ -20,7 +20,7 @@ The node determines if points are inside a mesh. I has two modes, 2D and 3D * Warning. This is only a first implementation, likely it will be more correct after a few iterations. - * *Multisample* has an Epsilon parameter, which alows you to relax precision. More information about that can be found here: :doc:`Epsilon <../../epsilon>` + * *Multisample* has an Epsilon parameter, which alows you to relax precision. More information about that can be found here: :doc:`Epsilon <../../../epsilon>` see https://github.com/nortikin/sverchok/pull/1703 -- GitLab From f59075577456b688a32dab666727e3bf83b0a3dd Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Sun, 8 Aug 2021 21:02:42 +0200 Subject: [PATCH 09/17] add to toctree --- docs/data_structure/data_structure_index.rst | 3 ++- docs/epsilon.rst | 3 --- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/docs/data_structure/data_structure_index.rst b/docs/data_structure/data_structure_index.rst index dab741b03..667f955bc 100644 --- a/docs/data_structure/data_structure_index.rst +++ b/docs/data_structure/data_structure_index.rst @@ -11,4 +11,5 @@ Data structure surfaces nurbs fields - solids \ No newline at end of file + solids + precision (32bit float) <../epsilon> \ No newline at end of file diff --git a/docs/epsilon.rst b/docs/epsilon.rst index 049ae780a..d10c81133 100644 --- a/docs/epsilon.rst +++ b/docs/epsilon.rst @@ -1,6 +1,3 @@ -.. meta:: - :scope: private_version - An explanation of Epsilon (and the computational limits imposed by 32bit floating point arithmetic) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- GitLab From 1856bf4c93d219b8e986ac8cf8f296c5f2c0e26e Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Mon, 9 Aug 2021 16:08:09 +0200 Subject: [PATCH 10/17] add more up to date link to 404.html --- docs/404.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/404.html b/docs/404.html index 50a2582ab..8a8f0fed6 100644 --- a/docs/404.html +++ b/docs/404.html @@ -31,7 +31,7 @@ -- GitLab From 4094f915e79e3533b21084c94b16d77d73aa4785 Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Mon, 9 Aug 2021 23:00:42 +0200 Subject: [PATCH 11/17] missing text --- docs/epsilon.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/epsilon.rst b/docs/epsilon.rst index d10c81133..f705ac762 100644 --- a/docs/epsilon.rst +++ b/docs/epsilon.rst @@ -71,4 +71,4 @@ Calculations and Epsilon The core concept is: if your geometry uses big numbers, you can increase ``Epsilon`` to allow the tolerance in the calculations to be more in line with the magnitude of the numbers. If you have really small numbers -(like millimeters) in your vectors, you want ``epsilon`` to be as small +(like millimeters) in your vectors, you want ``epsilon`` to be as small as possible. -- GitLab From aa3f1f0cd9a4ef03b9d32f1c9918c8289a5276e0 Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Thu, 12 Aug 2021 10:19:29 +0200 Subject: [PATCH 12/17] reshuffle text --- docs/epsilon.rst | 46 ++++++++-------------------------------------- 1 file changed, 8 insertions(+), 38 deletions(-) diff --git a/docs/epsilon.rst b/docs/epsilon.rst index f705ac762..7c788a689 100644 --- a/docs/epsilon.rst +++ b/docs/epsilon.rst @@ -7,59 +7,32 @@ An explanation of Epsilon (and the computational limits imposed by 32bit floatin Blender’s ``Vector`` -------------------- -A ``float`` is number with a decimal point and one or more digits behind -the decimal point. Blender’s ``Vector`` datatypes are currently *32bit -floats*, the same is true for regular ``Python`` floats. The limit of -the 32bit float precision is approximately 5 to 6 digits of -significance. The reason for this limited precision is purely down to -the amount of memory that 32bit floats are stored in. The choice to use -32bit floats in Blender is about lower memory usage and the non-critical -/ non-engineering “Artistic” nature of Blender’s origins. +Blender’s ``Vector`` datatypes are currently composed of 2 or more numbers, named "floats". *32bit floats* to be specific. A ``float`` is number with a decimal point and one or more digits behind the decimal point, for precision. The limit of the 32bit float precision is approximately 5 to 6 digits of significance. The reason for this limited precision is purely down to the amount of memory that 32bit floats are stored in. The choice to use 32bit floats in Blender is about lower memory usage and the non-critical / non-engineering “Artistic” nature of Blender’s origins. Numpy ``datatypes`` ------------------- -``Numpy`` offers 32bit and 64bit floats. 64bit floats store more -information (more significant digits) and therefore take up more memory -to store the value. They are a lot more precise. +``Numpy`` offers 32bit and 64bit floats. 64bit floats store more information (more significant digits) and therefore take up more memory to store the value. They are a lot more precise. What does this mean for Sverchok? --------------------------------- -Sverchok uses ``numpy`` extensively, but for some functionality we -import Blender functions and they use ``Vector`` datatypes internally -based around 32bit floats, those functions will have limited internal -precision. To get the most accuracy out of these kinds of calculations -the numbers need to be in the same order of magnitude throughout the -whole calculation. Most users will rarely run into issues, but you might -have if you are reading this. +Sverchok uses ``numpy`` extensively, but for some functionality we import Blender functions and they use ``Vector`` datatypes internally based around 32bit floats, those functions will have limited internal precision. To get the most accuracy out of these kinds of calculations the numbers need to be in the same order of magnitude throughout the whole calculation. Most users will rarely run into issues, but you might have if you are reading this. How does this effect Sverchok? To begin to answer that, some context is needed. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -For example if you have vectors with an ``x`` component of ``4000m``, -then that number is ultimately accurate only to about a centimeter. +For example if you have vectors with an ``x`` component of ``4000m``, then that number is ultimately accurate only to about a centimeter. .. code:: python 4000.01 -You might see more numbers behind the decimal point, but consider those -an illusion (an artifact) - only the first 5 or 6 numbers in the 32bit -float will be considered significant. +You might see more numbers behind the decimal point, but consider those an illusion (an artifact) - only the first 5 or 6 numbers in the 32bit float will be considered significant. -In non-engineering tolerances in the real world what sense does it make -to have a tolerance of centimeters on something that is 4 kilometer -long. Especially if the end product is going to be a render. If you are -rendering something that is 4km long, like a bridge, how many pixels -would the render need to be wide to make a detail (like a weld-seam) of -1 centimeter thick appear in the render? That’s a big render. +In non-engineering tolerances in the real world what sense does it make to have a tolerance of centimeters on something that is 4 kilometer long. Especially if the end product is going to be a render. If you are rendering something that is 4km long, like a bridge, how many pixels would the render need to be wide to make a detail (like a weld-seam) of 1 centimeter thick appear in the render? That’s a big render. -If we think more about architectural structures, something like 40 -meters, well then the precision behind the decimal is 6-2 = 4, a tenth -of a millimeter. If you are rendering a 40m tall building, how many -pixels would the render need to be high to see a details of a tenth of a -millimeter? That’s a big render, it’s the same as the previous example. +If we think more about architectural structures, something like 40 meters, well then the precision behind the decimal is 6-2 = 4, a tenth of a millimeter. If you are rendering a 40m tall building, how many pixels would the render need to be high to see a details of a tenth of a millimeter? That’s a big render, it’s the same as the previous example. .. code:: python @@ -68,7 +41,4 @@ millimeter? That’s a big render, it’s the same as the previous example. Calculations and Epsilon ~~~~~~~~~~~~~~~~~~~~~~~~ -The core concept is: if your geometry uses big numbers, you can increase -``Epsilon`` to allow the tolerance in the calculations to be more in -line with the magnitude of the numbers. If you have really small numbers -(like millimeters) in your vectors, you want ``epsilon`` to be as small as possible. +The core concept is: if your geometry uses big numbers, you can increase ``Epsilon`` to allow the tolerance in the calculations to be more in line with the magnitude of the numbers. If you have really small numbers (like millimeters) in your vectors, you want ``epsilon`` to be as small as possible. -- GitLab From 6688da8e9955c562dc29dca20ae03f4e8f79d922 Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Thu, 12 Aug 2021 10:31:05 +0200 Subject: [PATCH 13/17] describe the limit of precision --- docs/epsilon.rst | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/docs/epsilon.rst b/docs/epsilon.rst index 7c788a689..06758c605 100644 --- a/docs/epsilon.rst +++ b/docs/epsilon.rst @@ -32,11 +32,20 @@ You might see more numbers behind the decimal point, but consider those an illus In non-engineering tolerances in the real world what sense does it make to have a tolerance of centimeters on something that is 4 kilometer long. Especially if the end product is going to be a render. If you are rendering something that is 4km long, like a bridge, how many pixels would the render need to be wide to make a detail (like a weld-seam) of 1 centimeter thick appear in the render? That’s a big render. -If we think more about architectural structures, something like 40 meters, well then the precision behind the decimal is 6-2 = 4, a tenth of a millimeter. If you are rendering a 40m tall building, how many pixels would the render need to be high to see a details of a tenth of a millimeter? That’s a big render, it’s the same as the previous example. +If we think more about architectural structures, something like 40 meters (2 digits), well then the precision behind the decimal is .. code:: python - 40.0001 +# 6 digits of total precision +# 40m is 2 digits +# remaining precision digits are: +6-2 = 4. + +# a tenth of a millimeter. +40.0001 + +If you are rendering a 40m tall building, how many pixels would the render need to be high to see a details of a tenth of a millimeter? That’s a big render, it’s the same as the previous example. + Calculations and Epsilon ~~~~~~~~~~~~~~~~~~~~~~~~ -- GitLab From 89d355c1ee36d33777e1110dbd507d2ca779b710 Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Thu, 12 Aug 2021 10:32:52 +0200 Subject: [PATCH 14/17] correct indentation --- docs/epsilon.rst | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/docs/epsilon.rst b/docs/epsilon.rst index 06758c605..90572657b 100644 --- a/docs/epsilon.rst +++ b/docs/epsilon.rst @@ -36,13 +36,14 @@ If we think more about architectural structures, something like 40 meters (2 dig .. code:: python -# 6 digits of total precision -# 40m is 2 digits -# remaining precision digits are: -6-2 = 4. + # 6 digits of total precision + # 40m is 2 digits + # remaining precision digits are: + 6-2 = 4. + + # a tenth of a millimeter. + 40.0001 -# a tenth of a millimeter. -40.0001 If you are rendering a 40m tall building, how many pixels would the render need to be high to see a details of a tenth of a millimeter? That’s a big render, it’s the same as the previous example. -- GitLab From 9d8bd27a36dcac8e942ed2f5f5e2725d912046ba Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Fri, 15 Oct 2021 18:02:51 +0200 Subject: [PATCH 15/17] add link to float math --- docs/epsilon.rst | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/docs/epsilon.rst b/docs/epsilon.rst index 90572657b..6d1e41679 100644 --- a/docs/epsilon.rst +++ b/docs/epsilon.rst @@ -52,3 +52,8 @@ Calculations and Epsilon ~~~~~~~~~~~~~~~~~~~~~~~~ The core concept is: if your geometry uses big numbers, you can increase ``Epsilon`` to allow the tolerance in the calculations to be more in line with the magnitude of the numbers. If you have really small numbers (like millimeters) in your vectors, you want ``epsilon`` to be as small as possible. + +Further Reading +~~~~~~~~~~~~~~~ + +Floating Point Arithmetic: https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html -- GitLab From de6a32b1b20d6017b5da421b4a5c2a1261741a36 Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Mon, 30 May 2022 16:21:06 +0200 Subject: [PATCH 16/17] add the introduction that impressed me most. --- docs/epsilon.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/epsilon.rst b/docs/epsilon.rst index 6d1e41679..52ec19976 100644 --- a/docs/epsilon.rst +++ b/docs/epsilon.rst @@ -57,3 +57,4 @@ Further Reading ~~~~~~~~~~~~~~~ Floating Point Arithmetic: https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html +Alex Januszkiewicz's explanation (rip) https://web.archive.org/web/20070105015750/http://www.intelcad.com/pages/autocad/index.htm -- GitLab From 9ed9143fcf9dd8f22311da96f16ada997b31f8b8 Mon Sep 17 00:00:00 2001 From: Dealga McArdle Date: Mon, 25 Jul 2022 19:13:11 +0200 Subject: [PATCH 17/17] Update epsilon.rst --- docs/epsilon.rst | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/docs/epsilon.rst b/docs/epsilon.rst index 52ec19976..d84c0aeb5 100644 --- a/docs/epsilon.rst +++ b/docs/epsilon.rst @@ -56,5 +56,6 @@ The core concept is: if your geometry uses big numbers, you can increase ``Epsil Further Reading ~~~~~~~~~~~~~~~ -Floating Point Arithmetic: https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html -Alex Januszkiewicz's explanation (rip) https://web.archive.org/web/20070105015750/http://www.intelcad.com/pages/autocad/index.htm +- Floating Point Arithmetic: https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html +- Alex Januszkiewicz's explanation (rip): https://web.archive.org/web/20070105015750/http://www.intelcad.com/pages/autocad/index.htm +- johndcook: https://www.johndcook.com/blog/2009/04/06/anatomy-of-a-floating-point-number/ -- GitLab