Merge pull request #508 from RayTracing/min-max-abs

hollasch · web-flow · commit e824ff6a8aa3 · 2020-05-03T12:37:53.000-07:00
Standardize on fmin/fmax/fabs
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -10,6 +10,8 @@ Change Log -- Ray Tracing in One Weekend
 - New: Add explanation for padding `aarect` in the zero dimension (#488)
 - Change: Minor change to use new `point3` and `color` type aliases for `vec3` (#422)
 - Change: Renamed `constant_texture` to `solid_color`, add RGB constructor (#452)
+- Change: Math notation to bold uppercase points, bold lowercase no-barb vectors (#412)
+- Change: Switch from `ffmin`/`ffmax` to standard `fmin`/`fmax` (#444, #491)
 
 ### _In One Weekend_
 - Fix: Update image and size for first PPM image
diff --git a/books/RayTracingInOneWeekend.html b/books/RayTracingInOneWeekend.html
@@ -1150,9 +1150,6 @@
         return degrees * pi / 180;
     }
 
-    inline double ffmin(double a, double b) { return a <= b ? a : b; }
-    inline double ffmax(double a, double b) { return a >= b ? a : b; }
-
     // Common Headers
 
     #include "ray.h"
@@ -2389,7 +2386,7 @@
   $$ \cos\theta = \mathbf{R} \cdot \mathbf{n} $$
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    double cos_theta = ffmin(dot(-unit_direction, rec.normal), 1.0);
+    double cos_theta = fmin(dot(-unit_direction, rec.normal), 1.0);
     double sin_theta = sqrt(1.0 - cos_theta*cos_theta);
     if(etai_over_etat * sin_theta > 1.0) {
         // Must Reflect
@@ -2420,7 +2417,7 @@
 
                 vec3 unit_direction = unit_vector(r_in.direction());
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-                double cos_theta = ffmin(dot(-unit_direction, rec.normal), 1.0);
+                double cos_theta = fmin(dot(-unit_direction, rec.normal), 1.0);
                 double sin_theta = sqrt(1.0 - cos_theta*cos_theta);
                 if (etai_over_etat * sin_theta > 1.0 ) {
                     vec3 reflected = reflect(unit_direction, rec.normal);
@@ -2499,7 +2496,7 @@
                 double etai_over_etat = (rec.front_face) ? (1.0 / ref_idx) : (ref_idx);
 
                 vec3 unit_direction = unit_vector(r_in.direction());
-                double cos_theta = ffmin(dot(-unit_direction, rec.normal), 1.0);
+                double cos_theta = fmin(dot(-unit_direction, rec.normal), 1.0);
                 double sin_theta = sqrt(1.0 - cos_theta*cos_theta);
                 if (etai_over_etat * sin_theta > 1.0 ) {
                     vec3 reflected = reflect(unit_direction, rec.normal);
diff --git a/books/RayTracingTheNextWeek.html b/books/RayTracingTheNextWeek.html
@@ -584,12 +584,12 @@
 
             bool hit(const ray& r, double tmin, double tmax) const {
                 for (int a = 0; a < 3; a++) {
-                    auto t0 = ffmin((_min[a] - r.origin()[a]) / r.direction()[a],
-                                    (_max[a] - r.origin()[a]) / r.direction()[a]);
-                    auto t1 = ffmax((_min[a] - r.origin()[a]) / r.direction()[a],
-                                    (_max[a] - r.origin()[a]) / r.direction()[a]);
-                    tmin = ffmax(t0, tmin);
-                    tmax = ffmin(t1, tmax);
+                    auto t0 = fmin((_min[a] - r.origin()[a]) / r.direction()[a],
+                                   (_max[a] - r.origin()[a]) / r.direction()[a]);
+                    auto t1 = fmax((_min[a] - r.origin()[a]) / r.direction()[a],
+                                   (_max[a] - r.origin()[a]) / r.direction()[a]);
+                    tmin = fmax(t0, tmin);
+                    tmax = fmin(t1, tmax);
                     if (tmax <= tmin)
                         return false;
                 }
@@ -603,10 +603,6 @@
     [Listing [aabb]: <kbd>[aabb.h]</kbd> Axis-aligned bounding box class]
 </div>
 
-Note that we use the simple custom `ffmax()` function (defined in `rtweekend.h`) instead of the C++
-standard library `fmax()` utility. `ffmax()` is quite a bit faster because it doesn’t worry about
-`NaN`s and other exceptions.
-
 
 An Optimized AABB Hit Method
 -----------------------------
@@ -722,13 +718,13 @@
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     aabb surrounding_box(aabb box0, aabb box1) {
-        point3 small(ffmin(box0.min().x(), box1.min().x()),
-                   ffmin(box0.min().y(), box1.min().y()),
-                   ffmin(box0.min().z(), box1.min().z()));
+        point3 small(fmin(box0.min().x(), box1.min().x()),
+                     fmin(box0.min().y(), box1.min().y()),
+                     fmin(box0.min().z(), box1.min().z()));
 
-        point3 big(ffmax(box0.max().x(), box1.max().x()),
-                   ffmax(box0.max().y(), box1.max().y()),
-                   ffmax(box0.max().z(), box1.max().z()));
+        point3 big(fmax(box0.max().x(), box1.max().x()),
+                   fmax(box0.max().y(), box1.max().y()),
+                   fmax(box0.max().z(), box1.max().z()));
 
         return aabb(small,big);
     }
@@ -2564,8 +2560,8 @@
                     vec3 tester(newx, y, newz);
 
                     for (int c = 0; c < 3; c++) {
-                        min[c] = ffmin(min[c], tester[c]);
-                        max[c] = ffmax(max[c], tester[c]);
+                        min[c] = fmin(min[c], tester[c]);
+                        max[c] = fmax(max[c], tester[c]);
                     }
                 }
             }
diff --git a/src/InOneWeekend/material.h b/src/InOneWeekend/material.h
@@ -43,7 +43,7 @@ class dielectric : public material {
             double etai_over_etat = (rec.front_face) ? (1.0 / ref_idx) : (ref_idx);
 
             vec3 unit_direction = unit_vector(r_in.direction());
-            double cos_theta = ffmin(dot(-unit_direction, rec.normal), 1.0);
+            double cos_theta = fmin(dot(-unit_direction, rec.normal), 1.0);
             double sin_theta = sqrt(1.0 - cos_theta*cos_theta);
             if (etai_over_etat * sin_theta > 1.0 ) {
                 vec3 reflected = reflect(unit_direction, rec.normal);
diff --git a/src/TheNextWeek/hittable.h b/src/TheNextWeek/hittable.h
@@ -149,8 +149,8 @@ rotate_y::rotate_y(shared_ptr<hittable> p, double angle) : ptr(p) {
                 vec3 tester(newx, y, newz);
 
                 for (int c = 0; c < 3; c++) {
-                    min[c] = ffmin(min[c], tester[c]);
-                    max[c] = ffmax(max[c], tester[c]);
+                    min[c] = fmin(min[c], tester[c]);
+                    max[c] = fmax(max[c], tester[c]);
                 }
             }
         }
diff --git a/src/TheNextWeek/material.h b/src/TheNextWeek/material.h
@@ -47,7 +47,7 @@ class dielectric : public material {
             double etai_over_etat = (rec.front_face) ? (1.0 / ref_idx) : (ref_idx);
 
             vec3 unit_direction = unit_vector(r_in.direction());
-            double cos_theta = ffmin(dot(-unit_direction, rec.normal), 1.0);
+            double cos_theta = fmin(dot(-unit_direction, rec.normal), 1.0);
             double sin_theta = sqrt(1.0 - cos_theta*cos_theta);
             if (etai_over_etat * sin_theta > 1.0 ) {
                 vec3 reflected = reflect(unit_direction, rec.normal);
diff --git a/src/TheRestOfYourLife/hittable.h b/src/TheRestOfYourLife/hittable.h
@@ -157,8 +157,8 @@ rotate_y::rotate_y(shared_ptr<hittable> p, double angle) : ptr(p) {
                 vec3 tester(newx, y, newz);
 
                 for (int c = 0; c < 3; c++) {
-                    min[c] = ffmin(min[c], tester[c]);
-                    max[c] = ffmax(max[c], tester[c]);
+                    min[c] = fmin(min[c], tester[c]);
+                    max[c] = fmax(max[c], tester[c]);
                 }
             }
         }
diff --git a/src/TheRestOfYourLife/material.h b/src/TheRestOfYourLife/material.h
@@ -68,7 +68,7 @@ class dielectric : public material {
             double etai_over_etat = (rec.front_face) ? (1.0 / ref_idx) : (ref_idx);
 
             vec3 unit_direction = unit_vector(r_in.direction());
-            double cos_theta = ffmin(dot(-unit_direction, rec.normal), 1.0);
+            double cos_theta = fmin(dot(-unit_direction, rec.normal), 1.0);
             double sin_theta = sqrt(1.0 - cos_theta*cos_theta);
             if (etai_over_etat * sin_theta > 1.0 ) {
                 vec3 reflected = reflect(unit_direction, rec.normal);
diff --git a/src/common/aabb.h b/src/common/aabb.h
@@ -24,12 +24,12 @@ class aabb {
 
         bool hit(const ray& r, double tmin, double tmax) const {
             for (int a = 0; a < 3; a++) {
-                auto t0 = ffmin((_min[a] - r.origin()[a]) / r.direction()[a],
-                                (_max[a] - r.origin()[a]) / r.direction()[a]);
-                auto t1 = ffmax((_min[a] - r.origin()[a]) / r.direction()[a],
-                                (_max[a] - r.origin()[a]) / r.direction()[a]);
-                tmin = ffmax(t0, tmin);
-                tmax = ffmin(t1, tmax);
+                auto t0 = fmin((_min[a] - r.origin()[a]) / r.direction()[a],
+                               (_max[a] - r.origin()[a]) / r.direction()[a]);
+                auto t1 = fmax((_min[a] - r.origin()[a]) / r.direction()[a],
+                               (_max[a] - r.origin()[a]) / r.direction()[a]);
+                tmin = fmax(t0, tmin);
+                tmax = fmin(t1, tmax);
                 if (tmax <= tmin)
                     return false;
             }
@@ -61,13 +61,13 @@ class aabb {
 };
 
 aabb surrounding_box(aabb box0, aabb box1) {
-    vec3 small(ffmin(box0.min().x(), box1.min().x()),
-               ffmin(box0.min().y(), box1.min().y()),
-               ffmin(box0.min().z(), box1.min().z()));
+    vec3 small(fmin(box0.min().x(), box1.min().x()),
+               fmin(box0.min().y(), box1.min().y()),
+               fmin(box0.min().z(), box1.min().z()));
 
-    vec3 big  (ffmax(box0.max().x(), box1.max().x()),
-               ffmax(box0.max().y(), box1.max().y()),
-               ffmax(box0.max().z(), box1.max().z()));
+    vec3 big  (fmax(box0.max().x(), box1.max().x()),
+               fmax(box0.max().y(), box1.max().y()),
+               fmax(box0.max().z(), box1.max().z()));
 
     return aabb(small,big);
 }
diff --git a/src/common/rtweekend.h b/src/common/rtweekend.h
@@ -32,9 +32,6 @@ inline double degrees_to_radians(double degrees) {
     return degrees * pi / 180.0;
 }
 
-inline double ffmin(double a, double b) { return a <= b ? a : b; }
-inline double ffmax(double a, double b) { return a >= b ? a : b; }
-
 inline double clamp(double x, double min, double max) {
     if (x < min) return min;
     if (x > max) return max;
diff --git a/src/common/vec3.h b/src/common/vec3.h
@@ -175,7 +175,7 @@ vec3 reflect(const vec3& v, const vec3& n) {
 }
 
 vec3 refract(const vec3& uv, const vec3& n, double etai_over_etat) {
-    auto cos_theta = ffmin(dot(-uv, n), 1.0);
+    auto cos_theta = fmin(dot(-uv, n), 1.0);
     vec3 r_out_parallel =  etai_over_etat * (uv + cos_theta*n);
     vec3 r_out_perp = -sqrt(1.0 - r_out_parallel.length_squared()) * n;
     return r_out_parallel + r_out_perp;

Original file line number	Diff line number	Diff line change
`@@ -149,8 +149,8 @@ rotate_y::rotate_y(shared_ptr<hittable> p, double angle) : ptr(p) {`
`149`	`149`	`vec3 tester(newx, y, newz);`
`150`	`150`
`151`	`151`	`for (int c = 0; c < 3; c++) {`
`152`		`- min[c] = ffmin(min[c], tester[c]);`
`153`		`- max[c] = ffmax(max[c], tester[c]);`
	`152`	`+ min[c] = fmin(min[c], tester[c]);`
	`153`	`+ max[c] = fmax(max[c], tester[c]);`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`	`}`
Original file line number	Diff line number	Diff line change
`@@ -157,8 +157,8 @@ rotate_y::rotate_y(shared_ptr<hittable> p, double angle) : ptr(p) {`
`157`	`157`	`vec3 tester(newx, y, newz);`
`158`	`158`
`159`	`159`	`for (int c = 0; c < 3; c++) {`
`160`		`- min[c] = ffmin(min[c], tester[c]);`
`161`		`- max[c] = ffmax(max[c], tester[c]);`
	`160`	`+ min[c] = fmin(min[c], tester[c]);`
	`161`	`+ max[c] = fmax(max[c], tester[c]);`
`162`	`162`	`}`
`163`	`163`	`}`
`164`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,9 +32,6 @@ inline double degrees_to_radians(double degrees) {`
`32`	`32`	`return degrees * pi / 180.0;`
`33`	`33`	`}`
`34`	`34`
`35`		`-inline double ffmin(double a, double b) { return a <= b ? a : b; }`
`36`		`-inline double ffmax(double a, double b) { return a >= b ? a : b; }`
`37`		`-`
`38`	`35`	`inline double clamp(double x, double min, double max) {`
`39`	`36`	`if (x < min) return min;`
`40`	`37`	`if (x > max) return max;`