Gate float and hosted-stdlib code paths for embedded builds

Introduce TINYMIND_ENABLE_FLOAT and TINYMIND_ENABLE_HOSTED_IO opt-in
macros (defaulting off, matching the existing TINYMIND_ENABLE_OSTREAMS
precedent) so that targets without an FPU or full C++ stdlib can
include the standalone composable layers without dragging in <cmath>,
<fstream>, or <vector>. Refactor SquareRootApproximation<QValue> to
integer Newton's method on the raw representation (Q-format identity
sqrt(r/2^N)*2^N == isqrt(r << N)), and replace ValueConverter<double,
QValue> usage in batchnorm/binary/ternary with a SFINAE-dispatched
fromInteger helper so percent-based hyperparams compile to pure
integer arithmetic on QValue. Add a unit_test/embedded smoke test
that builds a QValue-only pipeline with none of the new macros set,
acting as a regression guard against future hosted-only includes.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: danmcleran

.gitignore

@@ -14,3 +14,5 @@ unit_test/qformat/output/
 unit_test/qlearn/output/
 unit_test/nn/output/
 unit_test/kan/output/
+unit_test/lookuptable/output/
+unit_test/embedded/output/

Makefile

@@ -6,6 +6,7 @@ check :
 	cd unit_test/qformat && make clean && make && make run && cd -
 	cd unit_test/qlearn && make clean && make && make run && cd -
 	cd unit_test/lookuptable && make clean && make && make run && cd -
+	cd unit_test/embedded && make clean && make && make run && cd -
 	cd examples/xor && make clean && make && make release && cd -
 	cd examples/maze && make clean && make && make release && cd -
 	cd examples/dqn_maze && make clean && make && make release && cd -

cpp/adam.hpp

@@ -22,9 +22,14 @@
 
 #pragma once
 
-#include <cmath>
+#include "include/tinymind_platform.hpp"
+
 #include <cstddef>
 
