fix: add flat indexing methods to TensorBase and fix tensor access patterns

Add GetFlat/SetFlat methods to TensorBase for accessing tensor data by
linear index, fixing test failures in gradient correctness tests that
were using single-integer indexing on multi-dimensional tensors.

- Add GetFlat(int flatIndex) and SetFlat(int flatIndex, T value) to TensorBase
- Fix GumbelSoftmax, TaylorSoftmax, and Pad methods in TensorOperations.cs
- Update GradientCorrectnessTests to use flat indexing helper methods

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: franklinic

src/AiDotNet.Tensors/LinearAlgebra/TensorBase.cs

@@ -259,6 +259,40 @@ internal Span<T> AsWritableSpan()
         return _data.AsWritableSpan();
     }
 
+    /// <summary>
+    /// Gets the value at a flat (linear) index in the underlying data.
+    /// </summary>
+    /// <param name="flatIndex">The flat index (0 to Length-1).</param>
+    /// <returns>The value at the specified flat index.</returns>
+    /// <remarks>
+    /// <para><b>For Beginners:</b> This allows accessing tensor elements using a single
+    /// index that treats the tensor as a 1D array. The flat index corresponds to
+    /// row-major ordering where the last dimension varies fastest.</para>
+    /// </remarks>
+    public T GetFlat(int flatIndex)
+    {
+        if (flatIndex < 0 || flatIndex >= Length)
+            throw new ArgumentOutOfRangeException(nameof(flatIndex), "Flat index is out of range.");
+        return _data[flatIndex];
+    }
+
+    /// <summary>
+    /// Sets the value at a flat (linear) index in the underlying data.
+    /// </summary>
+    /// <param name="flatIndex">The flat index (0 to Length-1).</param>
+    /// <param name="value">The value to set.</param>
+    /// <remarks>
+    /// <para><b>For Beginners:</b> This allows setting tensor elements using a single
+    /// index that treats the tensor as a 1D array. The flat index corresponds to
+    /// row-major ordering where the last dimension varies fastest.</para>
+    /// </remarks>
+    public void SetFlat(int flatIndex, T value)
+    {
+        if (flatIndex < 0 || flatIndex >= Length)
+            throw new ArgumentOutOfRangeException(nameof(flatIndex), "Flat index is out of range.");
+        _data[flatIndex] = value;
+    }
+
     /// <summary>
     /// Returns a string representation of the tensor.
     /// </summary>

src/Autodiff/TensorOperations.cs

