chore: import upstream snapshot with attribution

libnd4j/include/loops/cpu/reduce/reduce_bool.hpp

@@ -0,0 +1,198 @@
+/* ******************************************************************************
+ *
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License, Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ *  See the NOTICE file distributed with this work for additional
+ *  information regarding copyright ownership.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+ * the License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ******************************************************************************/
+
+//
+//  @author raver119@gmail.com
+//  @author Yurii Shyrma (iuriish@yahoo.com)
+//
+#include <helpers/ConstantTadHelper.h>
+#include <helpers/Loops.h>
+#include <helpers/OmpLaunchHelper.h>
+#include <loops/legacy_ops.h>
+#include <loops/reduce_bool.h>
+#include <system/op_boilerplate.h>
+#include <types/types.h>
+
+    using namespace simdOps;
+
+namespace functions {
+namespace reduce {
+template <typename X, typename Z>
+template <typename OpType>
+void SD_HOST ReduceBoolFunction<X, Z>::execScalar(const void *vx, const sd::LongType *xShapeInfo, void *vextraParams,
+                                                  void *vz, const sd::LongType *zShapeInfo) {
+  auto x = reinterpret_cast<const X *>(vx);
+  auto z = reinterpret_cast<Z *>(vz);
+  auto extraParams = reinterpret_cast<X *>(vextraParams);
+
+  const auto length = shape::length(xShapeInfo);
+
+  if (shape::isEmptyConst(xShapeInfo)) {
+    z[0] = OpType::startingValue(x);
+    return;
+  }
+
+  if (sd::ArrayOptions::arrayType(xShapeInfo) == sd::ArrayType::EMPTY) {
+    if (sd::ArrayOptions::arrayType(zShapeInfo) == sd::ArrayType::EMPTY) return;
+    const auto startingVal = OpType::startingValue(x);
+
+    for (sd::LongType i = 0; i < length; i++) {
+      z[i] = startingVal;
+    }
+    return;
+  }
+
+  auto startingValue = OpType::startingValue(x);
+  int maxThreads = sd::math::sd_min<int>(64, sd::Environment::getInstance().maxThreads());
+  X intermediate[64];
+
+  PRAGMA_OMP_SIMD
+  for (auto e = 0; e < maxThreads; e++) {
+    intermediate[e] = startingValue;
+  }
+
+  sd::LongType xRank = shape::rank(xShapeInfo);
+  sd::LongType* xShape = shape::shapeOf(xShapeInfo);
+  sd::LongType* xStride = shape::stride(xShapeInfo);
+  if(shape::isViewConst(xShapeInfo)) {
+    auto func = PRAGMA_THREADS_FOR {
+      for (auto i = start; i < stop; i++) {
+        sd::LongType coords[SD_MAX_RANK];
+        INDEX2COORDS(i, xRank, xShape, coords);
+        sd::LongType indexOffset;
+        COORDS2INDEX(xRank, xStride, coords, indexOffset);
+        intermediate[thread_id] = OpType::update(intermediate[thread_id], OpType::op(x[indexOffset], extraParams), extraParams);
+      }
+    };
+    maxThreads = samediff::Threads::parallel_for(func, 0, length, 1, maxThreads);
+    PRAGMA_OMP_SIMD
+    for (int e = 1; e < maxThreads; e++) {
+      intermediate[0] = OpType::update(intermediate[0], intermediate[e], extraParams);
+    }
+
+    z[0] = OpType::postProcess(intermediate[0], length, extraParams);
+  } else {
+    auto func = PRAGMA_THREADS_FOR {
+      for (auto i = start; i < stop; i++) {
+        intermediate[thread_id] = OpType::update(intermediate[thread_id], OpType::op(x[i], extraParams), extraParams);
+      }
+    };
+    maxThreads = samediff::Threads::parallel_for(func, 0, length, 1, maxThreads);
+    PRAGMA_OMP_SIMD
+    for (int e = 1; e < maxThreads; e++) {
+      intermediate[0] = OpType::update(intermediate[0], intermediate[e], extraParams);
+    }
+
+    z[0] = OpType::postProcess(intermediate[0], length, extraParams);
+  }
+}
+template <typename X, typename Z>
+template <typename OpType>
+Z SD_HOST ReduceBoolFunction<X, Z>::execScalar(const void *vx, const sd::LongType *xShapeInfo, void *vextraParams) {
+  auto x = reinterpret_cast<const X *>(vx);
+  auto extraParams = reinterpret_cast<X *>(vextraParams);
+
+  const sd::LongType length = shape::length(xShapeInfo);
+  auto startingValue = OpType::startingValue(x);
+
+  sd::LongType xRank = shape::rank(xShapeInfo);
+  sd::LongType *xShape = shape::shapeOf(xShapeInfo);
+  sd::LongType *xStride = shape::stride(xShapeInfo);
+
+  for (sd::LongType i = 0; i < length; i++) {
+    sd::LongType coords[SD_MAX_RANK];
+    INDEX2COORDS(i, xRank, xShape, coords);
+    sd::LongType offset;
+    COORDS2INDEX(xRank, xStride, coords, offset);
+    startingValue = OpType::update(startingValue, OpType::op(x[offset], extraParams), extraParams);
+  }
+  return OpType::postProcess(startingValue, length, extraParams);
+}
+
+template <typename X, typename Z>
+Z ReduceBoolFunction<X, Z>::execScalar(const int opNum, const void *x, const sd::LongType *xShapeInfo,
+                                       void *extraParams) {
+  RETURNING_DISPATCH_BY_OPNUM_TT(execScalar, PARAMS(x, xShapeInfo, extraParams), REDUCE_BOOL_OPS);
+
+
+}
+
+template <typename X, typename Z>
+void ReduceBoolFunction<X, Z>::execScalar(const int opNum, const void *x, const sd::LongType *xShapeInfo,
+                                          void *extraParams, void *z, const sd::LongType *zShapeInfo) {
+  DISPATCH_BY_OPNUM_TT(execScalar, PARAMS(x, xShapeInfo, extraParams, z, zShapeInfo), REDUCE_BOOL_OPS);
+
+
+}
+
+template <typename X, typename Z>
+template <typename OpType>
+void SD_HOST ReduceBoolFunction<X, Z>::exec(const void *x, const sd::LongType *xShapeInfo, void *extraParams,
+                                            void *vresult, const sd::LongType *resultShapeInfo) {
+  auto z = reinterpret_cast<Z *>(vresult);
+  z[0] = execScalar<OpType>(x, xShapeInfo, extraParams);
+}
+
+template <typename X, typename Z>
+template <typename OpType>
+void SD_HOST ReduceBoolFunction<X, Z>::exec(sd::memory::Workspace *workspace, const void *vx,
+                                            const sd::LongType *xShapeInfo, void *vextraParams, void *vz,
+                                            const sd::LongType *zShapeInfo, const sd::LongType *dims) {
+  const X *x = reinterpret_cast<const X *>(vx);
+  Z *z = reinterpret_cast<Z *>(vz);
+  X *extraParams = reinterpret_cast<X *>(vextraParams);
+
+  const sd::LongType xRank = shape::rank(xShapeInfo);
+  const sd::LongType zRank = shape::rank(zShapeInfo);
+
+  if (sd::ArrayOptions::arrayType(xShapeInfo) == sd::ArrayType::EMPTY) {
+    const auto startingVal = OpType::startingValue(x);
+    const auto zLen = shape::length(zShapeInfo);
+    if(z != nullptr)
+      for (sd::LongType i = 0; i < zLen; i++) {
+#if defined(PRINT_INDICES)
+        shape::printShapeInfo(xShapeInfo);
+        shape::printShapeInfo(zShapeInfo);
+        printf("i: %lld\n  ReduceBoolFunction<X, Z>::exec", i);
+#endif
+        z[i] = startingVal;
+      }
+    return;
+  }
+
+  if (shape::length(zShapeInfo) == 1) {
+    z[0] = execScalar<OpType>(x, xShapeInfo, extraParams);
+    return;
+  }
+
+#ifdef SD_LOOPS_INLINED
+  sd::ReductionLoops<X, Z, X>::template loopReduce<OpType>(workspace, x, xShapeInfo, z, zShapeInfo, dims, extraParams);
+#else
+  sd::ReductionBoolLoops<X, Z>::template innerloopReduce<OpType>(workspace, x, xShapeInfo, z, zShapeInfo, dims,
+                                                                 extraParams);
+#endif
+}
+
+template <typename X, typename Z>
+void ReduceBoolFunction<X, Z>::exec(int opNum, sd::memory::Workspace *workspace, const void *vx,
+                                    const sd::LongType *xShapeInfo, void *vextraParams, void *vz,
+                                    const sd::LongType *zShapeInfo, const sd::LongType *dims) {
+  DISPATCH_BY_OPNUM_TT(exec, PARAMS(workspace, vx, xShapeInfo, vextraParams, vz, zShapeInfo, dims), REDUCE_BOOL_OPS);
+}
+}  // namespace reduce
+}  // namespace functions

