Cover 2D pool backward paths and linearInterpolation

The forward path of AvgPool2D / GlobalAvgPool2D was tested, but the
backward path was not — and it shares the same divisor() helper that
silently produced wrong results in fixed-point before the previous
fix. Adds:

- AvgPool2D::backward in double and Q8.8 (validates that uniform
  upstream deltas distribute as delta/WindowArea per cell)
- GlobalAvgPool2D::backward in double and Q8.8
- MaxPool2D::backward in Q8.8 (argmax routing of gradients)
- linearInterpolation direct tests: endpoint cases on double and Q8.8,
  and the x1==x0 divide-by-zero short-circuit at interpolate.hpp:29

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

Author: danmcleran

unit_test/lookuptable/lookuptable_unit_test.cpp

@@ -33,6 +33,7 @@
 #include <limits>
 
 #include "qformat.hpp"
+#include "interpolate.hpp"
 #include "lookupTable.hpp"
 #include "sigmoid.hpp"
 #include "tanh.hpp"
@@ -136,6 +137,39 @@ void verifyAccuracy(const Table& table, double (*ref)(double),
 
 BOOST_AUTO_TEST_SUITE(test_suite_lookuptable)
 
+// ----- linearInterpolation (interpolate.hpp) ---------------------------------
+// Two branches: x1 == x0 short-circuit, and the linear path.
+
+BOOST_AUTO_TEST_CASE(linear_interpolation_endpoints_double)
+{
+    using tinymind::linearInterpolation;
+    BOOST_CHECK_CLOSE(linearInterpolation<double>(0.0, 0.0, 1.0, 10.0, 20.0), 10.0, 1e-9);
+    BOOST_CHECK_CLOSE(linearInterpolation<double>(1.0, 0.0, 1.0, 10.0, 20.0), 20.0, 1e-9);
+    BOOST_CHECK_CLOSE(linearInterpolation<double>(0.5, 0.0, 1.0, 10.0, 20.0), 15.0, 1e-9);
+}
+
+BOOST_AUTO_TEST_CASE(linear_interpolation_degenerate_returns_y0)
+{
+    // x1 == x0 hits the divide-by-zero guard at interpolate.hpp:29 and must
+    // return y0 unchanged, not divide by zero.
+    using tinymind::linearInterpolation;
+    BOOST_CHECK_CLOSE(linearInterpolation<double>(5.0, 1.0, 1.0, 7.0, 99.0), 7.0, 1e-9);
+}
+
+BOOST_AUTO_TEST_CASE(linear_interpolation_fixed_point)
+{
+    // Same boundary checks in Q8.8.
+    using tinymind::linearInterpolation;
+    using Q = QValue<8, 8, true>;
+    const Q result = linearInterpolation<Q>(Q(0, 128),  // x = 0.5
+                                            Q(0, 0),    // x0 = 0
+                                            Q(1, 0),    // x1 = 1
+                                            Q(0, 0),    // y0 = 0
+                                            Q(1, 0));   // y1 = 1
+    // Expect 0.5 = raw 128.
+    BOOST_CHECK_EQUAL(result.getValue(), Q(0, 128).getValue());
+}
+
 // ----- Branch coverage on LookupTable<Q>::getValue ---------------------------
 //
 // All five reachable branches in cpp/lookupTable.hpp:35-89 are exercised on a

unit_test/nn/nn_unit_test.cpp

@@ -6804,6 +6804,112 @@ BOOST_AUTO_TEST_CASE(test_case_globalavgpool2d_fixed_point)
     BOOST_TEST(output[1].getValue() == ValueType(3, 0).getValue());
 }
 
