Fix dropout scale construction for fixed-point types

scale() previously did static_cast<ValueType>(double), which for QValue
invokes the raw-bits constructor — so a 50% dropout on Q8.8 produced a
scale of ~0.008 (raw=2) instead of 2.0 (raw=512), silently corrupting
all fixed-point training runs that used dropout.

Construct the scale from integers via a SFINAE-dispatched fromInteger
helper: cast for floating-point types, (FixedPart, FractionalPart)
constructor for QValue. The forward/backward logic is unchanged.

Restored the fixed-point dropout training tests removed in the previous
commit; they now pass and pin down the corrected behavior.

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

Author: danmcleran

cpp/dropout.hpp

@@ -24,6 +24,7 @@
 
 #include <cstddef>
 #include <cstdlib>
+#include <type_traits>
 
 namespace tinymind {
     /**
@@ -157,11 +158,30 @@ namespace tinymind {
             }
         }
 
+        // Construct a ValueType representing the integer v. For floating-point
+        // types this is just a cast; for QValue the (fixed, fractional)
+        // constructor is required because QValue(int) treats its argument as
+        // the raw fixed-point bit pattern, not the value.
+        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 scale()
         {
             // 1 / (1 - p) where p = DropoutPercent / 100
             // = 100 / (100 - DropoutPercent)
-            static const ValueType s = static_cast<ValueType>(100.0 / (100.0 - static_cast<double>(DropoutPercent)));
+            static const ValueType s = fromInteger(100)
+                                     / fromInteger(100 - static_cast<int>(DropoutPercent));
             return s;
         }
 

unit_test/nn/nn_unit_test.cpp

@@ -4594,33 +4594,65 @@ BOOST_AUTO_TEST_CASE(test_case_dropout_fixed_point_inference_passthrough)
     }
 }
 
+BOOST_AUTO_TEST_CASE(test_case_dropout_fixed_point_training_scaling)
+{
+    // Q8.8 with 50% dropout: survivors must scale by exactly 2.0 = raw 512.
+    typedef tinymind::QValue<8, 8, true, tinymind::RoundUpPolicy> ValueType;
+    srand(RANDOM_SEED);
+    tinymind::Dropout<ValueType, 8, 50> dropout;
+    dropout.setTraining(true);
+
+    ValueType input[8];
+    for (size_t i = 0; i < 8; ++i)
+    {
+        input[i] = ValueType(1, 0); // 1.0
+    }
+    ValueType output[8];
+    dropout.forward(input, output);
+
+    for (size_t i = 0; i < 8; ++i)
+    {
+        if (dropout.getMask(i))
+        {
+            BOOST_TEST(output[i].getValue() == ValueType(2, 0).getValue());
+        }
+        else
+        {
+            BOOST_TEST(output[i].getValue() == 0);
+        }
+    }
+}
+
 BOOST_AUTO_TEST_CASE(test_case_dropout_high_rate_boundary)
 {
     // 99% dropout is the largest legal rate (the layer static_asserts < 100).
-    // Scale = 100, so survivors multiply by 100. Verified on double here;
-    // see notes in dropout.hpp for the fixed-point scale-construction issue.
+    // Scale = 100. Use Q16.16 since 100 doesn't fit in Q8.8's signed fixed range.
+    typedef tinymind::QValue<16, 16, true, tinymind::RoundUpPolicy> ValueType;
     srand(RANDOM_SEED);
-    tinymind::Dropout<double, 16, 99> dropout;
+    tinymind::Dropout<ValueType, 16, 99> dropout;
     dropout.setTraining(true);
 
-    double input[16];
+    ValueType input[16];
     for (size_t i = 0; i < 16; ++i)
     {
-        input[i] = 1.0;
+        input[i] = ValueType(1, 0);
     }
-    double output[16];
+    ValueType output[16];
     dropout.forward(input, output);
 
+    const ValueType expectedKept(100, 0);
     bool sawDropped = false;
     for (size_t i = 0; i < 16; ++i)
     {
         if (dropout.getMask(i))
         {
-            BOOST_TEST(std::fabs(output[i] - 100.0) < 1e-9);
+            // 1 LSB tolerance for Q16.16 division rounding in scale construction.
+            const auto delta = output[i].getValue() - expectedKept.getValue();
+            BOOST_TEST(std::abs(delta) <= 1);
         }
         else
         {
-            BOOST_TEST(output[i] == 0.0);
+            BOOST_TEST(output[i].getValue() == 0);
             sawDropped = true;
         }
     }