fix(asanyarray,where): pure-float object[] promotion + hot-path short-circuits

Second-round code review caught one real bug and several minor efficiency issues.

1. Fix: FindCommonNumericType promoted pure-float object[] to double

   np.asanyarray(new object[]{1.5f, 2.5f}) returned Double instead of Single.
   Root cause: the early-exit `if (hasDouble || hasFloat) return typeof(double)`
   fired before the `uniqueCount == 1` check that preserves the original dtype.
   Removing the hasFloat arm lets the general path handle it:
   - Pure float32 -> uniqueCount == 1 -> returns firstType (Single)  -- matches NumPy
   - int + float32 -> _FindCommonType_Scalar -> returns Double -- matches NumPy NEP50
   - Pure float64 -> unchanged (still Double)
   - decimal-wins-everything early exit preserved.

   Two regression tests added:
   - ObjectArray_AllFloat_PreservesSingle
   - ObjectArray_MixedIntAndFloat32_PromotesToDouble

2. Perf: skip type promotion in np.where when x.dtype == y.dtype

   Previously _FindCommonType(x, y) always ran, even when both operands shared a
   dtype. Short-circuit to x.GetTypeCode in that case, saving one dict lookup +
   two astype traversals per call. The NEP50 lookup still runs when dtypes
   differ, preserving scalar+array promotion semantics.

3. Perf: skip broadcast_arrays when all three shapes already match

   broadcast_arrays allocates three fresh NDArrays plus helper Shape[]. For the
   common case of np.where(mask, arr, other_arr) where all three arrays share a
   shape, this is wasted. Skip it when condition.Shape == x.Shape == y.Shape
   (Shape == compares by dimensions).

4. Perf: cache Vector256/Vector128 generic MethodInfo

   EmitWhereV256BodyWithOffset and EmitWhereV128BodyWithOffset did
   Array.Find(typeof(Vector*).GetMethods(), ...) three times per call, each
   scanning ~100 methods. Per kernel generation (4-way unrolled + 1 remainder
   call = 5 calls), that was 15 reflection scans per T, or ~180 on first use
   across all 12 dtypes. Cached as six static readonly fields; only
   MakeGenericMethod(typeof(T)) runs per call.