+BOOST_AUTO_TEST_CASE(test_case_avgpool2d_backward)
+{
+    // 4x4 single-channel, 2x2 window stride 2. Each output cell distributes
+    // its delta uniformly across the 4 input cells in its window: grad = d/4.
+    tinymind::AvgPool2D<double, 4, 4, 1, 2, 2, 2, 2> pool;
+    double outputDeltas[4] = {4.0, 8.0, 12.0, 16.0};
+    double inputDeltas[16];
+    pool.backward(outputDeltas, inputDeltas);
+
+    // Top-left window (output 0): grad = 1.0 across 4 cells.
+    BOOST_TEST(std::fabs(inputDeltas[0] - 1.0) < 1e-9);
+    BOOST_TEST(std::fabs(inputDeltas[1] - 1.0) < 1e-9);
+    BOOST_TEST(std::fabs(inputDeltas[4] - 1.0) < 1e-9);
+    BOOST_TEST(std::fabs(inputDeltas[5] - 1.0) < 1e-9);
+    // Top-right window (output 1): grad = 2.0
+    BOOST_TEST(std::fabs(inputDeltas[2] - 2.0) < 1e-9);
+    BOOST_TEST(std::fabs(inputDeltas[3] - 2.0) < 1e-9);
+    BOOST_TEST(std::fabs(inputDeltas[6] - 2.0) < 1e-9);
+    BOOST_TEST(std::fabs(inputDeltas[7] - 2.0) < 1e-9);
+    // Bot-right window (output 3): grad = 4.0
+    BOOST_TEST(std::fabs(inputDeltas[10] - 4.0) < 1e-9);
+    BOOST_TEST(std::fabs(inputDeltas[15] - 4.0) < 1e-9);
+}
+
+BOOST_AUTO_TEST_CASE(test_case_avgpool2d_backward_fixed_point)
+{
+    // Same input pattern as above in Q8.8: confirms divisor() is correct on
+    // the backward path, not just forward.
+    typedef tinymind::QValue<8, 8, true, tinymind::RoundUpPolicy> ValueType;
+    tinymind::AvgPool2D<ValueType, 4, 4, 1, 2, 2, 2, 2> pool;
+    ValueType outputDeltas[4] = {ValueType(4, 0), ValueType(8, 0), ValueType(12, 0), ValueType(16, 0)};
+    ValueType inputDeltas[16];
+    pool.backward(outputDeltas, inputDeltas);
+
+    BOOST_TEST(inputDeltas[0].getValue()  == ValueType(1, 0).getValue());
+    BOOST_TEST(inputDeltas[5].getValue()  == ValueType(1, 0).getValue());
+    BOOST_TEST(inputDeltas[3].getValue()  == ValueType(2, 0).getValue());
+    BOOST_TEST(inputDeltas[10].getValue() == ValueType(4, 0).getValue());
+    BOOST_TEST(inputDeltas[15].getValue() == ValueType(4, 0).getValue());
+}
+
+BOOST_AUTO_TEST_CASE(test_case_globalavgpool2d_backward)
+{
+    // GAP backward distributes each output delta uniformly across its
+    // spatial extent (H*W positions per channel).
+    tinymind::GlobalAvgPool2D<double, 3, 3, 2> gap;
+    double outputDeltas[2] = {9.0, 18.0};  // chosen so per-cell grad is 1.0 and 2.0
+    double inputDeltas[18];
+    gap.backward(outputDeltas, inputDeltas);
+
+    for (size_t i = 0; i < 9; ++i)
+    {
+        BOOST_TEST(std::fabs(inputDeltas[i * 2 + 0] - 1.0) < 1e-9);
+        BOOST_TEST(std::fabs(inputDeltas[i * 2 + 1] - 2.0) < 1e-9);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_case_globalavgpool2d_backward_fixed_point)
+{
+    typedef tinymind::QValue<8, 8, true, tinymind::RoundUpPolicy> ValueType;
+    tinymind::GlobalAvgPool2D<ValueType, 3, 3, 2> gap;
+    ValueType outputDeltas[2] = {ValueType(9, 0), ValueType(18, 0)};
+    ValueType inputDeltas[18];
+    gap.backward(outputDeltas, inputDeltas);
+
+    for (size_t i = 0; i < 9; ++i)
+    {
+        BOOST_TEST(inputDeltas[i * 2 + 0].getValue() == ValueType(1, 0).getValue());
+        BOOST_TEST(inputDeltas[i * 2 + 1].getValue() == ValueType(2, 0).getValue());
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_case_maxpool2d_backward_fixed_point)
+{
+    // Argmax-routed gradients: only the position holding each max receives
+    // the upstream delta. Other positions stay zero.
+    typedef tinymind::QValue<8, 8, true, tinymind::RoundUpPolicy> ValueType;
+    tinymind::MaxPool2D<ValueType, 4, 4, 1, 2, 2, 2, 2> pool;
+    ValueType input[16];
+    const int values[16] = {
+        1, 3, 2, 4,
+        5, 7, 6, 8,
+        9, 11, 10, 12,
+        13, 15, 14, 16
+    };
+    for (size_t i = 0; i < 16; ++i) input[i] = ValueType(values[i], 0);
+
+    ValueType output[4];
+    pool.forward(input, output);  // populates argmax indices
+
+    ValueType outputDeltas[4] = {ValueType(1, 0), ValueType(1, 0), ValueType(1, 0), ValueType(1, 0)};
+    ValueType inputDeltas[16];
+    pool.backward(outputDeltas, inputDeltas);
+
+    typename ValueType::FullWidthValueType sum = 0;
+    size_t hits = 0;
+    for (size_t i = 0; i < 16; ++i)
+    {
+        sum += inputDeltas[i].getValue();
+        if (inputDeltas[i].getValue() != 0) ++hits;
+    }
+    // Exactly four argmax positions, each receiving raw=256 (= 1.0).
+    BOOST_TEST(hits == 4u);
+    BOOST_TEST(sum == 4 * ValueType(1, 0).getValue());
+}
+
 // ============================================================
 // Benchmark harness tests
 // ============================================================