Merge branch 'dev-patch' into refactor/rotate-y-hit

hollasch · web-flow · commit 07f11f5045ef · 2024-08-23T11:29:07.000-07:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -12,15 +12,18 @@ Change Log / Ray Tracing in One Weekend
               height for code listings in both print and browser.
   - Change -- Include hittable.h from material.h; drop `hit_record` forward declaration (#1609)
   - Fix    -- Slight improvement to `rotate_y::hit()` function (#1484)
+  - Fix    -- Fixed possible bogus values from `random_unit_vector()` due to underflow (#1606)
 
 ### In One Weekend
   - Fix    -- Fixed usage of the term "unit cube" for a cube of diameter two (#1555, #1603)
   - Fix    -- Fixed broken highlighting on some code listings (#1600)
 
 ### The Next Week
+  - Fix    -- Add missing ellipsis in listing 2.62 (#1612)
 
 ### The Rest of Your Life
   - Fix    -- Fix typo of "arbitrary" (#1589)
+  - New    -- Added a bit more explanation of Buffon's needle problem (#1529)
 
 
 ----------------------------------------------------------------------------------------------------
diff --git a/books/RayTracingInOneWeekend.html b/books/RayTracingInOneWeekend.html
@@ -2292,24 +2292,29 @@
 surprisingly complicated to understand, and quite a bit complicated to implement. Instead, we'll use
 what is typically the easiest algorithm: A rejection method. A rejection method works by repeatedly
 generating random samples until we produce a sample that meets the desired criteria. In other words,
-keep rejecting samples until you find a good one.
+keep rejecting bad samples until you find a good one.
 
 There are many equally valid ways of generating a random vector on a hemisphere using the rejection
 method, but for our purposes we will go with the simplest, which is:
 
-1. Generate a random vector inside of the unit sphere
-2. Normalize this vector
+1. Generate a random vector inside the unit sphere
+2. Normalize this vector to extend it to the sphere surface
 3. Invert the normalized vector if it falls onto the wrong hemisphere
 
 <div class='together'>
 First, we will use a rejection method to generate the random vector inside the unit sphere (that is,
 a sphere of radius 1). Pick a random point inside the cube enclosing the unit sphere (that is, where
-$x$, $y$, and $z$ are all in the range $[-1,+1]$). If this point lies outside (or on) the unit
-sphere, then generate a new one until we find one that lies inside the unit sphere.
+$x$, $y$, and $z$ are all in the range $[-1,+1]$). If this point lies outside the unit
+sphere, then generate a new one until we find one that lies inside or on the unit sphere.
 
-  ![Figure [sphere-vec]: Two vectors were rejected before finding a good one
+  ![Figure [sphere-vec]: Two vectors were rejected before finding a good one (pre-normalization)
   ](../images/fig-1.11-sphere-vec.jpg)
 
+  ![Figure [sphere-vec]: The accepted random vector is normalized to produce a unit vector
+  ](../images/fig-1.12-sphere-unit-vec.jpg)
+
+Here's our first draft of the function:
+
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     ...
 
@@ -2319,49 +2324,45 @@
 
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-    inline vec3 random_in_unit_sphere() {
+    inline vec3 random_unit_vector() {
         while (true) {
             auto p = vec3::random(-1,1);
-            if (p.length_squared() < 1)
-                return p;
+            auto lensq = p.length_squared();
+            if (lensq <= 1)
+                return p / sqrt(lensq);
         }
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    [Listing [random-in-unit-sphere]: <kbd>[vec3.h]</kbd> The random_in_unit_sphere() function]
+    [Listing [random-in-unit-sphere]: <kbd>[vec3.h]</kbd> The random_unit_vector() function, version one]
 
 </div>
 
-<div class='together'>
-Once we have a random vector in the unit sphere we need to normalize it to get a vector _on_ the
-unit sphere.
+Sadly, we have a small floating-point abstraction leak to deal with. Since floating-point numbers
+have finite precision, a very small value can underflow to zero when squared. So if all three
+coordinates are small enough (that is, very near the center of the sphere), the norm of the vector
+will be zero, and thus normalizing will yield the bogus vector $[\pm\infty, \pm\infty, \pm\infty]$.
+To fix this, we'll also reject points that lie inside this "black hole" around the center. With
+double precision (64-bit floats), we can safely support values greater than $10^{-160}$.
 
-  ![Figure [sphere-vec]: The accepted random vector is normalized to produce a unit vector
-  ](../images/fig-1.12-sphere-unit-vec.jpg)
+Here's our more robust function:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    ...
-
-    inline vec3 random_in_unit_sphere() {
+    inline vec3 random_unit_vector() {
         while (true) {
             auto p = vec3::random(-1,1);
-            if (p.length_squared() < 1)
-                return p;
-        }
-    }
-
-
+            auto lensq = p.length_squared();
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-    inline vec3 random_unit_vector() {
-        return unit_vector(random_in_unit_sphere());
+            if (1e-160 < lensq && lensq <= 1)
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+                return p / sqrt(lensq);
+        }
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    [Listing [random-unit-vec]: <kbd>[vec3.h]</kbd> Random vector on the unit sphere]
-
-</div>
+    [Listing [random-in-unit-sphere]: <kbd>[vec3.h]</kbd> The random_unit_vector() function, version one]
 
 <div class='together'>
-And now that we have a random vector on the surface of the unit sphere, we can determine if it is on
-the correct hemisphere by comparing against the surface normal:
+Now that we have a random vector on the surface of the unit sphere, we can determine if it is on the
+correct hemisphere by comparing against the surface normal:
 
   ![Figure [normal-hor]: The normal vector tells us which hemisphere we need
   ](../images/fig-1.13-surface-normal.jpg)
@@ -2377,7 +2378,12 @@
     ...
 
     inline vec3 random_unit_vector() {
-        return unit_vector(random_in_unit_sphere());
+        while (true) {
+            auto p = vec3::random(-1,1);
+            auto lensq = p.length_squared();
+            if (1e-160 < lensq && lensq <= 1)
+                return p / sqrt(lensq);
+        }
     }
 
 
diff --git a/books/RayTracingTheNextWeek.html b/books/RayTracingTheNextWeek.html
@@ -3537,6 +3537,7 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
     class quad : public hittable {
+        ...
     };
 
 
diff --git a/books/RayTracingTheRestOfYourLife.html b/books/RayTracingTheRestOfYourLife.html
@@ -94,8 +94,13 @@
 Estimating Pi
 --------------
 The canonical example of a Monte Carlo algorithm is estimating $\pi$, so let's do that. There are
-many ways to estimate $\pi$, with the Buffon Needle problem being a classic case study. We’ll do a
-variation inspired by this method. Suppose you have a circle inscribed inside a square:
+many ways to estimate $\pi$, with _Buffon's needle problem_ being a classic case study. In Buffon's
+needle problem, one is presented with a floor made of parallel strips of floor board, each of the
+same width. If a needle is randomly dropped onto the floor, what is the probability that the needle
+will lie across two boards? (You can find more information on this problem with a simple Internet
+search.)
+
+We’ll do a variation inspired by this method. Suppose you have a circle inscribed inside a square:
 
   ![Figure [circ-square]: Estimating $\pi$ with a circle inside a square
   ](../images/fig-3.01-circ-square.jpg)
@@ -449,8 +454,8 @@
 
 One Dimensional Monte Carlo Integration
 ====================================================================================================
-Our Buffon Needle example is a way of calculating $\pi$ by solving for the ratio of the area of the
-circle and the area of the circumscribed square:
+Our variation of Buffon's needle problem is a way of calculating $\pi$ by solving for the ratio of
+the area of the circle and the area of the circumscribed square:
 
     $$ \frac{\operatorname{area}(\mathit{circle})}{\operatorname{area}(\mathit{square})}
        = \frac{\pi}{4}
diff --git a/src/InOneWeekend/vec3.h b/src/InOneWeekend/vec3.h
@@ -121,18 +121,15 @@ inline vec3 random_in_unit_disk() {
     }
 }
 
-inline vec3 random_in_unit_sphere() {
+inline vec3 random_unit_vector() {
     while (true) {
         auto p = vec3::random(-1,1);
-        if (p.length_squared() < 1)
-            return p;
+        auto lensq = p.length_squared();
+        if (1e-160 < lensq && lensq <= 1.0)
+            return p / sqrt(lensq);
     }
 }
 
-inline vec3 random_unit_vector() {
-    return unit_vector(random_in_unit_sphere());
-}
-
 inline vec3 random_on_hemisphere(const vec3& normal) {
     vec3 on_unit_sphere = random_unit_vector();
     if (dot(on_unit_sphere, normal) > 0.0) // In the same hemisphere as the normal
diff --git a/src/TheNextWeek/vec3.h b/src/TheNextWeek/vec3.h
@@ -121,18 +121,15 @@ inline vec3 random_in_unit_disk() {
     }
 }
 
-inline vec3 random_in_unit_sphere() {
+inline vec3 random_unit_vector() {
     while (true) {
         auto p = vec3::random(-1,1);
-        if (p.length_squared() < 1)
-            return p;
+        auto lensq = p.length_squared();
+        if (1e-160 < lensq && lensq <= 1.0)
+            return p / sqrt(lensq);
     }
 }
 
-inline vec3 random_unit_vector() {
-    return unit_vector(random_in_unit_sphere());
-}
-
 inline vec3 random_on_hemisphere(const vec3& normal) {
     vec3 on_unit_sphere = random_unit_vector();
     if (dot(on_unit_sphere, normal) > 0.0) // In the same hemisphere as the normal
diff --git a/src/TheRestOfYourLife/vec3.h b/src/TheRestOfYourLife/vec3.h
@@ -121,18 +121,15 @@ inline vec3 random_in_unit_disk() {
     }
 }
 
-inline vec3 random_in_unit_sphere() {
+inline vec3 random_unit_vector() {
     while (true) {
         auto p = vec3::random(-1,1);
-        if (p.length_squared() < 1)
-            return p;
+        auto lensq = p.length_squared();
+        if (1e-160 < lensq && lensq <= 1.0)
+            return p / sqrt(lensq);
     }
 }
 
-inline vec3 random_unit_vector() {
-    return unit_vector(random_in_unit_sphere());
-}
-
 inline vec3 random_on_hemisphere(const vec3& normal) {
     vec3 on_unit_sphere = random_unit_vector();
     if (dot(on_unit_sphere, normal) > 0.0) // In the same hemisphere as the normal

Original file line number	Diff line number	Diff line change
`@@ -121,18 +121,15 @@ inline vec3 random_in_unit_disk() {`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`
`124`		`-inline vec3 random_in_unit_sphere() {`
	`124`	`+inline vec3 random_unit_vector() {`
`125`	`125`	`while (true) {`
`126`	`126`	`auto p = vec3::random(-1,1);`
`127`		`- if (p.length_squared() < 1)`
`128`		`- return p;`
	`127`	`+ auto lensq = p.length_squared();`
	`128`	`+ if (1e-160 < lensq && lensq <= 1.0)`
	`129`	`+ return p / sqrt(lensq);`
`129`	`130`	`}`
`130`	`131`	`}`
`131`	`132`
`132`		`-inline vec3 random_unit_vector() {`
`133`		`- return unit_vector(random_in_unit_sphere());`
`134`		`-}`
`135`		`-`
`136`	`133`	`inline vec3 random_on_hemisphere(const vec3& normal) {`
`137`	`134`	`vec3 on_unit_sphere = random_unit_vector();`
`138`	`135`	`if (dot(on_unit_sphere, normal) > 0.0) // In the same hemisphere as the normal`