5. Polish: doc + error message

   - where(NDArray) xmldoc was copy-pasted from the 3-arg overload ("Return
     elements chosen from x or y"); rewritten to describe nonzero semantics.
   - object[] NotSupportedException now names the actual problem ("element type
     is not a supported NumSharp dtype") instead of just reporting the length.

Verified: 180 np.where + np.asanyarray tests pass on net8.0 + net10.0.

Author: Nucs

src/NumSharp.Core/APIs/np.where.cs

@@ -7,10 +7,11 @@ namespace NumSharp
     public static partial class np
     {
         /// <summary>
-        ///     Return elements chosen from `x` or `y` depending on `condition`.
+        ///     Equivalent to <see cref="nonzero(NDArray)"/>: returns the indices where
+        ///     <paramref name="condition"/> is non-zero.
         /// </summary>
-        /// <param name="condition">Where True, yield `x`, otherwise yield `y`.</param>
-        /// <returns>Tuple of arrays with indices where condition is non-zero (equivalent to np.nonzero).</returns>
+        /// <param name="condition">Input array. Non-zero entries yield their indices.</param>
+        /// <returns>Tuple of arrays with indices where condition is non-zero, one per dimension.</returns>
         /// <remarks>https://numpy.org/doc/stable/reference/generated/numpy.where.html</remarks>
         public static NDArray<long>[] where(NDArray condition)
         {
@@ -62,17 +63,29 @@ public static NDArray where(NDArray condition, object x, object y)
         /// </summary>
         private static NDArray where_internal(NDArray condition, NDArray x, NDArray y)
         {
-            // Broadcast all three arrays to common shape
-            var broadcasted = broadcast_arrays(condition, x, y);
-            var cond = broadcasted[0];
-            var xArr = broadcasted[1];
-            var yArr = broadcasted[2];
+            // Skip broadcast_arrays (which allocates 3 NDArrays + helper arrays) when all three
+            // already share a shape — the frequent case of np.where(mask, arr, other_arr).
+            NDArray cond, xArr, yArr;
+            if (condition.Shape == x.Shape && x.Shape == y.Shape)
+            {
+                cond = condition;
+                xArr = x;
+                yArr = y;
+            }
+            else
+            {
+                var broadcasted = broadcast_arrays(condition, x, y);
+                cond = broadcasted[0];
+                xArr = broadcasted[1];
+                yArr = broadcasted[2];
+            }
 
-            // Determine output dtype using existing type promotion system
-            // _FindCommonType already handles NEP50: scalar+array → array wins
-            var outType = _FindCommonType(x, y);
+            // When x and y already agree, skip the NEP50 promotion lookup. Otherwise defer to
+            // _FindCommonType which handles the scalar+array NEP50 rules.
+            var outType = x.GetTypeCode == y.GetTypeCode
+                ? x.GetTypeCode
+                : _FindCommonType(x, y);
 
-            // Convert x and y to output type if needed (required for kernel and iterator paths)
             if (xArr.GetTypeCode != outType)
                 xArr = xArr.astype(outType, copy: false);
             if (yArr.GetTypeCode != outType)

src/NumSharp.Core/Backends/Kernels/ILKernelGenerator.Where.cs

@@ -251,18 +251,27 @@ private static void EmitWhereSIMDLoop<T>(ILGenerator il, LocalBuilder locI) wher
             il.MarkLabel(lblVectorLoopEnd);
         }
 
+        // Generic method definitions are cached once at class init; MakeGenericMethod is the
+        // only per-T work needed during kernel generation.
+        private static readonly MethodInfo _v256LoadGeneric = Array.Find(typeof(Vector256).GetMethods(),
+            m => m.Name == "Load" && m.IsGenericMethodDefinition && m.GetParameters().Length == 1)!;
+        private static readonly MethodInfo _v256StoreGeneric = Array.Find(typeof(Vector256).GetMethods(),
+            m => m.Name == "Store" && m.IsGenericMethodDefinition && m.GetParameters().Length == 2)!;
+        private static readonly MethodInfo _v256ConditionalSelectGeneric = Array.Find(typeof(Vector256).GetMethods(),
+            m => m.Name == "ConditionalSelect" && m.IsGenericMethodDefinition)!;
+
+        private static readonly MethodInfo _v128LoadGeneric = Array.Find(typeof(Vector128).GetMethods(),
+            m => m.Name == "Load" && m.IsGenericMethodDefinition && m.GetParameters().Length == 1)!;
+        private static readonly MethodInfo _v128StoreGeneric = Array.Find(typeof(Vector128).GetMethods(),
+            m => m.Name == "Store" && m.IsGenericMethodDefinition && m.GetParameters().Length == 2)!;
+        private static readonly MethodInfo _v128ConditionalSelectGeneric = Array.Find(typeof(Vector128).GetMethods(),
+            m => m.Name == "ConditionalSelect" && m.IsGenericMethodDefinition)!;
+
         private static void EmitWhereV256BodyWithOffset<T>(ILGenerator il, LocalBuilder locI, long elementSize, long offset) where T : unmanaged
         {
-            // Get Vector256 methods via reflection - need to find generic method definitions first
-            var loadMethod = Array.Find(typeof(Vector256).GetMethods(),
-                m => m.Name == "Load" && m.IsGenericMethodDefinition && m.GetParameters().Length == 1)!
-                .MakeGenericMethod(typeof(T));
-            var storeMethod = Array.Find(typeof(Vector256).GetMethods(),
-                m => m.Name == "Store" && m.IsGenericMethodDefinition && m.GetParameters().Length == 2)!
-                .MakeGenericMethod(typeof(T));
-            var selectMethod = Array.Find(typeof(Vector256).GetMethods(),
-                m => m.Name == "ConditionalSelect" && m.IsGenericMethodDefinition)!
-                .MakeGenericMethod(typeof(T));
+            var loadMethod = _v256LoadGeneric.MakeGenericMethod(typeof(T));
+            var storeMethod = _v256StoreGeneric.MakeGenericMethod(typeof(T));
+            var selectMethod = _v256ConditionalSelectGeneric.MakeGenericMethod(typeof(T));
 
             // Load address: cond + (i + offset)
             il.Emit(OpCodes.Ldarg_0);  // cond
@@ -327,16 +336,9 @@ private static void EmitWhereV256BodyWithOffset<T>(ILGenerator il, LocalBuilder
 
         private static void EmitWhereV128BodyWithOffset<T>(ILGenerator il, LocalBuilder locI, long elementSize, long offset) where T : unmanaged
         {
-            // Get Vector128 methods via reflection - need to find generic method definitions first
-            var loadMethod = Array.Find(typeof(Vector128).GetMethods(),
-                m => m.Name == "Load" && m.IsGenericMethodDefinition && m.GetParameters().Length == 1)!
-                .MakeGenericMethod(typeof(T));
-            var storeMethod = Array.Find(typeof(Vector128).GetMethods(),
-                m => m.Name == "Store" && m.IsGenericMethodDefinition && m.GetParameters().Length == 2)!
-                .MakeGenericMethod(typeof(T));
-            var selectMethod = Array.Find(typeof(Vector128).GetMethods(),
-                m => m.Name == "ConditionalSelect" && m.IsGenericMethodDefinition)!
-                .MakeGenericMethod(typeof(T));
+            var loadMethod = _v128LoadGeneric.MakeGenericMethod(typeof(T));
+            var storeMethod = _v128StoreGeneric.MakeGenericMethod(typeof(T));
+            var selectMethod = _v128ConditionalSelectGeneric.MakeGenericMethod(typeof(T));
 
             // Load address: cond + (i + offset)
             il.Emit(OpCodes.Ldarg_0);

src/NumSharp.Core/Creation/np.asanyarray.cs

@@ -32,7 +32,7 @@ public static NDArray asanyarray(in object a, Type dtype = null) //todo support
                     // supported element type.
                     ret = ConvertNonGenericEnumerable(objArr);
                     if (ret is null)
-                        throw new NotSupportedException($"Unable to resolve asanyarray for object array of length {objArr.Length}.");
+                        throw new NotSupportedException($"Unable to resolve asanyarray for object[] (length {objArr.Length}): element type is not a supported NumSharp dtype.");
                     break;
                 case Array array:
                     ret = new NDArray(array);
@@ -206,8 +206,6 @@ private static Type FindCommonNumericType(List<object> items)
         {
             var span = CollectionsMarshal.AsSpan(items);
 
-            bool hasDouble = false;
-            bool hasFloat = false;
             Type firstType = null;
 
             // At most 12 unique NPTypeCode values exist; bound the stackalloc accordingly
@@ -221,12 +219,10 @@ private static Type FindCommonNumericType(List<object> items)
                 var t = span[i].GetType();
                 firstType ??= t;
 
+                // decimal wins everything in NumPy promotion
                 if (t == typeof(decimal))
                     return typeof(decimal);
 
-                if (t == typeof(double)) hasDouble = true;
-                else if (t == typeof(float)) hasFloat = true;
-
                 var code = t.GetTypeCode();
                 var bit = 1u << (int)code;
                 if ((seenMask & bit) == 0)
@@ -236,9 +232,6 @@ private static Type FindCommonNumericType(List<object> items)
                 }
             }
 
-            if (hasDouble || hasFloat)
-                return typeof(double);
-
             if (uniqueCount == 1)
                 return firstType ?? typeof(double);
 

test/NumSharp.UnitTest/Creation/np.asanyarray.Tests.cs

@@ -791,6 +791,29 @@ public void ObjectArray_Empty_ReturnsFloat64()
             result.dtype.Should().Be(typeof(double));
         }
 
+        [TestMethod]
+        public void ObjectArray_AllFloat_PreservesSingle()
+        {
+            // Regression: an earlier FindCommonNumericType short-circuit promoted any float
+            // to double. NumPy preserves float32 for homogeneous float32 inputs.
+            var arr = new object[] { 1.5f, 2.5f, 3.5f };
+            var result = np.asanyarray(arr);
+
+            result.dtype.Should().Be(typeof(float));
+            result.Should().BeShaped(3).And.BeOfValues(1.5f, 2.5f, 3.5f);
+        }
+
+        [TestMethod]
+        public void ObjectArray_MixedIntAndFloat32_PromotesToDouble()
+        {
+            // int + float32 -> float64 per NumPy NEP50.
+            var arr = new object[] { 1, 2.5f, 3 };
+            var result = np.asanyarray(arr);
+
+            result.dtype.Should().Be(typeof(double));
+            result.Should().BeShaped(3);
+        }
+
         #endregion
     }
 }