@@ -2491,7 +2491,7 @@ public static ComputationNode<T> Pad(ComputationNode<T> a, int[,] padWidth, T? v
             // Initialize with pad value
             for (int i = 0; i < result.Length; i++)
             {
-                result[i] = padValue;
+                result.SetFlat(i, padValue);
             }
             // Copy input data to center
             for (int r = 0; r < inputRows; r++)
@@ -2546,7 +2546,7 @@ void BackwardFunction(Tensor<T> gradient)
             // Initialize with pad value
             for (int i = 0; i < result.Length; i++)
             {
-                result[i] = padValue;
+                result.SetFlat(i, padValue);
             }
 
             // Copy input data to appropriate location
@@ -7515,15 +7515,15 @@ public static ComputationNode<T> GumbelSoftmax(ComputationNode<T> logits, double
             var u = random.NextDouble();
             u = Math.Max(u, eps);
             u = Math.Min(u, 1 - eps);
-            gumbel[i] = numOps.FromDouble(-Math.Log(-Math.Log(u)));
+            gumbel.SetFlat(i, numOps.FromDouble(-Math.Log(-Math.Log(u))));
         }
 
         // Compute soft samples: softmax((logits + gumbel) / temperature)
         var tempTensor = new Tensor<T>(shape);
         for (int i = 0; i < tempTensor.Length; i++)
         {
-            var val = numOps.Add(logits.Value[i], gumbel[i]);
-            tempTensor[i] = numOps.Divide(val, numOps.FromDouble(temperature));
+            var val = numOps.Add(logits.Value.GetFlat(i), gumbel.GetFlat(i));
+            tempTensor.SetFlat(i, numOps.Divide(val, numOps.FromDouble(temperature)));
         }
 
         // Apply softmax along last axis
@@ -7541,18 +7541,18 @@ public static ComputationNode<T> GumbelSoftmax(ComputationNode<T> logits, double
             for (int b = 0; b < batchSize; b++)
             {
                 int maxIdx = 0;
-                T maxVal = softResult[b * lastDim];
+                T maxVal = softResult.GetFlat(b * lastDim);
                 for (int i = 1; i < lastDim; i++)
                 {
-                    if (numOps.GreaterThan(softResult[b * lastDim + i], maxVal))
+                    if (numOps.GreaterThan(softResult.GetFlat(b * lastDim + i), maxVal))
                     {
-                        maxVal = softResult[b * lastDim + i];
+                        maxVal = softResult.GetFlat(b * lastDim + i);
                         maxIdx = i;
                     }
                 }
                 for (int i = 0; i < lastDim; i++)
                 {
-                    hardResult[b * lastDim + i] = i == maxIdx ? numOps.One : numOps.Zero;
+                    hardResult.SetFlat(b * lastDim + i, i == maxIdx ? numOps.One : numOps.Zero);
                 }
             }
 
@@ -9112,7 +9112,7 @@ public static ComputationNode<T> TaylorSoftmax(ComputationNode<T> a, int order =
                 for (int i = 0; i < axisSize; i++)
                 {
                     int flatIdx = outer * axisSize * innerSize + i * innerSize + inner;
-                    var x = a.Value[flatIdx];
+                    var x = a.Value.GetFlat(flatIdx);
                     var taylorExp = numOps.One; // Start with 1
                     var xPower = numOps.One;
 
@@ -9128,15 +9128,15 @@ public static ComputationNode<T> TaylorSoftmax(ComputationNode<T> a, int order =
                         ? taylorExp
                         : numOps.FromDouble(1e-10);
 
-                    taylorExpValues[flatIdx] = taylorExp;
+                    taylorExpValues.SetFlat(flatIdx, taylorExp);
                     expSum = numOps.Add(expSum, taylorExp);
                 }
 
                 // Normalize
                 for (int i = 0; i < axisSize; i++)
                 {
                     int flatIdx = outer * axisSize * innerSize + i * innerSize + inner;
-                    result[flatIdx] = numOps.Divide(taylorExpValues[flatIdx], expSum);
+                    result.SetFlat(flatIdx, numOps.Divide(taylorExpValues.GetFlat(flatIdx), expSum));
                 }
             }
         }
@@ -9163,7 +9163,7 @@ void BackwardFunction(Tensor<T> gradient)
                         for (int i = 0; i < capturedAxisSize; i++)
                         {
                             int flatIdx = outer * capturedAxisSize * capturedInnerSize + i * capturedInnerSize + inner;
-                            expSum = numOps.Add(expSum, taylorExpValues[flatIdx]);
+                            expSum = numOps.Add(expSum, taylorExpValues.GetFlat(flatIdx));
                         }
 
                         // Softmax-style Jacobian: s_i * (δ_ij - s_j)
@@ -9172,19 +9172,19 @@ void BackwardFunction(Tensor<T> gradient)
                         {
                             int flatIdx = outer * capturedAxisSize * capturedInnerSize + i * capturedInnerSize + inner;
                             dotProduct = numOps.Add(dotProduct,
-                                numOps.Multiply(gradient[flatIdx], result[flatIdx]));
+                                numOps.Multiply(gradient.GetFlat(flatIdx), result.GetFlat(flatIdx)));
                         }
 
                         for (int i = 0; i < capturedAxisSize; i++)
                         {
                             int flatIdx = outer * capturedAxisSize * capturedInnerSize + i * capturedInnerSize + inner;
                             // Softmax gradient part: s_i * (grad_i - dot(grad, s))
-                            var softmaxGrad = numOps.Multiply(result[flatIdx],
-                                numOps.Subtract(gradient[flatIdx], dotProduct));
+                            var softmaxGrad = numOps.Multiply(result.GetFlat(flatIdx),
+                                numOps.Subtract(gradient.GetFlat(flatIdx), dotProduct));
 
                             // Taylor exp derivative: d/dx[1 + x + x²/2! + ... + x^n/n!] = 1 + x + ... + x^(n-1)/(n-1)!
                             // This is Taylor_{n-1}(x) for exp
-                            var x = a.Value[flatIdx];
+                            var x = a.Value.GetFlat(flatIdx);
                             var taylorExpDeriv = numOps.One;
                             var xPower = numOps.One;
                             for (int n = 1; n < capturedOrder; n++)
@@ -9197,9 +9197,9 @@ void BackwardFunction(Tensor<T> gradient)
                             // For y_i = g(x_i) / sum_j(g(x_j)), the chain rule requires:
                             // grad_x_i = softmaxGrad * g'(x_i) / g(x_i)
                             // where g is the Taylor approximation of exp
-                            var gVal = taylorExpValues[flatIdx];
+                            var gVal = taylorExpValues.GetFlat(flatIdx);
                             var gPrimeOverG = numOps.Divide(taylorExpDeriv, gVal);
-                            gradA[flatIdx] = numOps.Multiply(softmaxGrad, gPrimeOverG);
+                            gradA.SetFlat(flatIdx, numOps.Multiply(softmaxGrad, gPrimeOverG));
                         }
                     }
                 }