diff --git a/motors/math.cc b/motors/math.cc
index 8441e97..3f505bc 100644
--- a/motors/math.cc
+++ b/motors/math.cc
@@ -6,31 +6,31 @@
 namespace motors {
 namespace math_internal {
 
-float sin_int_table[SinCosTableSize()];
-float cos_int_table[SinCosTableSize()];
-float sin_float_table[SinCosTableSize() + 1];
-float cos_float_table[SinCosTableSize() + 1];
+float sin_float_table[SinCosFloatTableSize() + 1];
+float cos_float_table[SinCosFloatTableSize() + 1];
+
+::std::array<GenericInitializer *, 10> global_initializers{};
 
 }  // namespace math_internal
 
-using math_internal::SinCosTableSize;
+using math_internal::SinCosFloatTableSize;
 
 __attribute__((cold)) void MathInit() {
-  for (uint32_t i = 0; i < SinCosTableSize(); ++i) {
-    const double int_theta =
-        ((static_cast<double>(i) + 0.5) / SinCosTableSize()) * 2.0 * M_PI;
-    math_internal::sin_int_table[i] = sin(int_theta);
-    math_internal::cos_int_table[i] = cos(int_theta);
-  }
-  for (uint32_t i = 0; i < SinCosTableSize() + 1; ++i) {
+  for (uint32_t i = 0; i < SinCosFloatTableSize() + 1; ++i) {
     const double float_theta =
         (static_cast<int32_t>(i) -
-         static_cast<int32_t>(SinCosTableSize() / 2)) *
+         static_cast<int32_t>(SinCosFloatTableSize() / 2)) *
         static_cast<double>(math_internal::FloatMaxMagnitude()) /
-        static_cast<double>(SinCosTableSize() / 2);
+        static_cast<double>(SinCosFloatTableSize() / 2);
     math_internal::sin_float_table[i] = sin(float_theta);
     math_internal::cos_float_table[i] = cos(float_theta);
   }
+  for (math_internal::GenericInitializer *initializer :
+       math_internal::global_initializers) {
+    if (initializer != nullptr) {
+      initializer->Initialize();
+    }
+  }
 }
 
 }  // namespace motors
diff --git a/motors/math.h b/motors/math.h
index 16cdf92..d7bbee4 100644
--- a/motors/math.h
+++ b/motors/math.h
@@ -3,6 +3,7 @@
 
 #include <limits.h>
 
+#include <array>
 #include <complex>
 #include <ratio>
 
@@ -23,7 +24,7 @@
 
 namespace math_internal {
 
-constexpr uint32_t SinCosTableSize() { return 4096; }
+constexpr uint32_t SinCosFloatTableSize() { return 2048; }
 
 constexpr float FloatMaxMagnitude() { return 1.0f; }
 
@@ -31,66 +32,146 @@
   return value == (1u << (Log2RoundUp(value) - 1));
 }
 
-static_assert(IsPowerOf2(SinCosTableSize()), "Tables need to be a power of 2");
+static_assert(IsPowerOf2(SinCosFloatTableSize()),
+              "Tables need to be a power of 2");
 
-extern float sin_int_table[SinCosTableSize()];
-extern float cos_int_table[SinCosTableSize()];
-extern float sin_float_table[SinCosTableSize() + 1];
-extern float cos_float_table[SinCosTableSize() + 1];
+extern float sin_float_table[SinCosFloatTableSize() + 1];
+extern float cos_float_table[SinCosFloatTableSize() + 1];
 
-template <class Rotation>
+template <class Rotation, int kTableSize>
 float FastTableLookupInt(uint32_t theta, const float *table) {
   static_assert(IsPowerOf2(Rotation::den),
                 "Denominator needs to be a power of 2");
 
   // Don't need to worry about the sizes of intermediates given this constraint.
   static_assert(
-      ConstexprMax<uint32_t>(Rotation::den, SinCosTableSize()) * Rotation::num <
+      ConstexprMax<uint32_t>(Rotation::den, kTableSize) * Rotation::num <
           UINT32_MAX,
       "Numerator and denominator are too big");
 
   // Rounding/truncating here isn't supported.
-  static_assert(Rotation::den <= SinCosTableSize(),
-                "Tables need to be bigger");
+  static_assert(Rotation::den <= kTableSize, "Tables need to be bigger");
 
   // Don't feel like thinking through the consequences of this not being true.
   static_assert(Rotation::num > 0 && Rotation::den > 0,
                 "Need a positive ratio");
 
-  constexpr uint32_t kDenominatorRatio = SinCosTableSize() / Rotation::den;
+  constexpr uint32_t kDenominatorRatio = kTableSize / Rotation::den;
 
   // These should always be true given the other constraints.
-  static_assert(kDenominatorRatio * Rotation::den == SinCosTableSize(),
+  static_assert(kDenominatorRatio * Rotation::den == kTableSize,
                 "Math is broken");
   static_assert(IsPowerOf2(kDenominatorRatio), "Math is broken");
 
   return table[(theta * kDenominatorRatio * Rotation::num +
                 kDenominatorRatio * Rotation::num / 2) %
-               SinCosTableSize()];
+               kTableSize];
 }
 
 inline float FastTableLookupFloat(float theta, const float *table) {
   static constexpr float kScalar =
-      (SinCosTableSize() / 2) / FloatMaxMagnitude();
+      (SinCosFloatTableSize() / 2) / FloatMaxMagnitude();
   const int index =
-      (SinCosTableSize() / 2) + static_cast<int32_t>(theta * kScalar);
+      (SinCosFloatTableSize() / 2) + static_cast<int32_t>(theta * kScalar);
   return table[index];
 }
 