libnd4j/include/loops/cpu/reduce/reduce_float.hpp

@@ -0,0 +1,380 @@
+#include <helpers/ConstantTadHelper.h>
+#include <helpers/Loops.h>
+#include <helpers/OmpLaunchHelper.h>
+#include <helpers/ShapeBuilders.h>
+#include <loops/legacy_ops.h>
+#include <loops/reduce_float.h>
+#include <system/op_boilerplate.h>
+#include <types/types.h>
+#include <algorithm>
+
+using namespace simdOps;
+
+namespace functions {
+namespace reduce {
+
+// =============================================================================
+// TYPE-SAFE UTILITIES FOR ALL NUMERIC TYPES INCLUDING FLOAT16
+// =============================================================================
+
+namespace SafeTypeUtils {
+
+/**
+ * @brief Type-safe array initialization that works with float16 and all other types
+ */
+template<typename T>
+SD_INLINE void initializeArray(T* array, size_t count) {
+  if constexpr (std::is_arithmetic_v<T>) {
+    // For arithmetic types including float16, use loop initialization
+    for (size_t i = 0; i < count; i++) {
+      array[i] = static_cast<T>(0);
+    }
+  } else {
+    // For non-arithmetic types, use default initialization
+    std::fill_n(array, count, T{});
+  }
+}
+
+/**
+ * @brief Safe type conversion for mixed-type operations
+ */
+template<typename From, typename To>
+SD_INLINE constexpr To safeCast(const From& value) {
+  return static_cast<To>(value);
+}
+
+/**
+ * @brief Convert parameter arrays between types safely
+ */
+template<typename SourceType, typename TargetType>
+SD_INLINE void convertParams(const SourceType* source, TargetType* target, size_t count = 8) {
+  if (source && target) {
+    for (size_t i = 0; i < count; i++) {
+      target[i] = safeCast<SourceType, TargetType>(source[i]);
+    }
+  }
+}
+
+/**
+ * @brief Determine appropriate parameter type for mixed operations
+ * For float16, use float for better compatibility; otherwise use Z type
+ */
+template<typename X, typename Z>
+struct CompatibleParamType {
+  using type = typename std::conditional_t<
+      std::is_same_v<Z, float16> || std::is_same_v<Z, bfloat16>,
+      float,  // Use float for half-precision types
+      Z       // Use Z for all other types
+      >;
+};
+
+} // namespace SafeTypeUtils
+
+// =============================================================================
+// REDUCE FLOAT FUNCTION IMPLEMENTATION WITH FLOAT16 SUPPORT
+// =============================================================================
+
+template <typename X, typename Z>
+template <typename OpType>
+void SD_HOST ReduceFloatFunction<X, Z>::execScalar(const void *vx, const sd::LongType *xShapeInfo, void *vextraParams,
+                                                   void *vz, const sd::LongType *zShapeInfo) {
+  auto x = reinterpret_cast<const X *>(vx);
+  auto z = reinterpret_cast<Z *>(vz);
+
+  // Convert to Z* for consistency with macro expectations
+  Z *extraParams = nullptr;
+  Z convertedParams[8];
+
+  if (vextraParams != nullptr) {
+    if constexpr (std::is_same_v<Z, X>) {
+      extraParams = reinterpret_cast<Z*>(vextraParams);
+    } else {
+      // Convert parameters to Z type
+      auto originalParams = reinterpret_cast<X*>(vextraParams);
+      for (int i = 0; i < 8; ++i) {
+        convertedParams[i] = static_cast<Z>(originalParams[i]);
+      }
+      extraParams = convertedParams;
+    }
+  }
+
+  const auto length = shape::length(xShapeInfo);
+
+  if (shape::isEmptyConst(xShapeInfo)) {
+    z[0] = static_cast<Z>(OpType::startingValue(x));
+    return;
+  }
+
+  if (sd::ArrayOptions::arrayType(xShapeInfo) == sd::ArrayType::EMPTY) {
+    if (sd::ArrayOptions::arrayType(zShapeInfo) == sd::ArrayType::EMPTY) return;
+    const auto startingVal = static_cast<Z>(OpType::startingValue(x));
+
+    for (sd::LongType i = 0; i < length; i++) {
+      z[i] = startingVal;
+    }
+    return;
+  }
+
+  auto startingValue = static_cast<typename OpType::InterType>(OpType::startingValue(x));
+  int maxThreads = sd::math::sd_min<int>(64, sd::Environment::getInstance().maxThreads());
+  typename OpType::InterType intermediate[64];
+
+  PRAGMA_OMP_SIMD
+  for (auto e = 0; e < maxThreads; e++) {
+    intermediate[e] = startingValue;
+  }
+
+  sd::LongType xRank = shape::rank(xShapeInfo);
+  sd::LongType* xShape = shape::shapeOf(xShapeInfo);
+  sd::LongType* xStride = shape::stride(xShapeInfo);
+
+  if(shape::isViewConst(xShapeInfo)) {
+    auto func = PRAGMA_THREADS_FOR {
+      for (auto i = start; i < stop; i++) {
+        sd::LongType coords[SD_MAX_RANK];
+        INDEX2COORDS(i, xRank, xShape, coords);
+        sd::LongType indexOffset;
+        COORDS2INDEX(xRank, xStride, coords, indexOffset);
+
+        auto opResult = OpType::op(x[indexOffset], extraParams);
+        intermediate[thread_id] = OpType::update(
+            intermediate[thread_id],
+            opResult,
+            extraParams
+        );
+      }
+    };
+    maxThreads = samediff::Threads::parallel_for(func, 0, length, 1, maxThreads);
+
+    PRAGMA_OMP_SIMD
+    for (int e = 1; e < maxThreads; e++) {
+      intermediate[0] = OpType::merge(intermediate[0], intermediate[e], extraParams);
+    }
+
+    z[0] = OpType::postProcess(intermediate[0], length, extraParams);
+  } else {
+    auto func = PRAGMA_THREADS_FOR {
+      for (auto i = start; i < stop; i++) {
+        auto opResult = OpType::op(x[i], extraParams);
+        intermediate[thread_id] = OpType::update(
+            intermediate[thread_id],
+            opResult,
+            extraParams
+        );
+      }
+    };
+    maxThreads = samediff::Threads::parallel_for(func, 0, length, 1, maxThreads);
+
+    PRAGMA_OMP_SIMD
+    for (int e = 1; e < maxThreads; e++) {
+      intermediate[0] = OpType::merge(intermediate[0], intermediate[e], extraParams);
+    }
+
+    z[0] = OpType::postProcess(intermediate[0], length, extraParams);
+  }
+}
+
+template <typename X, typename Z>
+template <typename OpType>
+Z SD_HOST ReduceFloatFunction<X, Z>::execScalar(const void *vx, const sd::LongType *xShapeInfo, void *vextraParams) {
+  auto x = reinterpret_cast<const X *>(vx);
+
+  // Convert to Z* for compatibility with OpType::op
+  Z *extraParams = nullptr;
+  Z convertedParams[8];
+
+  if (vextraParams != nullptr) {
+    if constexpr (std::is_same_v<Z, X>) {
+      extraParams = reinterpret_cast<Z*>(vextraParams);
+    } else {
+      // Convert the parameters to Z type
+      auto originalParams = reinterpret_cast<X*>(vextraParams);
+      for (int i = 0; i < 8; ++i) {
+        convertedParams[i] = static_cast<Z>(originalParams[i]);
+      }
+      extraParams = convertedParams;
+    }
+  }
+
+  const sd::LongType length = shape::length(xShapeInfo);
+  auto startingValue = static_cast<typename OpType::InterType>(OpType::startingValue(x));
+
+  sd::LongType xRank = shape::rank(xShapeInfo);
+  sd::LongType *xShape = shape::shapeOf(xShapeInfo);
+  sd::LongType *xStride = shape::stride(xShapeInfo);
+
+  for (sd::LongType i = 0; i < length; i++) {
+    sd::LongType coords[SD_MAX_RANK];
+    INDEX2COORDS(i, xRank, xShape, coords);
+    sd::LongType offset;
+    COORDS2INDEX(xRank, xStride, coords, offset);
+
+    auto opResult = OpType::op(x[offset], extraParams);
+    startingValue = OpType::update(startingValue, opResult, extraParams);
+  }
+
+  return OpType::postProcess(startingValue, length, extraParams);
+}
+template <typename X, typename Z>
+template <typename OpType>
+void SD_HOST ReduceFloatFunction<X, Z>::exec(sd::memory::Workspace *workspace, const void *vx,
+                                             const sd::LongType *xShapeInfo, void *vextraParams, void *vz,
+                                             const sd::LongType *zShapeInfo, const sd::LongType *dims) {
+  const X *x = reinterpret_cast<const X *>(vx);
+  Z *z = reinterpret_cast<Z *>(vz);
+
+  using CompatibleParamType = typename SafeTypeUtils::CompatibleParamType<X, Z>::type;
+  CompatibleParamType *compatibleExtraParams = nullptr;
+  CompatibleParamType convertedParams[8];
+  SafeTypeUtils::initializeArray(convertedParams, 8);
+
+  if (vextraParams != nullptr) {
+    if constexpr (std::is_same_v<X, CompatibleParamType>) {
+      compatibleExtraParams = reinterpret_cast<CompatibleParamType*>(vextraParams);
+    } else {
+      SafeTypeUtils::convertParams(reinterpret_cast<X*>(vextraParams), convertedParams, 8);
+      compatibleExtraParams = convertedParams;
+    }
+  }
+
+  const int xRank = shape::rank(xShapeInfo);
+  const int zRank = shape::rank(zShapeInfo);
+
+  if (sd::ArrayOptions::arrayType(xShapeInfo) == sd::ArrayType::EMPTY) {
+    const auto startingVal = std::is_same<OpType, simdOps::Mean<X, Z>>::value
+                                 ? sd::DataTypeUtils::nanOrZero<Z>()
+                                 : SafeTypeUtils::safeCast<X, Z>(OpType::startingValue(x));
+    const auto zLen = shape::length(zShapeInfo);
+    if (z != nullptr)
+      for (sd::LongType i = 0; i < zLen; i++) z[i] = startingVal;
+    return;
+  }
+
+  if (shape::length(zShapeInfo) == 1) {
+    z[0] = execScalar<OpType>(x, xShapeInfo, compatibleExtraParams);
+    return;
+  }
+
+  if (OpType::requiresSpecialAccumulation) {
+    // FIXED: Handle execSpecial with flexible parameter types
+    // The enhanced macro provides template overloads that accept any arithmetic type
+        
+    if constexpr (std::is_same_v<CompatibleParamType, sd::LongType>) {
+      // Direct call for sd::LongType parameters
+      OpType::execSpecial(x, xShapeInfo, compatibleExtraParams, z, zShapeInfo,
+                          const_cast<sd::LongType *>(dims) + zRank, xRank - zRank,
+                          nullptr, nullptr);
+    } else {
+      // Convert to sd::LongType for operations that specifically need it
+      sd::LongType longExtraParams[8];
+      SafeTypeUtils::initializeArray(longExtraParams, 8);
+            
+      if (compatibleExtraParams != nullptr) {
+        SafeTypeUtils::convertParams(compatibleExtraParams, longExtraParams, 8);
+      }
+            
+      // Use template overload that accepts sd::LongType*
+      OpType::execSpecial(x, xShapeInfo, longExtraParams, z, zShapeInfo,
+                          const_cast<sd::LongType *>(dims) + zRank, xRank - zRank,
+                          nullptr, nullptr);
+    }
+    return;
+  }
+
+#ifdef SD_LOOPS_INLINED
+  sd::ReductionLoops<X, Z, CompatibleParamType>::template loopReduce<OpType>(workspace, x, xShapeInfo, z, zShapeInfo, dims, compatibleExtraParams);
+#else
+  sd::ReductionFloatLoops<X, Z>::template innerloopReduce<OpType>(workspace, x, xShapeInfo, z, zShapeInfo, dims, compatibleExtraParams);
+#endif
+}
+
+
+template <typename X, typename Z>
+Z ReduceFloatFunction<X, Z>::execScalar(const int opNum, const void *x, const sd::LongType *xShapeInfo,
+                                        void *extraParams) {
+  RETURNING_DISPATCH_BY_OPNUM_TT(execScalar, PARAMS(x, xShapeInfo, extraParams), REDUCE_FLOAT_OPS);
+}
+
+template <typename X, typename Z>
+void ReduceFloatFunction<X, Z>::execScalar(const int opNum, const void *x, const sd::LongType *xShapeInfo,
+                                           void *extraParams, void *z, const sd::LongType *zShapeInfo) {
+  DISPATCH_BY_OPNUM_TT(execScalar, PARAMS(x, xShapeInfo, extraParams, z, zShapeInfo), REDUCE_FLOAT_OPS);
+}
+
+template <typename X, typename Z>
+template <typename OpType>
+void SD_HOST ReduceFloatFunction<X, Z>::exec(const void *x, const sd::LongType *xShapeInfo, void *extraParams,
+                                             void *vresult, const sd::LongType *resultShapeInfo) {
+  auto z = reinterpret_cast<Z *>(vresult);
+  z[0] = execScalar<OpType>(x, xShapeInfo, extraParams);
+}
+
+template <typename X, typename Z>
+template <typename OpType>
+Z SD_HOST ReduceFloatFunction<X, Z>::execScalar(const void *vx, sd::LongType xEws, sd::LongType length,
+                                                void *vextraParams) {
+  auto x = reinterpret_cast<const X *>(vx);
+
+  using CompatibleParamType = typename SafeTypeUtils::CompatibleParamType<X, Z>::type;
+  CompatibleParamType *compatibleExtraParams = nullptr;
+  CompatibleParamType convertedParams[8];
+  SafeTypeUtils::initializeArray(convertedParams, 8);
+
+  if (vextraParams != nullptr) {
+    if constexpr (std::is_same_v<X, CompatibleParamType>) {
+      compatibleExtraParams = reinterpret_cast<CompatibleParamType*>(vextraParams);
+    } else {
+      SafeTypeUtils::convertParams(reinterpret_cast<X*>(vextraParams), convertedParams, 8);
+      compatibleExtraParams = convertedParams;
+    }
+  }
+
+  int maxThreads = sd::math::sd_min<int>(64, sd::Environment::getInstance().maxThreads());
+  using InterType = typename OpType::InterType;
+  InterType intermediate[64];
+
+  PRAGMA_OMP_SIMD
+  for (auto e = 0; e < maxThreads; e++) {
+    intermediate[e] = SafeTypeUtils::safeCast<X, InterType>(OpType::startingValue(x));
+  }
+
+  auto func = PRAGMA_THREADS_FOR {
+    if (xEws == 1) {
+      for (auto i = start; i < stop; i++) {
+        auto opResult = OpType::op(x[i], compatibleExtraParams);
+        intermediate[thread_id] = OpType::update(
+            intermediate[thread_id],
+            SafeTypeUtils::safeCast<decltype(opResult), InterType>(opResult),
+            compatibleExtraParams
+        );
+      }
+    } else {
+      for (auto i = start; i < stop; i++) {
+        auto opResult = OpType::op(x[i * xEws], compatibleExtraParams);
+        intermediate[thread_id] = OpType::update(
+            intermediate[thread_id],
+            SafeTypeUtils::safeCast<decltype(opResult), InterType>(opResult),
+            compatibleExtraParams
+        );
+      }
+    }
+  };
+
+  maxThreads = samediff::Threads::parallel_for(func, 0, length, 1, maxThreads);
+
+  for (int e = 1; e < maxThreads; e++)
+    intermediate[0] = OpType::update(intermediate[0], intermediate[e], compatibleExtraParams);
+
+  return SafeTypeUtils::safeCast<InterType, Z>(OpType::postProcess(intermediate[0], length, compatibleExtraParams));
+}
+
+template <typename X, typename Z>
+void ReduceFloatFunction<X, Z>::exec(int opNum, sd::memory::Workspace *workspace, const void *vx,
+                                     const sd::LongType *xShapeInfo, void *vextraParams, void *vz,
+                                     const sd::LongType *zShapeInfo, const sd::LongType *dims) {
+  DISPATCH_BY_OPNUM_TT(exec, PARAMS(workspace, vx, xShapeInfo, vextraParams, vz, zShapeInfo, dims), REDUCE_FLOAT_OPS);
+}
+
+
+}  // namespace reduce
+}  // namespace functions