+#if TINYMIND_ENABLE_FLOAT
+#include <cmath>
+#endif
+
 namespace tinymind {
     /**
      * No-op optimizer policy (default). Weight updates use SGD with momentum.
@@ -40,23 +45,44 @@ namespace tinymind {
 
     /**
      * Square root approximation for fixed-point QValue types.
-     * Converts to double via getValue(), computes sqrt, converts back.
+     *
+     * FPU-free integer Newton's method on the raw representation.
+     * Q-format identity: for value = r / 2^N, sqrt(value) in Q form is
+     * isqrt(r << N) — the integer sqrt of the raw value left-shifted by
+     * the number of fractional bits. The shift fits in the QValue's
+     * MultiplicationResultFullWidthValueType (always 2x the raw width)
+     * for any supported Q format. Negative inputs clamp to 0.
+     *
+     * Convergence: O(log W) iterations where W is the bit width of the
+     * intermediate, so ~6 iterations for 64-bit and ~7 for 128-bit.
      */
     template<typename ValueType>
     struct SquareRootApproximation
     {
-        typedef typename ValueType::FullWidthValueType FullWidthValueType;
+        typedef typename ValueType::FullWidthValueType                     FullWidthValueType;
+        typedef typename ValueType::MultiplicationResultFullWidthValueType WideType;
 
         static ValueType sqrt(const ValueType& value)
         {
-            static const double factor = std::pow(2.0, -1.0 * static_cast<double>(ValueType::NumberOfFractionalBits));
-            const double dval = static_cast<double>(value.getValue()) * factor;
-            const double result = std::sqrt(dval >= 0.0 ? dval : 0.0);
-            const FullWidthValueType rawResult = static_cast<FullWidthValueType>(result * static_cast<double>(1ULL << ValueType::NumberOfFractionalBits));
-            return ValueType(rawResult);
+            const FullWidthValueType raw = value.getValue();
+            if (raw <= static_cast<FullWidthValueType>(0))
+            {
+                return ValueType(static_cast<FullWidthValueType>(0));
+            }
+
+            const WideType n = static_cast<WideType>(raw) << ValueType::NumberOfFractionalBits;
+            WideType x = n;
+            WideType y = (x + static_cast<WideType>(1)) / static_cast<WideType>(2);
+            while (y < x)
+            {
+                x = y;
+                y = (x + n / x) / static_cast<WideType>(2);
+            }
+            return ValueType(static_cast<FullWidthValueType>(x));
         }
     };
 
+#if TINYMIND_ENABLE_FLOAT
     template<>
     struct SquareRootApproximation<float>
     {
@@ -74,6 +100,7 @@ namespace tinymind {
             return std::sqrt(value);
         }
     };
+#endif // TINYMIND_ENABLE_FLOAT
 
     /**
      * Adam optimizer policy for use with BackPropagationParent.
@@ -187,6 +214,7 @@ namespace tinymind {
         size_t mTimestep;
     };
 
+#if TINYMIND_ENABLE_FLOAT
     /**
      * Floating-point Adam optimizer with standard hyperparameters.
      * Uses double-precision constants directly instead of QValue constructors.
@@ -251,5 +279,6 @@ namespace tinymind {
         double mBeta2;
         double mEpsilon;
     };
+#endif // TINYMIND_ENABLE_FLOAT
 
 }

cpp/batchnorm.hpp

@@ -23,7 +23,7 @@
 #pragma once
 
 #include <cstddef>
-#include <cmath>
+#include <type_traits>
 
 #include "adam.hpp"
 #include "nnproperties.hpp"
@@ -221,35 +221,52 @@ namespace tinymind {
         ValueType mNormalized[Size];
         bool mTraining;
 
-        typedef ValueConverter<double, ValueType> Converter;
+        // Construct a ValueType representing the integer v. FPU-free for QValue:
+        // QValue(int) treats its argument as the raw fixed-point bit pattern,
+        // so we must use the (fixed, fractional) constructor instead.
+        template<typename T = ValueType>
+        static typename std::enable_if<std::is_floating_point<T>::value, T>::type
+        fromInteger(const int v)
+        {
+            return static_cast<T>(v);
+        }
+
+        template<typename T = ValueType>
+        static typename std::enable_if<!std::is_floating_point<T>::value, T>::type
+        fromInteger(const int v)
+        {
+            return T(static_cast<typename T::FixedPartFieldType>(v), 0u);
+        }
 
         static ValueType zero()
         {
-            static const ValueType z = Converter::convertToDestinationType(0.0);
+            static const ValueType z = fromInteger(0);
             return z;
         }
 
         static ValueType one()
         {
-            static const ValueType o = Converter::convertToDestinationType(1.0);
+            static const ValueType o = fromInteger(1);
             return o;
         }
 
         static ValueType sizeValue()
         {
-            static const ValueType s = Converter::convertToDestinationType(static_cast<double>(Size));
+            static const ValueType s = fromInteger(static_cast<int>(Size));
             return s;
         }
 
         static ValueType momentum()
         {
-            static const ValueType m = Converter::convertToDestinationType(static_cast<double>(MomentumPercent) / 100.0);
+            static const ValueType m = fromInteger(static_cast<int>(MomentumPercent))
+                                     / fromInteger(100);
             return m;
         }
 
         static ValueType epsilon()
         {
-            static const ValueType e = Converter::convertToDestinationType(static_cast<double>(EpsilonPercent) / 100.0);
+            static const ValueType e = fromInteger(static_cast<int>(EpsilonPercent))
+                                     / fromInteger(100);
             return e;
         }
 

cpp/binarylayer.hpp

@@ -24,6 +24,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <type_traits>
 
 #include "nnproperties.hpp"
 
@@ -341,29 +342,44 @@ namespace tinymind {
         ValueType mBias[OutputSize];
         ValueType mBiasGradients[OutputSize];
 
-        typedef ValueConverter<double, ValueType> Converter;
+        // Construct a ValueType representing the integer v. FPU-free for QValue:
+        // QValue(int) treats its argument as the raw fixed-point bit pattern,
+        // so we must use the (fixed, fractional) constructor instead.
+        template<typename T = ValueType>
+        static typename std::enable_if<std::is_floating_point<T>::value, T>::type
+        fromInteger(const int v)
+        {
+            return static_cast<T>(v);
+        }
+
+        template<typename T = ValueType>
+        static typename std::enable_if<!std::is_floating_point<T>::value, T>::type
+        fromInteger(const int v)
+        {
+            return T(static_cast<typename T::FixedPartFieldType>(v), 0u);
+        }
 
         static ValueType zero()
         {
-            static const ValueType z = Converter::convertToDestinationType(0.0);
+            static const ValueType z = fromInteger(0);
             return z;
         }
 
         static ValueType one()
         {
-            static const ValueType o = Converter::convertToDestinationType(1.0);
+            static const ValueType o = fromInteger(1);
             return o;
         }
 
         static ValueType negOne()
         {
-            static const ValueType n = Converter::convertToDestinationType(-1.0);
+            static const ValueType n = fromInteger(-1);
             return n;
         }
 
         static ValueType intToValue(const int32_t v)
         {
-            return Converter::convertToDestinationType(static_cast<double>(v));
+            return fromInteger(static_cast<int>(v));
         }
 
         static_assert(InputSize > 0, "Input size must be > 0.");

cpp/include/nnproperties.hpp

@@ -96,11 +96,20 @@
  * Total values = I*H + H + (L-1)*(H^2 + H) + H*O + O  (L hidden layers)
  */
 
+#include "tinymind_platform.hpp"
+
 #include <cstdint>
 #include <cstdlib>
+#include <cstdio>
+
+#if TINYMIND_ENABLE_FLOAT
+#include <cmath>
+#endif
+
+#if TINYMIND_ENABLE_HOSTED_IO
 #include <fstream>
 #include <vector>
-#include <cstdio>
+#endif
 
 namespace tinymind {
     template<typename SourceType>
@@ -118,6 +127,7 @@ namespace tinymind {
         }
     };
 
+#if TINYMIND_ENABLE_FLOAT
     template<>
     struct ValueParser<double>
     {
@@ -129,7 +139,7 @@ namespace tinymind {
             return atof(buffer);
         }
     };
-    
+
     template<>
     struct ValueParser<float>
     {
@@ -141,6 +151,7 @@ namespace tinymind {
             return static_cast<float>(atof(buffer));
         }
     };
+#endif // TINYMIND_ENABLE_FLOAT
 
     template<typename SourceType, typename DestinationType>
     struct ValueConverter
@@ -151,6 +162,7 @@ namespace tinymind {
         }
     };
 