+// A simple parent class for arranging to initialize all the templates.
+//
+// This will be lower overhead than ::std::function and also adds less
+// complicated stuff around static initialization time.
+class GenericInitializer {
+ public:
+  virtual void Initialize() = 0;
+
+ protected:
+  // Don't destroy instances via pointers to this type. Do it through subclass
+  // pointers instead.
+  ~GenericInitializer() = default;
+};
+
+// We build up this list at static construction time so we can call all the
+// contained objects in MathInit(). The contained pointers are not owned by this
+// list.
+//
+// This has to be big enough to hold all the different sizes of integer tables
+// somebody might use in one program. If it overflows, there will be a
+// __builtin_abort during static initialization.
+extern ::std::array<GenericInitializer *, 10> global_initializers;
+
+// Manages initializing and access to an integer table of a single size.
+template<int kTableSize>
+class SinCosIntTable {
+ public:
+  static const float *sin_int_table() {
+    // Empirically, this is enough to get GCC to actually instantiate and link
+    // in the variable, without any runtime overhead.
+    (void)add_my_initializer;
+    return &static_sin_int_table[0];
+  }
+  static const float *cos_int_table() {
+    (void)add_my_initializer;
+    return &static_cos_int_table[0];
+  }
+
+ private:
+  // An object which adds a MyInitializer to global_initializers at static
+  // construction time.
+  class AddMyInitializer {
+   public:
+    AddMyInitializer() {
+      static MyInitializer initializer;
+      for (size_t i = 0; i < global_initializers.size(); ++i) {
+        if (global_initializers[i] == nullptr) {
+          global_initializers[i] = &initializer;
+          return;
+        }
+      }
+      __builtin_trap();
+    }
+  };
+
+  class MyInitializer : public GenericInitializer {
+    void Initialize() override {
+      for (uint32_t i = 0; i < kTableSize; ++i) {
+        const double int_theta =
+            ((static_cast<double>(i) + 0.5) / kTableSize) * 2.0 * M_PI;
+        static_sin_int_table[i] = sin(int_theta);
+        static_cos_int_table[i] = cos(int_theta);
+      }
+    }
+  };
+
+  static AddMyInitializer add_my_initializer;
+
+  static float static_sin_int_table[kTableSize];
+  static float static_cos_int_table[kTableSize];
+};
+
+template <int kTableSize>
+typename SinCosIntTable<kTableSize>::AddMyInitializer
+    SinCosIntTable<kTableSize>::add_my_initializer;
+
+template <int kTableSize>
+float SinCosIntTable<kTableSize>::static_sin_int_table[kTableSize];
+template <int kTableSize>
+float SinCosIntTable<kTableSize>::static_cos_int_table[kTableSize];
+
 }  // namespace math_internal
 
-// All theta arguments to the float-based functions must be in [-0.2, 0.2].
-
+// theta must be in [-0.2, 0.2].
 inline float FastSinFloat(float theta) {
   return math_internal::FastTableLookupFloat(theta,
                                              math_internal::sin_float_table);
 }
 
+// theta must be in [-0.2, 0.2].
 inline float FastCosFloat(float theta) {
   return math_internal::FastTableLookupFloat(theta,
                                              math_internal::cos_float_table);
 }
 
+// theta must be in [-0.2, 0.2].
 inline ::std::complex<float> ImaginaryExpFloat(float theta) {
   return ::std::complex<float>(FastCosFloat(theta), FastSinFloat(theta));
 }
@@ -105,17 +186,22 @@
 // All theta arguments must be in [0, Rotation::den).
 //
 // All denominators must be powers of 2.
+//
+// kTableSize is the size table it will actually use. This must be a power of 2
+// >= Rotation::den. The default of Rotation::den makes the most sense, unless
+// multiple denominators are needed in the same program, in which case using the
+// biggest denominator for all of them will use the least memory.
 
-template<class Rotation>
+template<class Rotation, int kTableSize = Rotation::den>
 float FastSinInt(uint32_t theta) {
-  return math_internal::FastTableLookupInt<Rotation>(
-      theta, math_internal::sin_int_table);
+  return math_internal::FastTableLookupInt<Rotation, kTableSize>(
+      theta, math_internal::SinCosIntTable<kTableSize>::sin_int_table());
 }
 