libnd4j/include/loops/cpu/reduce/reduce_long.hpp

@@ -0,0 +1,246 @@
+/* ******************************************************************************
+*
+*
+* This program and the accompanying materials are made available under the
+* terms of the Apache License, Version 2.0 which is available at
+* https://www.apache.org/licenses/LICENSE-2.0.
+*
+*  See the NOTICE file distributed with this work for additional
+*  information regarding copyright ownership.
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+* License for the specific language governing permissions and limitations
+* under the License.
+*
+* SPDX-License-Identifier: Apache-2.0
+******************************************************************************/
+
+//
+//  @author raver119@gmail.com
+//  @author Yurii Shyrma (iuriish@yahoo.com)
+//
+#include <helpers/ConstantTadHelper.h>
+#include <helpers/Loops.h>
+#include <helpers/OmpLaunchHelper.h>
+#include <loops/legacy_ops.h>
+#include <loops/reduce_long.h>
+#include <system/op_boilerplate.h>
+#include <types/types.h>
+
+using namespace simdOps;
+
+namespace functions {
+namespace reduce {
+
+template <typename X, typename Z>
+template <typename OpType>
+void SD_HOST ReduceLongFunction<X, Z>::execScalar(const void *vx, const sd::LongType *xShapeInfo, void *vextraParams,
+                                                  void *vz, const sd::LongType *zShapeInfo) {
+  auto x = reinterpret_cast<const X *>(vx);
+  auto z = reinterpret_cast<Z *>(vz);
+
+  // For reduce_long operations like MatchCondition, extraParams contain comparison values
+  // (e.g., compare value, epsilon) that must remain in input type X, not be converted to Z.
+  // Converting double→LongType would truncate 0.5→0, breaking comparisons.
+  auto compatibleExtraParams = reinterpret_cast<X*>(vextraParams);
+
+  const sd::LongType length = shape::length(xShapeInfo);
+
+  if (shape::isEmptyConst(xShapeInfo)) {
+    z[0] = static_cast<Z>(OpType::startingValue(x));
+    return;
+  }
+
+  if (sd::ArrayOptions::arrayType(xShapeInfo) == sd::ArrayType::EMPTY) {
+    if (sd::ArrayOptions::arrayType(zShapeInfo) == sd::ArrayType::EMPTY) return;
+    const auto startingVal = static_cast<Z>(OpType::startingValue(x));
+
+    for (sd::LongType i = 0; i < length; i++) z[i] = startingVal;
+    return;
+  }
+
+  int maxThreads = sd::math::sd_min<int>(64, sd::Environment::getInstance().maxThreads());
+  typename OpType::InterType intermediate[64];
+
+  PRAGMA_OMP_SIMD
+  for (auto e = 0; e < maxThreads; e++) {
+    intermediate[e] = static_cast<typename OpType::InterType>(OpType::startingValue(x));
+  }
+
+  sd::LongType xRank = shape::rank(xShapeInfo);
+  sd::LongType* xShape = shape::shapeOf(xShapeInfo);
+  sd::LongType* xStride = shape::stride(xShapeInfo);
+
+
+  auto func = PRAGMA_THREADS_FOR {
+    sd::LongType coords[SD_MAX_RANK];
+    for (auto i = start; i < stop; i++) {
+      INDEX2COORDS(i, xRank, xShape, coords);
+      sd::LongType indexOffset;
+      COORDS2INDEX(xRank, xStride, coords, indexOffset);
+      
+      intermediate[thread_id] = OpType::update(
+          intermediate[thread_id],
+          OpType::op(x[indexOffset], compatibleExtraParams),
+          compatibleExtraParams);
+    }
+  };
+  maxThreads = samediff::Threads::parallel_for(func, 0, length, 1, maxThreads);
+
+  for (int e = 1; e < maxThreads; e++)
+    intermediate[0] = OpType::update(intermediate[0], intermediate[e], compatibleExtraParams);
+
+  z[0] = OpType::postProcess(intermediate[0], length, compatibleExtraParams);
+}
+
+template <typename X, typename Z>
+template <typename OpType>
+Z SD_HOST ReduceLongFunction<X, Z>::execScalar(const void *vx, const sd::LongType *xShapeInfo, void *vextraParams) {
+  auto x = reinterpret_cast<const X *>(vx);
+
+
+  // For reduce_long operations like MatchCondition, extraParams contain comparison values
+  // (e.g., compare value, epsilon) that must remain in input type X, not be converted to Z.
+  // Converting double→LongType would truncate 0.5→0, breaking comparisons.
+  auto compatibleExtraParams = reinterpret_cast<X*>(vextraParams);
+
+  const sd::LongType length = shape::length(xShapeInfo);
+
+  auto startingValue = static_cast<typename OpType::InterType>(OpType::startingValue(x));
+
+  sd::LongType xRank = shape::rank(xShapeInfo);
+  sd::LongType* xShape = shape::shapeOf(xShapeInfo);
+  sd::LongType* xStride = shape::stride(xShapeInfo);
+
+
+  sd::LongType coords[SD_MAX_RANK];
+  for (sd::LongType i = 0; i < length; i++) {
+    INDEX2COORDS(i, xRank, xShape, coords);
+    sd::LongType indexOffset;
+    COORDS2INDEX(xRank, xStride, coords, indexOffset);
+
+    
+    startingValue = OpType::update(startingValue, OpType::op(x[indexOffset], compatibleExtraParams), compatibleExtraParams);
+  }
+  
+  Z result = OpType::postProcess(startingValue, length, compatibleExtraParams);
+  return result;
+}
+
+template <typename X, typename Z>
+Z ReduceLongFunction<X, Z>::execScalar(const int opNum, const void *x, const sd::LongType *xShapeInfo,
+                                       void *extraParams) {
+  RETURNING_DISPATCH_BY_OPNUM_TT(execScalar, PARAMS(x, xShapeInfo, extraParams), REDUCE_LONG_OPS);
+}
+
+template <typename X, typename Z>
+void ReduceLongFunction<X, Z>::execScalar(const int opNum, const void *x, const sd::LongType *xShapeInfo,
+                                          void *extraParams, void *z, const sd::LongType *zShapeInfo) {
+  DISPATCH_BY_OPNUM_TT(execScalar, PARAMS(x, xShapeInfo, extraParams, z, zShapeInfo), REDUCE_LONG_OPS);
+}
+
+template <typename X, typename Z>
+template <typename OpType>
+void SD_HOST ReduceLongFunction<X, Z>::exec(const void *x, const sd::LongType *xShapeInfo, void *extraParams,
+                                            void *vresult, const sd::LongType *resultShapeInfo) {
+
+  auto z = reinterpret_cast<Z *>(vresult);
+  z[0] = execScalar<OpType>(x, xShapeInfo, extraParams);
+}
+
+template <typename X, typename Z>
+template <typename OpType>
+Z SD_HOST ReduceLongFunction<X, Z>::execScalar(const void *vx, sd::LongType xEws, sd::LongType length,
+                                               void *vextraParams) {
+  auto x = reinterpret_cast<const X *>(vx);
+
+
+  // For reduce_long operations like MatchCondition, extraParams contain comparison values
+  // (e.g., compare value, epsilon) that must remain in input type X, not be converted to Z.
+  // Converting double→LongType would truncate 0.5→0, breaking comparisons.
+  auto compatibleExtraParams = reinterpret_cast<X*>(vextraParams);
+
+  int maxThreads = sd::math::sd_min<int>(64, sd::Environment::getInstance().maxThreads());
+  typename OpType::InterType intermediate[64];
+
+  PRAGMA_OMP_SIMD
+  for (auto e = 0; e < maxThreads; e++) {
+    intermediate[e] = static_cast<typename OpType::InterType>(OpType::startingValue(x));
+  }
+
+
+  auto func = PRAGMA_THREADS_FOR {
+    if (xEws == 1) {
+      for (auto i = start; i < stop; i++) {
+        intermediate[thread_id] = OpType::update(intermediate[thread_id], OpType::op(x[i], compatibleExtraParams), compatibleExtraParams);
+      }
+    } else {
+      for (auto i = start; i < stop; i++) {
+        intermediate[thread_id] =
+            OpType::update(intermediate[thread_id], OpType::op(x[i * xEws], compatibleExtraParams), compatibleExtraParams);
+      }
+    }
+  };
+
+  maxThreads = samediff::Threads::parallel_for(func, 0, length, 1, maxThreads);
+
+  for (int e = 1; e < maxThreads; e++)
+    intermediate[0] = OpType::update(intermediate[0], intermediate[e], compatibleExtraParams);
+
+  Z result = OpType::postProcess(intermediate[0], length, compatibleExtraParams);
+  return result;
+}
+
+template <typename X, typename Z>
+template <typename OpType>
+void SD_HOST ReduceLongFunction<X, Z>::exec(sd::memory::Workspace *workspace, const void *vx,
+                                            const sd::LongType *xShapeInfo, void *vextraParams, void *vz,
+                                            const sd::LongType *zShapeInfo, const sd::LongType *dims) {
+  const X *x = reinterpret_cast<const X *>(vx);
+  Z *z = reinterpret_cast<Z *>(vz);
+
+  // For reduce_long operations like MatchCondition, extraParams contain comparison values
+  // (e.g., compare value, epsilon) that must remain in input type X, not be converted to Z.
+  // Converting double→LongType would corrupt the comparison values.
+  auto compatibleExtraParams = reinterpret_cast<X*>(vextraParams);
+
+  const int xRank = shape::rank(xShapeInfo);
+  const int zRank = shape::rank(zShapeInfo);
+
+
+  if (sd::ArrayOptions::arrayType(xShapeInfo) == sd::ArrayType::EMPTY) {
+    const auto startingVal = static_cast<Z>(OpType::startingValue(x));
+    const auto zLen = shape::length(zShapeInfo);
+
+    for (sd::LongType i = 0; i < zLen; i++) z[i] = startingVal;
+    return;
+  }
+
+  if (shape::length(zShapeInfo) == 1) {
+    z[0] = execScalar<OpType>(x, xShapeInfo, vextraParams);
+    return;
+  }
+
+  if (OpType::requiresSpecialAccumulation) {
+    // For execSpecial, use original LongType* extraParams as expected by that API
+    auto originalParams = reinterpret_cast<sd::LongType *>(vextraParams);
+    OpType::execSpecial(x, xShapeInfo, originalParams, z, zShapeInfo, const_cast<sd::LongType *>(dims) + zRank,
+                        xRank - zRank, nullptr, nullptr);
+    return;
+  }
+  // Call ReductionLongLoops with properly typed X* extraParams
+  sd::ReductionLongLoops<X, Z>::template innerloopReduce<OpType>(workspace, x, xShapeInfo, z, zShapeInfo, dims, compatibleExtraParams);
+
+}
+
+template <typename X, typename Z>
+void ReduceLongFunction<X, Z>::exec(const int opNum, sd::memory::Workspace *workspace, const void *vx,
+                                    const sd::LongType *xShapeInfo, void *vextraParams, void *vz,
+                                    const sd::LongType *zShapeInfo,  sd::LongType *dims) {
+
+  DISPATCH_BY_OPNUM_TT(exec, PARAMS(workspace, vx, xShapeInfo, vextraParams, vz, zShapeInfo, dims), REDUCE_LONG_OPS);
+}
+
+}  // namespace reduce
+}  // namespace functions

