Factor FloatModulo out of Angle::Normalize

So that it can also be used in other places.  Note that it has to go in a new module rather than in `geometry/internal/algorithms` in order to avoid a dependency cycle with `Angle`.

PiperOrigin-RevId: 721475555

Author: Ink Open Source

ink/geometry/BUILD.bazel

@@ -58,6 +58,7 @@ cc_library(
     hdrs = ["angle.h"],
     visibility = ["//visibility:public"],
     deps = [
+        "//ink/geometry/internal:modulo",
         "//ink/types:numbers",
         "@com_google_absl//absl/strings:str_format",
     ],

ink/geometry/angle.cc

@@ -22,25 +22,6 @@
 
 namespace ink {
 
-Angle Angle::Normalized() const {
-  float radians =
-      std::fmod(ValueInRadians(), static_cast<float>(2.0 * numbers::kPi));
-  // fmod always matches the sign of the first argument, so fmod(angle, 2π)
-  // returns a value in the range (-2π, 2π).  We want [0, 2π), so wrap negative
-  // values back to positive.
-  if (radians < 0.f) {
-    radians += static_cast<float>(2.0 * numbers::kPi);
-    // If fmod returned a sufficiently small negative number, then adding 2π
-    // will give us a result exactly equal to 2π, due to float rounding.
-    // However, Angle::Normalized() promises to return a value strictly less
-    // than 2π, so we should normalize to zero in this case.
-    if (radians == static_cast<float>(2.0 * numbers::kPi)) {
-      radians = 0.f;
-    }
-  }
-  return Angle::Radians(radians);
-}
-
 Angle Angle::NormalizedAboutZero() const {
   float radians =
       std::fmod(ValueInRadians(), static_cast<float>(2.0 * numbers::kPi));

ink/geometry/angle.h

@@ -19,6 +19,7 @@
 #include <cstdlib>
 #include <string>
 
+#include "ink/geometry/internal/modulo.h"
 #include "ink/types/numbers.h"
 
 namespace ink {
@@ -197,6 +198,11 @@ inline Angle& operator/=(Angle& lhs, float rhs) {
   return lhs;
 }
 
+inline Angle Angle::Normalized() const {
+  return Angle::Radians(geometry_internal::FloatModulo(
+      ValueInRadians(), static_cast<float>(2.0 * numbers::kPi)));
+}
+
 }  // namespace ink
 
 #endif  // INK_GEOMETRY_ANGLE_H_

ink/geometry/internal/BUILD.bazel

@@ -133,6 +133,25 @@ cc_test(
     ],
 )
 
+cc_library(
+    name = "modulo",
+    srcs = ["modulo.cc"],
+    hdrs = ["modulo.h"],
+    deps = [
+        "@com_google_absl//absl/log:absl_check",
+    ],
+)
+
+cc_test(
+    name = "modulo_test",
+    srcs = ["modulo_test.cc"],
+    deps = [
+        ":modulo",
+        "@com_google_fuzztest//fuzztest",
+        "@com_google_fuzztest//fuzztest:fuzztest_gtest_main",
+    ],
+)
+
 cc_library(
     name = "circle",
     srcs = ["circle.cc"],

ink/geometry/internal/modulo.cc

@@ -0,0 +1,42 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ink/geometry/internal/modulo.h"
+
+#include <cmath>
+
+#include "absl/log/absl_check.h"
+
+namespace ink::geometry_internal {
+
+float FloatModulo(float a, float b) {
+  ABSL_DCHECK(std::isfinite(b) && b > 0.f);
+  float result = std::fmodf(a, b);
+  // `fmodf` always matches the sign of the first argument, so `fmodf(a, b)`
+  // returns a value in the range (-b, b).  We want [0, b), so wrap negative
+  // values back to positive.
+  if (result < 0.f) {
+    result += b;
+    // If `fmodf` returned a sufficiently small negative number, then adding `b`
+    // will give us a result exactly equal to `b`, due to float rounding.
+    // However, `FloatModulo` promises to return a value strictly less than `b`,
+    // so we should return zero in this case.
+    if (result == b) {
+      result = 0.f;
+    }
+  }
+  return result;
+}
+
+}  // namespace ink::geometry_internal

ink/geometry/internal/modulo.h

@@ -0,0 +1,28 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INK_GEOMETRY_INTERNAL_MODULO_H_
+#define INK_GEOMETRY_INTERNAL_MODULO_H_
+
+namespace ink::geometry_internal {
+
+// Returns `a` mod `b`, with the result being in the range [0, `b`). This is
+// different from `std::fmodf`, which returns a negative result if `a` is
+// negative. `b` must be finite and strictly greater than zero. Returns NaN if
+// `a` is infinite or NaN.
+float FloatModulo(float a, float b);
+
+}  // namespace ink::geometry_internal
+
+#endif  // INK_GEOMETRY_INTERNAL_MODULO_H_

ink/geometry/internal/modulo_test.cc

@@ -0,0 +1,71 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ink/geometry/internal/modulo.h"
+
+#include <cmath>
+#include <limits>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "fuzztest/fuzztest.h"
+
+namespace ink::geometry_internal {
+namespace {
+
+using ::testing::AllOf;
+using ::testing::Ge;
+using ::testing::IsNan;
+using ::testing::Lt;
+
+constexpr float kInf = std::numeric_limits<float>::infinity();
+const float kNaN = std::nanf("");
+
+fuzztest::Domain<float> FinitePositiveFloat() {
+  return fuzztest::Filter([](float b) { return std::isfinite(b); },
+                          fuzztest::Positive<float>());
+}
+
+TEST(ModuloTest, FloatModulo) {
+  EXPECT_FLOAT_EQ(FloatModulo(0, 1), 0);
+  EXPECT_FLOAT_EQ(FloatModulo(0.75, 1), 0.75);
+  EXPECT_FLOAT_EQ(FloatModulo(1, 1), 0);
+  EXPECT_FLOAT_EQ(FloatModulo(1.25, 1), 0.25);
+  EXPECT_FLOAT_EQ(FloatModulo(-0.25, 1), 0.75);
+  EXPECT_FLOAT_EQ(FloatModulo(-1.5, 1), 0.5);
+
+  EXPECT_FLOAT_EQ(FloatModulo(0, 10), 0);
+  EXPECT_FLOAT_EQ(FloatModulo(7.5, 10), 7.5);
+  EXPECT_FLOAT_EQ(FloatModulo(10, 10), 0);
+  EXPECT_FLOAT_EQ(FloatModulo(12.5, 10), 2.5);
+  EXPECT_FLOAT_EQ(FloatModulo(-2.5, 10), 7.5);
+  EXPECT_FLOAT_EQ(FloatModulo(-15, 10), 5);
+}
+
+void FloatModuloOfNonFiniteIsNan(float b) {
+  EXPECT_THAT(FloatModulo(kInf, b), IsNan());
+  EXPECT_THAT(FloatModulo(-kInf, b), IsNan());
+  EXPECT_THAT(FloatModulo(kNaN, b), IsNan());
+}
+FUZZ_TEST(ModuloTest, FloatModuloOfNonFiniteIsNan)
+    .WithDomains(FinitePositiveFloat());
+
+void FloatModuloIsStrictlyInRange(float a, float b) {
+  EXPECT_THAT(FloatModulo(a, b), AllOf(Ge(0.f), Lt(b)));
+}
+FUZZ_TEST(ModuloTest, FloatModuloIsStrictlyInRange)
+    .WithDomains(fuzztest::Finite<float>(), FinitePositiveFloat());
+
+}  // namespace
+}  // namespace ink::geometry_internal