-template<class Rotation>
+template <class Rotation, int kTableSize = Rotation::den>
 float FastCosInt(uint32_t theta) {
-  return math_internal::FastTableLookupInt<Rotation>(
-      theta, math_internal::cos_int_table);
+  return math_internal::FastTableLookupInt<Rotation, kTableSize>(
+      theta, math_internal::SinCosIntTable<kTableSize>::cos_int_table());
 }
 
 template<class Rotation>
@@ -124,6 +210,7 @@
                                FastSinInt<Rotation>(theta));
 }
 
+// This must be called before any of the other functions.
 void MathInit();
 
 }  // namespace motors
diff --git a/motors/math_test.cc b/motors/math_test.cc
index 06f168f..91100e8 100644
--- a/motors/math_test.cc
+++ b/motors/math_test.cc
@@ -13,16 +13,20 @@
     MathInit();
   }
 
-  template <class Rotation>
+  template <class Rotation, int kTableSize>
   void CheckSinCos() {
     static constexpr float kTolerance = 0.004;
+    SCOPED_TRACE("num=" + ::std::to_string(Rotation::num) + " den=" +
+                 ::std::to_string(Rotation::den) + " table_size=" +
+                 ::std::to_string(kTableSize));
     for (uint32_t theta = 0; theta < Rotation::den; ++theta) {
-      EXPECT_THAT(
-          FastSinInt<Rotation>(theta),
-          ::testing::FloatNear(sin(ThetaToFloat<Rotation>(theta)), kTolerance));
-      EXPECT_THAT(
-          FastCosInt<Rotation>(theta),
-          ::testing::FloatNear(cos(ThetaToFloat<Rotation>(theta)), kTolerance));
+      const float theta_float = ThetaToFloat<Rotation>(theta);
+      SCOPED_TRACE("theta=" + ::std::to_string(theta) + " theta_float=" +
+                   ::std::to_string(theta_float));
+      EXPECT_THAT((FastSinInt<Rotation, kTableSize>(theta)),
+                  ::testing::FloatNear(sin(theta_float), kTolerance));
+      EXPECT_THAT((FastCosInt<Rotation, kTableSize>(theta)),
+                  ::testing::FloatNear(cos(theta_float), kTolerance));
     }
   }
 
@@ -35,20 +39,40 @@
   }
 };
 
-TEST_F(SinCosIntTest, Numerator1) {
-  CheckSinCos<::std::ratio<1, 2>>();
-  CheckSinCos<::std::ratio<1, 4>>();
-  CheckSinCos<::std::ratio<1, 8>>();
-  CheckSinCos<::std::ratio<1, 128>>();
-  CheckSinCos<::std::ratio<1, 1024>>();
-  CheckSinCos<::std::ratio<1, 4096>>();
+TEST_F(SinCosIntTest, Numerator1DefaultTable) {
+  CheckSinCos<::std::ratio<1, 2>, 2>();
+  CheckSinCos<::std::ratio<1, 4>, 4>();
+  CheckSinCos<::std::ratio<1, 8>, 8>();
+  CheckSinCos<::std::ratio<1, 128>, 128>();
+  CheckSinCos<::std::ratio<1, 1024>, 1024>();
+  CheckSinCos<::std::ratio<1, 4096>, 4096>();
 }
 
-TEST_F(SinCosIntTest, Numerator5) {
-  CheckSinCos<::std::ratio<5, 8>>();
-  CheckSinCos<::std::ratio<5, 128>>();
-  CheckSinCos<::std::ratio<5, 1024>>();
-  CheckSinCos<::std::ratio<5, 4096>>();
+TEST_F(SinCosIntTest, Numerator1LargerTable) {
+  // Don't include silly things like a denominator of 2 and table size of 4
+  // here. It will fail because the slope varies so much that linearly
+  // interpolating between 0.5pi/1.5pi vs 0.25pi/0.75pi/1.25pi/1.75pi gives very
+  // different results.
+  CheckSinCos<::std::ratio<1, 2>, 4096>();
+  CheckSinCos<::std::ratio<1, 2>, 1024>();
+  CheckSinCos<::std::ratio<1, 8>, 4096>();
+  CheckSinCos<::std::ratio<1, 128>, 4096>();
+  CheckSinCos<::std::ratio<1, 1024>, 2048>();
+}
+
+TEST_F(SinCosIntTest, Numerator5DefaultTable) {
+  CheckSinCos<::std::ratio<5, 8>, 8>();
+  CheckSinCos<::std::ratio<5, 128>, 128>();
+  CheckSinCos<::std::ratio<5, 1024>, 1024>();
+  CheckSinCos<::std::ratio<5, 4096>, 4096>();
+}
+
+TEST_F(SinCosIntTest, Numerator5LargerTable) {
+  CheckSinCos<::std::ratio<5, 2>, 4096>();
+  CheckSinCos<::std::ratio<5, 2>, 1024>();
+  CheckSinCos<::std::ratio<5, 8>, 4096>();
+  CheckSinCos<::std::ratio<5, 128>, 4096>();
+  CheckSinCos<::std::ratio<5, 1024>, 2048>();
 }
 
 class SinCosFloatTest : public ::testing::Test {