libnd4j/include/loops/cpu/reduce/reduce_same.hpp

@@ -0,0 +1,204 @@
+/* ******************************************************************************
+ *
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License, Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ *  See the NOTICE file distributed with this work for additional
+ *  information regarding copyright ownership.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+ * the License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ******************************************************************************/
+
+//
+//  @author raver119@gmail.com
+//  @author Yurii Shyrma (iuriish@yahoo.com)
+//
+#include <helpers/ConstantTadHelper.h>
+#include <helpers/Loops.h>
+#include <helpers/OmpLaunchHelper.h>
+#include <loops/legacy_ops.h>
+#include <loops/reduce_same.h>
+#include <system/op_boilerplate.h>
+#include <types/types.h>
+
+#include <chrono>
+
+using namespace simdOps;
+
+namespace functions {
+namespace reduce {
+template <typename X>
+template <typename OpType>
+void SD_HOST ReduceSameFunction<X>::execScalar(const void *vx, const sd::LongType *xShapeInfo, void *vextraParams,
+                                               void *vz, const sd::LongType *zShapeInfo) {
+  auto x = reinterpret_cast<const X *>(vx);
+  auto z = reinterpret_cast<X *>(vz);
+  auto extraParams = reinterpret_cast<X *>(vextraParams);
+
+  const auto length = shape::length(xShapeInfo);
+
+  if (shape::isEmptyConst(xShapeInfo)) {
+    z[0] = OpType::startingValue(x);
+    return;
+  }
+
+  if (sd::ArrayOptions::arrayType(xShapeInfo) == sd::ArrayType::EMPTY) {
+    if (sd::ArrayOptions::arrayType(zShapeInfo) == sd::ArrayType::EMPTY) return;
+    const auto startingVal = OpType::startingValue(x);
+
+    for (sd::LongType i = 0; i < length; i++) {
+      z[i] = startingVal;
+    }
+    return;
+  }
+
+  auto startingValue = OpType::startingValue(x);
+  int maxThreads = sd::math::sd_min<int>(64, sd::Environment::getInstance().maxThreads());
+  X intermediate[64];
+
+  PRAGMA_OMP_SIMD
+  for (auto e = 0; e < maxThreads; e++) {
+    intermediate[e] = startingValue;
+  }
+
+  sd::LongType xRank = shape::rank(xShapeInfo);
+  sd::LongType* xShape = shape::shapeOf(xShapeInfo);
+  sd::LongType* xStride = shape::stride(xShapeInfo);
+  if(shape::isViewConst(xShapeInfo)) {
+    auto func = PRAGMA_THREADS_FOR {
+      for (auto i = start; i < stop; i++) {
+        sd::LongType coords[SD_MAX_RANK];
+        INDEX2COORDS(i, xRank, xShape, coords);
+        sd::LongType indexOffset;
+        COORDS2INDEX(xRank, xStride, coords, indexOffset);
+        intermediate[thread_id] = OpType::update(intermediate[thread_id], OpType::op(x[indexOffset], extraParams), extraParams);
+      }
+    };
+    maxThreads = samediff::Threads::parallel_for(func, 0, length, 1, maxThreads);
+    PRAGMA_OMP_SIMD
+    for (int e = 1; e < maxThreads; e++) {
+      intermediate[0] = OpType::update(intermediate[0], intermediate[e], extraParams);
+    }
+
+    z[0] = OpType::postProcess(intermediate[0], length, extraParams);
+  } else {
+    auto func = PRAGMA_THREADS_FOR {
+      for (auto i = start; i < stop; i++) {
+        intermediate[thread_id] = OpType::update(intermediate[thread_id], OpType::op(x[i], extraParams), extraParams);
+      }
+    };
+    maxThreads = samediff::Threads::parallel_for(func, 0, length, 1, maxThreads);
+    PRAGMA_OMP_SIMD
+    for (int e = 1; e < maxThreads; e++) {
+      intermediate[0] = OpType::update(intermediate[0], intermediate[e], extraParams);
+    }
+
+    z[0] = OpType::postProcess(intermediate[0], length, extraParams);
+  }
+
+}
+
+template <typename X>
+template <typename OpType>
+X SD_HOST ReduceSameFunction<X>::execScalar(const void *vx, const sd::LongType *xShapeInfo, void *vextraParams) {
+  auto x = reinterpret_cast<const X *>(vx);
+  auto extraParams = reinterpret_cast<X *>(vextraParams);
+
+  const sd::LongType length = shape::length(xShapeInfo);
+
+  if (shape::isEmptyConst(xShapeInfo)) {
+    return OpType::startingValue(x);
+  }
+
+  auto startingValue = OpType::startingValue(x);
+  sd::LongType xRank = shape::rank(xShapeInfo);
+  sd::LongType* xShape = shape::shapeOf(xShapeInfo);
+  sd::LongType* xStride = shape::stride(xShapeInfo);
+
+  for (sd::LongType i = 0; i < length; i++) {
+    sd::LongType coords[SD_MAX_RANK];
+    INDEX2COORDS(i, xRank, xShape, coords);
+    sd::LongType indexOffset;
+    COORDS2INDEX(xRank, xStride, coords, indexOffset);
+    startingValue = OpType::update(startingValue, OpType::op(x[indexOffset], extraParams), extraParams);
+  }
+  return OpType::postProcess(startingValue, length, extraParams);
+}
+
+template <typename X>
+X ReduceSameFunction<X>::execScalar(const int opNum, const void *x, const sd::LongType *xShapeInfo, void *extraParams) {
+  RETURNING_DISPATCH_BY_OPNUM_T(execScalar, PARAMS(x, xShapeInfo, extraParams), REDUCE_SAME_OPS);
+}
+
+template <typename X>
+void ReduceSameFunction<X>::execScalar(const int opNum, const void *x, const sd::LongType *xShapeInfo,
+                                       void *extraParams, void *z, const sd::LongType *zShapeInfo) {
+  DISPATCH_BY_OPNUM_T(execScalar, PARAMS(x, xShapeInfo, extraParams, z, zShapeInfo), REDUCE_SAME_OPS);
+}
+
+template <typename X>
+template <typename OpType>
+void SD_HOST ReduceSameFunction<X>::exec(const void *x, const sd::LongType *xShapeInfo, void *extraParams, void *vz,
+                                         const sd::LongType *zShapeInfo) {
+  auto z = reinterpret_cast<X *>(vz);
+  z[0] = execScalar<OpType>(x, xShapeInfo, extraParams);
+}
+
+template <typename X>
+template <typename OpType>
+void SD_HOST ReduceSameFunction<X>::exec(sd::memory::Workspace *workspace, const void *vx,
+                                         const sd::LongType *xShapeInfo, void *vextraParams, void *vz,
+                                         const sd::LongType *zShapeInfo, const sd::LongType *dims) {
+  const X *x = reinterpret_cast<const X *>(vx);
+  X *z = reinterpret_cast<X *>(vz);
+  X *extraParams = reinterpret_cast<X *>(vextraParams);
+
+  const sd::LongType xRank = shape::rank(xShapeInfo);
+  const sd::LongType zRank = shape::rank(zShapeInfo);
+
+  if (sd::ArrayOptions::arrayType(xShapeInfo) == sd::ArrayType::EMPTY) {
+    const auto startingVal = OpType::startingValue(x);
+    const auto zLen = shape::length(zShapeInfo);
+    if (z != nullptr) {
+      for (sd::LongType i = 0; i < zLen; i++) {
+        z[i] = startingVal;
+      }
+    }
+    return;
+  }
+
+  if (shape::length(zShapeInfo) == 1) {
+    z[0] = execScalar<OpType>(x, xShapeInfo, extraParams);
+    return;
+  }
+
+  if (OpType::requiresSpecialAccumulation) {
+    OpType::execSpecial(x, xShapeInfo, extraParams, z, zShapeInfo, const_cast<sd::LongType *>(dims) + zRank,
+                        xRank - zRank, nullptr, nullptr);
+    return;
+  }
+
+#ifdef SD_LOOPS_INLINED
+  sd::ReductionLoops<X, X, X>::template loopReduce<OpType>(workspace, x, xShapeInfo, z, zShapeInfo, dims, extraParams);
+#else
+  sd::ReductionSameLoops<X>::template innerloopReduce<OpType>(workspace, x, xShapeInfo, z, zShapeInfo, dims, extraParams);
+#endif
+}
+
+template <typename X>
+void ReduceSameFunction<X>::exec(int opNum, sd::memory::Workspace *workspace, const void *vx,
+                                 const sd::LongType *xShapeInfo, void *vextraParams, void *vz,
+                                 const sd::LongType *zShapeInfo, const sd::LongType *dims) {
+  DISPATCH_BY_OPNUM_T(exec, PARAMS(workspace, vx, xShapeInfo, vextraParams, vz, zShapeInfo, dims), REDUCE_SAME_OPS);
+}
+
+
+}  // namespace reduce
+}  // namespace functions