+#if TINYMIND_ENABLE_FLOAT
     template<typename DestinationType>
     struct ValueConverter<double, DestinationType>
     {
@@ -170,7 +182,7 @@ namespace tinymind {
     {
         static double convertToDestinationType(const SourceType& value)
         {
-            static const double factor = pow(2, -1.0 * SourceType::NumberOfFractionalBits);
+            static const double factor = std::pow(2.0, -1.0 * SourceType::NumberOfFractionalBits);
             const double result = (static_cast<double>(value.getValue()) * factor);
 
             return result;
@@ -205,7 +217,7 @@ namespace tinymind {
     {
         static float convertToDestinationType(const SourceType& value)
         {
-            static const float factor = pow(2, -1.0f * SourceType::NumberOfFractionalBits);
+            static const float factor = std::pow(2.0f, -1.0f * SourceType::NumberOfFractionalBits);
             const float result = (static_cast<float>(value.getValue()) * factor);
 
             return result;
@@ -220,7 +232,9 @@ namespace tinymind {
             return value;
         }
     };
+#endif // TINYMIND_ENABLE_FLOAT
 
+#if TINYMIND_ENABLE_HOSTED_IO
     template<typename NeuralNetworkType>
     struct NetworkPropertiesFileManager
     {
@@ -776,4 +790,5 @@ namespace tinymind {
             }
         }
     };
+#endif // TINYMIND_ENABLE_HOSTED_IO
 }

cpp/include/tinymind_platform.hpp

@@ -0,0 +1,55 @@
+/**
+* Copyright (c) 2026 Dan McLeran
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in all
+* copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*/
+
+#pragma once
+
+/*
+ * Platform feature gates for TinyMind.
+ *
+ * All TINYMIND_ENABLE_* macros default to 0 so that a freestanding embedded
+ * build (no FPU, no full C++ stdlib) compiles out of the box. Hosted users
+ * opt in via -DTINYMIND_ENABLE_FLOAT=1, etc.
+ *
+ * TINYMIND_ENABLE_OSTREAMS  - <ostream> support in qformat.hpp and other
+ *                             debug-printing paths.
+ * TINYMIND_ENABLE_FLOAT     - float/double-typed code paths: Adam/RMSprop
+ *                             float optimizers, Xavier initializer, and the
+ *                             float/double specializations of ValueParser /
+ *                             ValueConverter in nnproperties.hpp. These
+ *                             paths call <cmath> functions (std::sqrt,
+ *                             std::pow) that require an FPU or softfp.
+ * TINYMIND_ENABLE_HOSTED_IO - File I/O serialization in nnproperties.hpp
+ *                             (NetworkPropertiesFileManager and friends),
+ *                             which pulls in <fstream> and <vector>.
+ */
+
+#ifndef TINYMIND_ENABLE_OSTREAMS
+#define TINYMIND_ENABLE_OSTREAMS 0
+#endif
+
+#ifndef TINYMIND_ENABLE_FLOAT
+#define TINYMIND_ENABLE_FLOAT 0
+#endif
+
+#ifndef TINYMIND_ENABLE_HOSTED_IO
+#define TINYMIND_ENABLE_HOSTED_IO 0
+#endif