From 31674ff87e97352d9b9744052052caffedf47882 Mon Sep 17 00:00:00 2001
From: zhangyang2057 <zhangyang@canaan-creative.com>
Date: Tue, 2 Dec 2025 16:11:09 +0800
Subject: [PATCH 1/3] Refactor ntt cast.

---
 .../nncase/ntt/arch/riscv64/ukernels.h        | 178 ++++++++++++++++
 ntt/include/nncase/ntt/kernels/cast.h         | 193 +++---------------
 ntt/include/nncase/ntt/ukernels/u_cast.h      |  95 ++-------
 3 files changed, 220 insertions(+), 246 deletions(-)

diff --git a/ntt/include/nncase/ntt/arch/riscv64/ukernels.h b/ntt/include/nncase/ntt/arch/riscv64/ukernels.h
index 162e298912..5f83ef32f7 100644
--- a/ntt/include/nncase/ntt/arch/riscv64/ukernels.h
+++ b/ntt/include/nncase/ntt/arch/riscv64/ukernels.h
@@ -547,6 +547,7 @@ template <reduce_op Op, class T> struct u_reduce_policy<Op, T, true> {
     static constexpr size_t unroll = 8;
 };
 
+#if 0
 // cast
 template <> struct u_cast_policy<true> {
     static constexpr size_t unroll = 8;
@@ -899,6 +900,183 @@ DEFINE_U_CAST_2_1(half, 16, float_e4m3_t, 8, _Float16, int8_t, f16, float8e4m3)
 DEFINE_U_CAST_1_2(half, 16, float, 32, _Float16, float, float16, f32)
 #if defined(NNCASE_XPU_MODULE) && defined(SYS_MODE)
 DEFINE_U_CAST_1_2(float_e4m3_t, 8, half, 16, int8_t, _Float16, float8e4m3, f16)
+#endif
+#else
+// cast
+template <> struct u_cast_policy<true> {
+    static constexpr size_t unroll = 8;
+};
+
+#define DEFINE_U_CAST_2_1(IN_ELEM, IN_BW, OUT_ELEM, OUT_BW, IN_BUILTIN_ELEM,               \
+                          OUT_BUILTIN_ELEM, IN_INTRINSIC_ELEM,                             \
+                          OUT_INTRINSIC_ELEM)                                              \
+    template <template <class> class TPostOps, class Stride>                               \
+    struct u_cast<true, vector<IN_ELEM, 2, NTT_VLEN / IN_BW>,                              \
+                  vector<OUT_ELEM, NTT_VLEN / OUT_BW>, TPostOps, Stride> {                 \
+      public:                                                                              \
+        using T2Elem = OUT_ELEM;                                                           \
+        using T1 = vector<IN_ELEM, 2, NTT_VLEN / IN_BW>;                                   \
+        using T2 = vector<OUT_ELEM, NTT_VLEN / OUT_BW>;                                    \
+        constexpr static size_t in_offset_scale = 2;                                       \
+                                                                                           \
+        constexpr void operator()(const T1 *input, Stride input_stride,                    \
+                                  T2 *output,                                              \
+                                  [[maybe_unused]] Stride output_stride,                   \
+                                  size_t count) noexcept {                                 \
+            using policy_t = u_cast_policy<true>;                                          \
+            constexpr auto unroll = policy_t::unroll;                                      \
+            while (count / unroll) {                                                       \
+                auto v0 = ntt::cast_elem<T2Elem>(*(input + 0 * input_stride));             \
+                auto v2 = ntt::cast_elem<T2Elem>(*(input + 1 * input_stride));             \
+                auto v4 = ntt::cast_elem<T2Elem>(*(input + 2 * input_stride));             \
+                auto v6 = ntt::cast_elem<T2Elem>(*(input + 3 * input_stride));             \
+                auto v8 = ntt::cast_elem<T2Elem>(*(input + 4 * input_stride));             \
+                auto v10 = ntt::cast_elem<T2Elem>(*(input + 5 * input_stride));            \
+                auto v12 = ntt::cast_elem<T2Elem>(*(input + 6 * input_stride));            \
+                auto v14 = ntt::cast_elem<T2Elem>(*(input + 7 * input_stride));            \
+                                                                                           \
+                v0 = TPostOps<vector<OUT_ELEM, NTT_VLEN / OUT_BW>>()(v0);                  \
+                v2 = TPostOps<vector<OUT_ELEM, NTT_VLEN / OUT_BW>>()(v2);                  \
+                v4 = TPostOps<vector<OUT_ELEM, NTT_VLEN / OUT_BW>>()(v4);                  \
+                v6 = TPostOps<vector<OUT_ELEM, NTT_VLEN / OUT_BW>>()(v6);                  \
+                v8 = TPostOps<vector<OUT_ELEM, NTT_VLEN / OUT_BW>>()(v8);                  \
+                v10 = TPostOps<vector<OUT_ELEM, NTT_VLEN / OUT_BW>>()(v10);                \
+                v12 = TPostOps<vector<OUT_ELEM, NTT_VLEN / OUT_BW>>()(v12);                \
+                v14 = TPostOps<vector<OUT_ELEM, NTT_VLEN / OUT_BW>>()(v14);                \
+                                                                                           \
+                asm volatile("vs1r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m1_t)v0),   \
+                             "r"(output + 0 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs1r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m1_t)v2),   \
+                             "r"(output + 1 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs1r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m1_t)v4),   \
+                             "r"(output + 2 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs1r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m1_t)v6),   \
+                             "r"(output + 3 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs1r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m1_t)v8),   \
+                             "r"(output + 4 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs1r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m1_t)v10),  \
+                             "r"(output + 5 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs1r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m1_t)v12),  \
+                             "r"(output + 6 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs1r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m1_t)v14),  \
+                             "r"(output + 7 * output_stride)                               \
+                             : "memory");                                                  \
+                output += unroll;                                                          \
+                input += unroll;                                                           \
+                count -= unroll;                                                           \
+            }                                                                              \
+                                                                                           \
+            for (size_t i = 0; i < count; i++) {                                           \
+                auto v0 = ntt::cast_elem<T2Elem>(*input);                                  \
+                v0 = TPostOps<vector<OUT_ELEM, NTT_VLEN / OUT_BW>>()(v0);                  \
+                asm volatile("vs1r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m1_t)v0),   \
+                             "r"(output)                                                   \
+                             : "memory");                                                  \
+                input += input_stride;                                                     \
+                output += output_stride;                                                   \
+            }                                                                              \
+        }                                                                                  \
+    };
+
+DEFINE_U_CAST_2_1(float, 32, half, 16, float, _Float16, f32, float16)
+#if defined(NNCASE_XPU_MODULE) && defined(SYS_MODE)
+DEFINE_U_CAST_2_1(half, 16, float_e4m3_t, 8, _Float16, int8_t, f16, float8e4m3)
+#endif
+
+
+#define DEFINE_U_CAST_1_2(IN_ELEM, IN_BW, OUT_ELEM, OUT_BW, IN_BUILTIN_ELEM,                 \
+                          OUT_BUILTIN_ELEM, IN_INTRINSIC_ELEM,                               \
+                          OUT_INTRINSIC_ELEM)                                                \
+    template <template <class> class TPostOps, class Stride>                                 \
+    struct u_cast<true, vector<IN_ELEM, NTT_VLEN / IN_BW>,                                   \
+                  vector<OUT_ELEM, 2 * NTT_VLEN / OUT_BW>, TPostOps, Stride> {               \
+        constexpr void                                                                       \
+        operator()(const vector<IN_ELEM, NTT_VLEN / IN_BW> *input,                           \
+                   [[maybe_unused]] Stride input_stride,                                     \
+                   vector<OUT_ELEM, 2 * NTT_VLEN / OUT_BW> *output,                          \
+                   Stride output_stride, size_t count) noexcept {                            \
+            using policy_t = u_cast_policy<true>;                                            \
+            constexpr auto unroll = policy_t::unroll;                                        \
+            constexpr auto half_unroll = unroll / 2;                                         \
+                                                                                             \
+            using T2Elem = OUT_ELEM;                                                         \
+            using T1 = vector<IN_ELEM, NTT_VLEN / IN_BW>;                                    \
+            using T2 = vector<OUT_ELEM, 2 * NTT_VLEN / OUT_BW>;                              \
+            [[maybe_unused]] constexpr static size_t out_offset_scale = 2;                   \
+                                                                                             \
+            while (count / unroll) {                                                         \
+                constexpr auto vl_in = NTT_VLEN / IN_BW;                                     \
+                constexpr auto vl_out = 2 * NTT_VLEN / OUT_BW;                               \
+                auto v0 = ntt::cast_elem<T2Elem>(*(input + 0 * input_stride));             \
+                auto v2 = ntt::cast_elem<T2Elem>(*(input + 1 * input_stride));             \
+                auto v4 = ntt::cast_elem<T2Elem>(*(input + 2 * input_stride));             \
+                auto v6 = ntt::cast_elem<T2Elem>(*(input + 3 * input_stride));             \
+                auto v8 = ntt::cast_elem<T2Elem>(*(input + 4 * input_stride));             \
+                auto v10 = ntt::cast_elem<T2Elem>(*(input + 5 * input_stride));            \
+                auto v12 = ntt::cast_elem<T2Elem>(*(input + 6 * input_stride));            \
+                auto v14 = ntt::cast_elem<T2Elem>(*(input + 7 * input_stride));            \
+                                                                                           \
+                v0 = TPostOps<vector<OUT_ELEM, 2, NTT_VLEN / OUT_BW>>()(v0);               \
+                v2 = TPostOps<vector<OUT_ELEM, 2, NTT_VLEN / OUT_BW>>()(v2);               \
+                v4 = TPostOps<vector<OUT_ELEM, 2, NTT_VLEN / OUT_BW>>()(v4);               \
+                v6 = TPostOps<vector<OUT_ELEM, 2, NTT_VLEN / OUT_BW>>()(v6);               \
+                v8 = TPostOps<vector<OUT_ELEM, 2, NTT_VLEN / OUT_BW>>()(v8);               \
+                v10 = TPostOps<vector<OUT_ELEM, 2, NTT_VLEN / OUT_BW>>()(v10);             \
+                v12 = TPostOps<vector<OUT_ELEM, 2, NTT_VLEN / OUT_BW>>()(v12);             \
+                v14 = TPostOps<vector<OUT_ELEM, 2, NTT_VLEN / OUT_BW>>()(v14);             \
+                                                                                           \
+                asm volatile("vs2r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m2_t)v0),   \
+                             "r"(output + 0 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs2r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m2_t)v2),   \
+                             "r"(output + 1 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs2r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m2_t)v4),   \
+                             "r"(output + 2 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs2r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m2_t)v6),   \
+                             "r"(output + 3 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs2r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m2_t)v8),   \
+                             "r"(output + 4 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs2r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m2_t)v10),  \
+                             "r"(output + 5 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs2r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m2_t)v12),  \
+                             "r"(output + 6 * output_stride)                               \
+                             : "memory");                                                  \
+                asm volatile("vs2r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m2_t)v14),  \
+                             "r"(output + 7 * output_stride)                               \
+                             : "memory");                                                  \
+                input += unroll;                                                           \
+                output += unroll;                                                          \
+                count -= unroll;                                                           \
+            }                                                                              \
+            for (size_t i = 0; i < count; i++) {                                           \
+                auto v0 = ntt::cast_elem<T2Elem>(*input);                                  \
+                v0 = TPostOps<vector<OUT_ELEM, 2 * NTT_VLEN / OUT_BW>>()(v0);              \
+                asm volatile("vs2r.v %0, (%1);" ::"vr"((v##OUT_INTRINSIC_ELEM##m2_t)v0),   \
+                             "r"(output)                                                   \
+                             : "memory");                                                  \
+                input += input_stride;                                                     \
+                output += output_stride;                                                   \
+            }                                                                              \
+        }                                                                                  \
+    };
+
+DEFINE_U_CAST_1_2(half, 16, float, 32, _Float16, float, float16, float32)
+#if defined(NNCASE_XPU_MODULE) && defined(SYS_MODE)
+DEFINE_U_CAST_1_2(float_e4m3_t, 8, half, 16, int8_t, _Float16, float8e4m3, f16)
+#endif
+
 #endif
 
 template <Scalar TProbs, Scalar TIndices, size_t Rank, size_t Axis, bool Norm>
diff --git a/ntt/include/nncase/ntt/kernels/cast.h b/ntt/include/nncase/ntt/kernels/cast.h
index bba36a1b3c..a36da2e7e3 100644
--- a/ntt/include/nncase/ntt/kernels/cast.h
+++ b/ntt/include/nncase/ntt/kernels/cast.h
@@ -25,8 +25,7 @@
 
 namespace nncase::ntt {
 namespace detail {
-template <Tensor TIn, Tensor TOut, FixedDimensions VectorizedAxes,
-          template <class> class TPostOp>
+template <Tensor TIn, Tensor TOut, template <class> class TPostOp>
 class cast_impl {
     inline static constexpr size_t rank = TIn::rank();
     // !! For vector<bool>, the element counts must be same as the other cast
@@ -55,179 +54,41 @@ class cast_impl {
                                                                 : (size_t)1;
     inline static constexpr auto
         out_offset_scale = scale > 1.0f ? (size_t)1 : (size_t)(1.0f / scale);
-    inline static constexpr auto axis =
-        VectorizedAxes::rank() == 1 ? VectorizedAxes{}.at(0) : 0_dim;
 
   public:
-    constexpr void operator()(const TIn &input, TOut &output,
-                              const VectorizedAxes &) noexcept {
-
-        constexpr auto vectorizedAxes = VectorizedAxes{};
-        static_assert(vectorizedAxes.rank() == 0 || vectorizedAxes.rank() == 1,
-                      "vectorizedAxes rank for cast must be 0 or 1");
-
+    constexpr void operator()(const TIn &input, TOut &output) noexcept {
+        constexpr auto rank = TIn::rank();
         auto input_conti_dims = contiguous_dims(input.shape(), input.strides());
         auto output_conti_dims =
             contiguous_dims(output.shape(), output.strides());
-
-        auto input_stride = vectorizedAxes.rank() == 1
-                                ? input.strides()[vectorizedAxes.at(0)]
-                                : 1;
-        auto output_stride = vectorizedAxes.rank() == 1
-                                 ? output.strides()[vectorizedAxes.at(0)]
-                                 : 1;
-
-        constexpr auto rank = TIn::rank();
-        auto pack_dims = rank + 1;
-        if (vectorizedAxes.rank() != 0)
-            pack_dims = rank - vectorizedAxes.at(0) - 1;
         auto conti_dims = std::min(input_conti_dims, output_conti_dims);
-
-        bool opted = (conti_dims >= pack_dims) ||
-                     (pack_dims == 0_dim && conti_dims > 0_dim);
-        auto apply_dim = pack_dims == 0_dim ? conti_dims : pack_dims;
-
-        if (opted) {
-
-            if constexpr (in_offset_scale > 1 && out_offset_scale == 1) {
-
-                auto apply_out_shape = generate_shape<rank>([&](auto i) {
-                    if (i > rank - apply_dim - 1)
-                        return (dim_t)1;
-                    else
-                        return (dim_t)output.shape()[i];
-                });
-
-                auto inner_out_shape = generate_shape<rank>([&](auto i) {
-                    if (i > rank - apply_dim - 1)
-                        return (dim_t)output.shape()[i];
-                    else
-                        return (dim_t)1_dim;
-                });
-
-                ntt::apply(apply_out_shape, [&](auto index) {
-                    auto in_index = index;
-                    if constexpr (vectorizedAxes.rank() == 1)
-                        in_index[fixed_dim_v<vectorizedAxes.at(0)>] *=
-                            in_offset_scale;
-                    auto in_ptr = &input(in_index);
-                    auto out_ptr = &output(index);
-                    auto len = inner_out_shape.length();
-                    ntt::u_cast<in_offset_scale, out_offset_scale, TPostOp>(
-                        in_ptr, input_stride, out_ptr, output_stride, len);
-                });
-
-            } else if constexpr (in_offset_scale == 1 && out_offset_scale > 1) {
-
-                auto apply_in_shape = generate_shape<rank>([&](auto i) {
-                    if (i > rank - apply_dim - 1)
-                        return (dim_t)1;
-                    else
-                        return (dim_t)input.shape()[i];
-                });
-
-                auto inner_in_shape = generate_shape<rank>([&](auto i) {
-                    if (i > rank - apply_dim - 1)
-                        return (dim_t)input.shape()[i];
-                    else
-                        return (dim_t)1_dim;
-                });
-
-                ntt::apply(apply_in_shape, [&](auto index) {
-                    auto out_index = index;
-                    if constexpr (vectorizedAxes.rank() == 1)
-                        out_index[fixed_dim_v<vectorizedAxes.at(0)>] *=
-                            out_offset_scale;
-
-                    auto in_ptr = &input(index);
-                    auto out_ptr = &output(out_index);
-                    auto len = inner_in_shape.length();
-                    ntt::u_cast<in_offset_scale, out_offset_scale, TPostOp>(
-                        in_ptr, input_stride, out_ptr, output_stride, len);
-                });
-            } else {
-
-                auto apply_out_shape = generate_shape<rank>([&](auto i) {
-                    if (i > rank - apply_dim - 1)
-                        return (dim_t)1;
-                    else
-                        return (dim_t)output.shape()[i];
-                });
-
-                auto inner_out_shape = generate_shape<rank>([&](auto i) {
-                    if (i > rank - apply_dim - 1)
-                        return (dim_t)output.shape()[i];
-                    else
-                        return (dim_t)1_dim;
-                });
-
-                ntt::apply(apply_out_shape, [&](auto index) {
-                    auto in_index = index;
-                    if constexpr (vectorizedAxes.rank() == 1)
-                        in_index[fixed_dim_v<vectorizedAxes.at(0)>] *=
-                            in_offset_scale;
-                    auto in_ptr = &input(in_index);
-                    auto out_ptr = &output(index);
-                    auto len = inner_out_shape.length();
-                    ntt::u_cast<in_offset_scale, out_offset_scale, TPostOp>(
-                        in_ptr, 1, out_ptr, 1, len);
-                });
-            }
-        } else {
-            if constexpr (in_offset_scale > 1 && out_offset_scale == 1) {
-                ntt::apply(output.shape(), [&](auto index) {
-                    auto in_index = index;
-                    if constexpr (vectorizedAxes.rank() == 1)
-                        in_index[fixed_dim_v<vectorizedAxes.at(0)>] *=
-                            in_offset_scale;
-                    prepend_lanes_t<InElemType, in_offset_scale> in_temp{};
-                    ntt::loop<in_offset_scale>([&](auto i) {
-                        in_temp(i) = input(in_index);
-                        if constexpr (vectorizedAxes.rank() == 1) {
-                            in_index[fixed_dim_v<vectorizedAxes.at(0)>] += 1;
-                        }
-                    });
-                    output(index) =
-                        ntt::cast_elem<element_or_scalar_t<OutElemType>>(
-                            in_temp);
-                    output(index) = TPostOp<OutElemType>()(output(index));
-                });
-            } else if constexpr (in_offset_scale == 1 && out_offset_scale > 1) {
-                ntt::apply(input.shape(), [&](auto index) {
-                    auto out_index = index;
-                    if constexpr (vectorizedAxes.rank() == 1)
-                        out_index[fixed_dim_v<vectorizedAxes.at(0)>] *=
-                            out_offset_scale;
-
-                    auto tmp_output =
-                        ntt::cast_elem<element_or_scalar_t<OutElemType>>(
-                            input(index));
-                    ntt::loop<out_offset_scale>([&](auto s) {
-                        output(out_index) = tmp_output(s);
-                        output(out_index) =
-                            TPostOp<OutElemType>()(output(out_index));
-                        if constexpr (vectorizedAxes.rank() == 1)
-                            out_index[fixed_dim_v<vectorizedAxes.at(0)>] += 1;
-                    });
-                });
-            } else {
-                ntt::apply(input.shape(), [&](auto index) {
-                    output(index) =
-                        ntt::cast_elem<element_or_scalar_t<OutElemType>>(
-                            input(index));
-                    output(index) = TPostOp<OutElemType>()(output(index));
-                });
-            }
-        }
+        auto outer_shape = generate_shape<rank>([&](auto i) {
+            if (i > rank - conti_dims - 1)
+                return (dim_t)1;
+            else
+                return (dim_t)output.shape()[i];
+        });
+
+        auto inner_shape = generate_shape<rank>([&](auto i) {
+            if (i > rank - conti_dims - 1)
+                return (dim_t)output.shape()[i];
+            else
+                return (dim_t)1_dim;
+        });
+
+        auto len = inner_shape.length();
+        ntt::apply(outer_shape, [&](auto index) {
+            auto in_ptr = &input(index);
+            auto out_ptr = &output(index);
+            ntt::u_cast<TPostOp>(in_ptr, 1, out_ptr, 1, len);
+        });
     }
 };
 } // namespace detail
 
-template <template <class> class TPostOp = DefaultPostOp, Tensor TIn,
-          Tensor TOut, FixedDimensions VectorizedAxes = shape_t<>>
-void cast(const TIn &input, TOut &&output,
-          const VectorizedAxes &vectorizedAxes = {}) noexcept {
-    detail::cast_impl<TIn, std::decay_t<TOut>, VectorizedAxes, TPostOp> impl;
-    impl(input, output, vectorizedAxes);
+template <template <class> class TPostOp = DefaultPostOp, Tensor TIn, Tensor TOut>
+void cast(const TIn &input, TOut &&output) noexcept {
+    detail::cast_impl<TIn, std::decay_t<TOut>, TPostOp> impl;
+    impl(input, output);
 }
 } // namespace nncase::ntt
diff --git a/ntt/include/nncase/ntt/ukernels/u_cast.h b/ntt/include/nncase/ntt/ukernels/u_cast.h
index a23d775cf4..b70b56c1dd 100644
--- a/ntt/include/nncase/ntt/ukernels/u_cast.h
+++ b/ntt/include/nncase/ntt/ukernels/u_cast.h
@@ -25,8 +25,7 @@ template <bool Arch> struct u_cast_policy {
     static constexpr size_t unroll = 2;
 };
 
-template <bool Arch, size_t in_offset_scale, size_t out_offset_scale, class T1,
-          class T2, template <class> class TPostOps, class Stride>
+template <bool Arch, class T1, class T2, template <class> class TPostOps, class Stride>
 struct u_cast {
   public:
     using T2Elem = element_or_scalar_t<T2>;
@@ -35,95 +34,31 @@ struct u_cast {
                               Stride output_stride, size_t count) noexcept {
         using policy_t = u_cast_policy<Arch>;
         constexpr auto unroll = policy_t::unroll;
-
-        if constexpr (in_offset_scale > 1 && out_offset_scale == 1) {
-            while (count / unroll) {
-                for (size_t i = 0; i < unroll; i++) {
-                    prepend_lanes_t<T1, in_offset_scale> in_temp{};
-                    auto in_ptr = input;
-                    ntt::loop<in_offset_scale>([&](auto s) {
-                        in_temp(s) = *(in_ptr + s * input_stride);
-                    });
-                    *output = ntt::cast_elem<T2Elem>(in_temp);
-                    (*output) = TPostOps<T2>()(*output);
-                    output += 1;
-                    input += ntt::where(input_stride == 1, in_offset_scale, 1);
-                    count--;
-                }
-            }
-
-            for (size_t i = 0; i < count; i++) {
-                prepend_lanes_t<T1, in_offset_scale> in_temp{};
-                auto in_ptr = input;
-                ntt::loop<in_offset_scale>(
-                    [&](auto s) { in_temp(s) = *(in_ptr + s * input_stride); });
-                *output = ntt::cast_elem<T2Elem>(in_temp);
-                (*output) = TPostOps<T2>()(*output);
-                output += 1;
-                input += ntt::where(input_stride == 1, in_offset_scale, 1);
-            }
-
-        } else if constexpr (in_offset_scale == 1 && out_offset_scale > 1) {
-            using value_type = typename T2::element_type;
-
-            while (count / unroll) {
-                for (size_t i = 0; i < unroll; i++) {
-                    auto tmp_output = ntt::cast_elem<T2Elem>(*input);
-                    auto out_ptr = output;
-                    ntt::loop<out_offset_scale>([&](auto s) {
-                        *out_ptr = tmp_output(s);
-                        (*out_ptr) = TPostOps<T2>()(*out_ptr);
-                        out_ptr += output_stride;
-                    });
-                    output +=
-                        ntt::where(output_stride == 1, out_offset_scale, 1);
-                    input += 1;
-                    count--;
-                }
-            }
-
-            for (size_t i = 0; i < count; i++) {
-                auto tmp_output = ntt::cast_elem<T2Elem>(*input);
-                auto out_ptr = output;
-                ntt::loop<out_offset_scale>([&](auto s) {
-                    *out_ptr = tmp_output(s);
-                    (*out_ptr) = TPostOps<T2>()(*out_ptr);
-                    out_ptr += output_stride;
-                });
-                output += ntt::where(output_stride == 1, out_offset_scale, 1);
-                input += 1;
-            }
-
-        } else {
-            while (count / unroll) {
-                for (size_t i = 0; i < unroll; i++) {
-                    *output = ntt::cast_elem<T2Elem>(*input);
-                    (*output) = TPostOps<T2>()(*output);
-                    input += input_stride * in_offset_scale;
-                    output += output_stride * out_offset_scale;
-                    count--;
-                }
-            }
-
-            for (size_t i = 0; i < count; i++) {
+        while (count / unroll) {
+            for (size_t i = 0; i < unroll; i++) {
                 *output = ntt::cast_elem<T2Elem>(*input);
                 (*output) = TPostOps<T2>()(*output);
-                input += input_stride * in_offset_scale;
-                output += output_stride * out_offset_scale;
+                input += input_stride;
+                output += output_stride;
+                count--;
             }
         }
+
+        for (size_t i = 0; i < count; i++) {
+            *output = ntt::cast_elem<T2Elem>(*input);
+            (*output) = TPostOps<T2>()(*output);
+            input += input_stride;
+            output += output_stride;
+        }
     }
 };
 } // namespace ukernels
 
-template <size_t in_offset_scale, size_t out_offset_scale,
-          template <class> class TPostOp = DefaultPostOp, class T1, class T2,
+template <template <class> class TPostOp = DefaultPostOp, class T1, class T2,
           class Stride>
 constexpr void u_cast(const T1 *input, Stride input_stride, T2 *output,
                       Stride output_stride, size_t count) noexcept {
-    ukernels::u_cast<true, in_offset_scale, out_offset_scale, T1, T2, TPostOp,
-                     Stride>
-        impl;
+    ukernels::u_cast<true, T1, T2, TPostOp, Stride> impl;
     impl(input, input_stride, output, output_stride, count);
 }
 } // namespace nncase::ntt

From 368f7e3842b545c23a984d13701fdd65313b737f Mon Sep 17 00:00:00 2001
From: zhangyang2057 <zhangyang2057@users.noreply.github.com>
Date: Tue, 2 Dec 2025 08:15:02 +0000
Subject: [PATCH 2/3] Apply code-format changes

---
 src/Nncase.Passes/Rules/Neutral/AddRangeOfAndMarker.cs          | 2 +-
 .../TestFixture/PagedAttentionKVCacheTestFixture.cs             | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Nncase.Passes/Rules/Neutral/AddRangeOfAndMarker.cs b/src/Nncase.Passes/Rules/Neutral/AddRangeOfAndMarker.cs
index a1ceaedb5e..6656ef6000 100644
--- a/src/Nncase.Passes/Rules/Neutral/AddRangeOfAndMarker.cs
+++ b/src/Nncase.Passes/Rules/Neutral/AddRangeOfAndMarker.cs
@@ -195,7 +195,7 @@ private IR.Tuple WrapLSTMOutput(Call call, int outputSize, bool configExist, boo
         {
             var outputNames = new List<string>();
             var getItem = IR.F.Tensors.GetItem(call, i);
-            outputNames.Add(call.Metadata.OutputNames?[i] ?? "LSTMOutput_" + i.ToString());
+            outputNames.Add(call.Metadata.OutputNames?[i] ?? ("LSTMOutput_" + i.ToString()));
             outputs[i].Metadata.OutputNames = outputNames;
         }
 
diff --git a/src/Nncase.Tests.TestFixture/TestFixture/PagedAttentionKVCacheTestFixture.cs b/src/Nncase.Tests.TestFixture/TestFixture/PagedAttentionKVCacheTestFixture.cs
index c738b347f3..0ed117a43e 100644
--- a/src/Nncase.Tests.TestFixture/TestFixture/PagedAttentionKVCacheTestFixture.cs
+++ b/src/Nncase.Tests.TestFixture/TestFixture/PagedAttentionKVCacheTestFixture.cs
@@ -75,7 +75,7 @@ public static OrtKISharp.Tensor ScaledDotProductAttention(OrtKISharp.Tensor quer
         var curLen = query.Shape[^2];
         var histLen = key.Shape[^2];
 
-        OrtKISharp.Tensor scaleFactor = scale ?? 1 / MathF.Sqrt(query.Length);
+        OrtKISharp.Tensor scaleFactor = scale ?? (1 / MathF.Sqrt(query.Length));
         scaleFactor = scaleFactor.Cast(query.DataType);
 
         var attnBias = OrtKI.Expand(OrtKISharp.Tensor.FromScalar(0f), OrtKISharp.Tensor.MakeTensor([curLen, histLen]));

From 1e9c90c2f56915e392c3690e6479fdb3b81ba644 Mon Sep 17 00:00:00 2001
From: zhangyang2057 <zhangyang@canaan-creative.com>
Date: Thu, 4 Dec 2025 21:03:58 +0800
Subject: [PATCH 3/3] Modify test.cpp/cast ctest.

---
 ntt/test/ctest/CMakeLists.txt                 |  28 +-
 ...enerate_binary_tests.py => binary_test.py} | 186 ++--
 .../{generate_cast_tests.py => cast_test.py}  | 342 +++----
 .../{generate_pack_tests.py => pack_test.py}  |  73 +-
 .../test_generator/test_generator_base.py     |  90 +-
 ...{generate_unary_tests.py => unary_test.py} |  75 +-
 ...enerate_unpack_tests.py => unpack_test.py} |  19 +-
 ntt/test/ctest/test_ntt_cast.cpp              | 929 +++++++-----------
 src/Native/src/test.cpp                       |  22 +-
 9 files changed, 766 insertions(+), 998 deletions(-)
 rename ntt/test/ctest/test_generator/{generate_binary_tests.py => binary_test.py} (95%)
 rename ntt/test/ctest/test_generator/{generate_cast_tests.py => cast_test.py} (57%)
 rename ntt/test/ctest/test_generator/{generate_pack_tests.py => pack_test.py} (92%)
 rename ntt/test/ctest/test_generator/{generate_unary_tests.py => unary_test.py} (94%)
 rename ntt/test/ctest/test_generator/{generate_unpack_tests.py => unpack_test.py} (95%)

diff --git a/ntt/test/ctest/CMakeLists.txt b/ntt/test/ctest/CMakeLists.txt
index aad700fa6b..4217a2ab26 100644
--- a/ntt/test/ctest/CMakeLists.txt
+++ b/ntt/test/ctest/CMakeLists.txt
@@ -18,10 +18,6 @@ include_directories(${CMAKE_CURRENT_LIST_DIR}/..)
 # --- Generate test source files ---
 # Define kernel names for automatic test generation. Add more kernels here.
 set(KERNEL_NAMES binary pack unpack cast unary)
-# set(KERNEL_NAMES binary pack unpack)
-# set(KERNEL_NAMES  pack unpack)
-# set(KERNEL_NAMES binary)
-# set(KERNEL_NAMES unary)
 
 # Set directories
 set(TEST_GENERATOR_DIR ${CMAKE_CURRENT_SOURCE_DIR}/test_generator)
@@ -53,15 +49,15 @@ endmacro()
 foreach(kernel ${KERNEL_NAMES})
     string(TOUPPER ${kernel} KERNEL_UPPER)
 
-    set(GENERATOR_SCRIPT ${TEST_GENERATOR_DIR}/generate_${kernel}_tests.py)
-    set(GENERATED_CMAKE ${GENERATED_DIR}/generated_${kernel}_tests.cmake)
+    set(GENERATOR_SCRIPT ${TEST_GENERATOR_DIR}/${kernel}_test.py)
+    set(GENERATED_CMAKE ${GENERATED_DIR}/${kernel}_test.cmake)
 
     if(EXISTS ${GENERATOR_SCRIPT})
         run_generator_if_needed(${GENERATOR_SCRIPT} ${GENERATED_CMAKE})
 
         if(EXISTS ${GENERATED_CMAKE})
             include(${GENERATED_CMAKE})
-            list(APPEND GENERATED_TEST_SOURCES ${GENERATED_${KERNEL_UPPER}_TEST_SOURCES})
+            list(APPEND GENERATED_TESTS ${${KERNEL_UPPER}_TESTS})
         endif()
     else()
         message(WARNING "Generator script for ${kernel} not found: ${GENERATOR_SCRIPT}")
@@ -78,22 +74,10 @@ macro(add_test_exec test_source_file)
 endmacro()
 
 file(GLOB HANDWRITTEN_TESTS CONFIGURE_DEPENDS
-    # generated/test_ntt_binary_generated_add_Uint16.cpp
     test_ntt_playground.cpp
-    # generated/test_ntt_binary_float16_pow_generated.cpp
-    # generated/test_ntt_binary_float32_floor_mod_generated.cpp
-    # generated/test_ntt_binary_float32_floor_mod_generated.cpp
-    # generated/test_ntt_binary_float16_floor_mod_generated.cpp
-    # generated/test_ntt_binary_float64_floor_mod_generated.cpp
-    # generated/test_ntt_binary_int16_floor_mod_generated.cpp
-    # generated/test_ntt_binary_float32_sub_generated.cpp
-    # generated/test_ntt_cast_from_bfloat16_generated.cpp
-    # generated/test_ntt_binary_uint8_sub_generated.cpp
-    # test_ntt_pack_generated_Uint64
     # test_ntt_binary_mul.cpp
     # test_ntt_binary_sub.cpp
     # test_ntt_cast.cpp
-
     # test_ntt_unary_abs.cpp
     test_ntt_clamp.cpp
     test_ntt_compare_equal.cpp
@@ -115,14 +99,10 @@ file(GLOB HANDWRITTEN_TESTS CONFIGURE_DEPENDS
     test_ntt_transpose.cpp
     test_ntt_unpack.cpp
     test_ntt_where.cpp
-    # test_ntt_cast_from_float32_generated.cpp
 )
 
 # Combine handwritten and generated tests
-list(APPEND TEST_NAMES ${HANDWRITTEN_TESTS} ${GENERATED_TEST_SOURCES})
-# list(APPEND TEST_NAMES ${HANDWRITTEN_TESTS} )
-# list(APPEND TEST_NAMES ${GENERATED_TEST_SOURCES} )
-
+list(APPEND TEST_NAMES ${HANDWRITTEN_TESTS} ${GENERATED_TESTS})
 
 foreach(test_file ${TEST_NAMES})
     add_test_exec(${test_file})
diff --git a/ntt/test/ctest/test_generator/generate_binary_tests.py b/ntt/test/ctest/test_generator/binary_test.py
similarity index 95%
rename from ntt/test/ctest/test_generator/generate_binary_tests.py
rename to ntt/test/ctest/test_generator/binary_test.py
index 95d01c1c19..068b6492a6 100644
--- a/ntt/test/ctest/test_generator/generate_binary_tests.py
+++ b/ntt/test/ctest/test_generator/binary_test.py
@@ -8,14 +8,14 @@
 class BinaryTestGenerator(BaseTestGenerator):
     def __init__(self):
         super().__init__()
-        
-        # ORT *binary operations* do not support these data types, need to cast to double 
+
+        # ORT *binary operations* do not support these data types, need to cast to double
         # fortunately, they could be *cast* in ort( fp8 are unfortunate)
         self.types_need_cast_in_ort = {
             "swishb": [ 'bool', 'uint8_t', 'uint16_t', 'uint32_t',
                     'uint64_t', 'int8_t', 'int16_t', 'bfloat16', 'half',
                       "int32_t", "int64_t",
-                    'float_e4m3_t', 'float_e5m2_t' 
+                    'float_e4m3_t', 'float_e5m2_t'
                    ],
 
             "default": [ 'bool',  'int8_t', 'int16_t', 'bfloat16', 'half',
@@ -23,7 +23,7 @@ def __init__(self):
                 ]
         }
         self.types_need_cast_in_ntt = {
-            'float_e4m3_t', 'float_e5m2_t' 
+            'float_e4m3_t', 'float_e5m2_t'
         }
 
         self.dims_specs_options = {
@@ -31,7 +31,7 @@ def __init__(self):
                 # Scalar broadcast
                 ([2, 3, 16, 16], [1])
             ],
-            
+
             "default": [
                 # No broadcast
                 ([2, 3, 16, 16], [2, 3, 16, 16]),
@@ -45,8 +45,8 @@ def __init__(self):
                 ([2, 1, 16, 1], [1, 3, 1, 16]),
             ]
         }
-        
-        
+
+
         # Define power operand ranges
         self.ALL_POW_OPRANDS = {
             "uint8_t": {"lhs_min": "0", "lhs_max": "3", "rhs_min": "0", "rhs_max": "3"},
@@ -70,8 +70,8 @@ def __init__(self):
 
 
 
-        self.integer_types = ['int8_t', 'int16_t', 'int32_t', 'int64_t', 'uint8_t', 'uint16_t', 'uint32_t', 'uint64_t'] 
-        
+        self.integer_types = ['int8_t', 'int16_t', 'int32_t', 'int64_t', 'uint8_t', 'uint16_t', 'uint32_t', 'uint64_t']
+
         self.ort_custom_function = {
             "ceil_div": self._generate_ort_ceil_div_function,
             "swishb": self._generate_ort_SwishB,
@@ -86,7 +86,7 @@ def __init__(self):
                             "static bool element_is_vec = ntt::Vector<typename decltype(ntt_input_lhs)::element_type>;\n" \
                             "   auto ort_output = ortki_inner_product(ort_input_lhs, ort_input_rhs, element_is_vec); " ,
             "outer_product":  \
-                            "   auto ort_output =ortki_Mul(ort_input_lhs, ort_input_rhs); " 
+                            "   auto ort_output =ortki_Mul(ort_input_lhs, ort_input_rhs); "
         }
         self.op_str_map_simplified = {
             "sub": f"auto ort_output = ortki_Sub(ort_input_lhs, ort_input_rhs);",
@@ -131,14 +131,14 @@ def _generate_ceil_div_operation(self, datatype):
         if datatype.cpp_type == "int64_t":
             var_type = "int64_t"
             value_str = "-1"
-        elif datatype.cpp_type not in types_to_cast: 
+        elif datatype.cpp_type not in types_to_cast:
             # Now only int32_t in this case
             var_type = "int32_t"
             value_str = "-1"
         else:
             var_type = "double"
             value_str = "-1.0f"
-        
+
         # Return the common template with variable substitution
         return (
             f"auto ntt_neg1 = make_tensor<{var_type}>(ntt::fixed_shape_v<1>);\n"
@@ -175,7 +175,7 @@ def _generate_ort_const_var_info(self, datatype, const_value, op_str):
     def _generate_ort_ceil_div_function(self, datatype):
         """Generate the ort_ceil_div function definition"""
         const_var_type, const_value_str = self._generate_ort_const_var_info(datatype, -1, "ceil_div")
-        
+
         return (
             f"static ortki::OrtKITensor* ort_ceil_div(ortki::OrtKITensor* ort_input_lhs, ortki::OrtKITensor* ort_input_rhs) {{\n"
             f"    auto ntt_neg1 = make_tensor<{const_var_type}>(ntt::fixed_shape_v<1>);\n"
@@ -218,12 +218,12 @@ def _generate_inner_product_operation(self, datatype):
     def _generate_ort_SwishB(self, datatype):
         """Generate the ortki_SwishB function definition"""
         const_var_type, const_value_str = self._generate_ort_const_var_info(datatype, 1, "swishb")
-        
+
         return (
             f"static ortki::OrtKITensor* ortki_SwishB(ortki::OrtKITensor* ort_input, ortki::OrtKITensor* beta_tensor) {{\n"
             f"    auto ntt_1_tensor = make_tensor<{const_var_type}>(ntt::fixed_shape_v<1>);\n"
             f"    ntt_1_tensor(0) = {const_value_str};\n"
-            "    auto ort_1 = NttTest::ntt2ort(ntt_1_tensor);\n"           
+            "    auto ort_1 = NttTest::ntt2ort(ntt_1_tensor);\n"
             "    auto ort_neg = ortki_Neg(ort_input);\n"
             "    auto ort_mul = ortki_Mul(ort_neg, beta_tensor);\n"
             "    auto ort_exp = ortki_Exp(ort_mul);\n"
@@ -233,7 +233,7 @@ def _generate_ort_SwishB(self, datatype):
         )
 
 
-    def _generate_aligned_ntt_scalar_input(self, ntt_op_str, datatype, input_var_name, var_name, 
+    def _generate_aligned_ntt_scalar_input(self, ntt_op_str, datatype, input_var_name, var_name,
                                    is_dynamic_shape, dims_spec, vector_rank, other_vector_rank):
         """Generate aligned NTT input tensors for fp8 operations"""
         """ normal case: tensor<vector<P>, axbxc> -> tensor<scalar, axbxcxP>
@@ -241,12 +241,12 @@ def _generate_aligned_ntt_scalar_input(self, ntt_op_str, datatype, input_var_nam
         """
         code = []
         aligned_dims = None
-        
+
         # Determine if tensors need alignment based on vector ranks
         need_alignment = vector_rank + other_vector_rank > 0
 
         #fistly unsqueeze
-        
+
         unsqueeze_dims = ""
         unpack_dims = ""
         if vector_rank >= other_vector_rank :
@@ -280,7 +280,7 @@ def _generate_aligned_ntt_scalar_input(self, ntt_op_str, datatype, input_var_nam
             if other_vector_rank == 1:
                 # this vector rank must be 0
                 unsqueeze_dims = f"{len(dims_spec)}"
-                unpack_dims = unsqueeze_dims    
+                unpack_dims = unsqueeze_dims
             else: # other_vector_rank == 2
                 # this vector rank should be 1 or 0
                 unsqueeze_dims = f"{len(dims_spec)}, {len(dims_spec)+1}"
@@ -314,32 +314,32 @@ def _prepare_double_input_alignment(self, code, datatype, lhs_is_dynamic_shape,
             lhs_is_dynamic_shape, lhs_dims_spec, lhs_continuity
         )
         code.extend(lhs_copy_code)
-        
+
         rhs_var_name, rhs_copy_code = self._prepare_contiguous_input(
             "ntt_input_rhs", datatype, rhs_vector_rank, rhs_vec_param,
             rhs_is_dynamic_shape, rhs_dims_spec, rhs_continuity
         )
         code.extend(rhs_copy_code)
-        
+
         """
         lhs_var_name = "ntt_input_lhs"
         rhs_var_name = "ntt_input_rhs"
         code.append("// align in NTT, then cast to double, then process in ORT")
-        
+
         # Determine if tensors need alignment based on vector ranks
         need_alignment = (lhs_vector_rank + rhs_vector_rank != 0 )
         # Initialize aligned dimensions to default values
         lhs_aligned_dims = lhs_dims_spec
         rhs_aligned_dims = rhs_dims_spec
-        
+
         if need_alignment:
             # 1.1.a for tensors pair that one of which is tensor of vector
             # Generate aligned lhs input
             lhs_code, lhs_aligned_dims = self._generate_aligned_ntt_scalar_input(
-                ntt_op_str, datatype, "ntt_input_lhs", lhs_var_name, lhs_is_dynamic_shape, 
+                ntt_op_str, datatype, "ntt_input_lhs", lhs_var_name, lhs_is_dynamic_shape,
                 lhs_dims_spec, lhs_vector_rank, rhs_vector_rank)
             code.extend(lhs_code)
-                
+
             # Generate aligned rhs input
             rhs_code, rhs_aligned_dims = self._generate_aligned_ntt_scalar_input(
                 ntt_op_str, datatype, "ntt_input_rhs", rhs_var_name, rhs_is_dynamic_shape,
@@ -350,18 +350,18 @@ def _prepare_double_input_alignment(self, code, datatype, lhs_is_dynamic_shape,
             code.append("// 1.1.b for tensors pair that are all tensor of scalar")
             code.append(f"auto ntt_input_lhs_aligned = ({lhs_var_name}).view();")
             code.append(f"auto ntt_input_rhs_aligned = ({rhs_var_name}).view();")
-        
+
         # 1.2 get ntt_lhs/rhs_double
         lhs_double_shape_expr = self.generate_shape_init(lhs_is_dynamic_shape, lhs_aligned_dims)
         rhs_double_shape_expr = self.generate_shape_init(rhs_is_dynamic_shape, rhs_aligned_dims)
-        
+
         code.append(f"// 1.2 get ntt_lhs/rhs_double")
         code.append(f"auto ntt_lhs_double = ntt::make_tensor<double>({lhs_double_shape_expr});")
         code.append(f"auto ntt_rhs_double = ntt::make_tensor<double>({rhs_double_shape_expr});")
         code.append("")
         code.append("ntt::cast(ntt_input_lhs_aligned, ntt_lhs_double);")
         code.append("ntt::cast(ntt_input_rhs_aligned, ntt_rhs_double);")
-        
+
         return lhs_aligned_dims, rhs_aligned_dims
 
     def _execute_ort_operation(self, code, datatype, ntt_op_str):
@@ -378,7 +378,7 @@ def _execute_ort_operation(self, code, datatype, ntt_op_str):
 
 
 
-    def _generate_ntt_cast_golden_output(self, datatype, 
+    def _generate_ntt_cast_golden_output(self, datatype,
                                    lhs_is_dynamic_shape, rhs_is_dynamic_shape,
                                    lhs_dims_spec, rhs_dims_spec,
                                    lhs_vector_rank, rhs_vector_rank,
@@ -399,7 +399,7 @@ def _generate_ntt_cast_golden_output(self, datatype,
         """
 
         code = []
-        
+
         # 1. Prepare input alignment and cast to double
         lhs_aligned_dims, rhs_aligned_dims = self._prepare_double_input_alignment(
             code, datatype, lhs_is_dynamic_shape, rhs_is_dynamic_shape,
@@ -407,12 +407,12 @@ def _generate_ntt_cast_golden_output(self, datatype,
             lhs_continuity, rhs_continuity, lhs_vec_param, rhs_vec_param,
             ntt_op_str
         )
-        
+
         # 2. Execute ORT operation
         ort_golden_double_var = self._execute_ort_operation(
             code, datatype, ntt_op_str
         )
-        
+
         # Calculate output shape for scalar tensor
         output_is_dynamic_shape, output_dims_spec = self.get_binary_output_shape(
             lhs_is_dynamic_shape, rhs_is_dynamic_shape, lhs_dims_spec, rhs_dims_spec)
@@ -422,14 +422,14 @@ def _generate_ntt_cast_golden_output(self, datatype,
 
         # 3. Process ORT output back to NTT format
         self._cast_ort_golden_double_into_ntt_shape(
-            code, datatype, ntt_op_str, output_is_dynamic_shape, 
-            output_dims_spec, output_vector_rank, 
+            code, datatype, ntt_op_str, output_is_dynamic_shape,
+            output_dims_spec, output_vector_rank,
             output_vec_param, ort_golden_double_var
         )
-        
+
         return code
 
-    def _generate_ort_cast_golden_output(self, datatype, 
+    def _generate_ort_cast_golden_output(self, datatype,
                                    lhs_is_dynamic_shape, rhs_is_dynamic_shape,
                                    lhs_dims_spec, rhs_dims_spec,
                                    lhs_vector_rank, rhs_vector_rank,
@@ -445,19 +445,21 @@ def _generate_ort_cast_golden_output(self, datatype,
         4. perform operation
         """
         code = []
-        
+
         # Check if datatype needs to be cast to float32
         need_cast_in_ort = self._need_cast_in_ort(datatype, ntt_op_str)
 
+        lhs_element_type = self.get_element_cpp_type(datatype.cpp_type, lhs_vector_rank, lhs_vec_param)
         lhs_var_name, lhs_copy_code = self._prepare_contiguous_input(
-            "ntt_input_lhs", datatype, lhs_vector_rank, lhs_vec_param,
+            "ntt_input_lhs", lhs_element_type,
             lhs_is_dynamic_shape, lhs_dims_spec, lhs_continuity
         )
         code.extend(lhs_copy_code)
         ntt2ort_lhs = lhs_var_name
 
+        rhs_element_type = self.get_element_cpp_type(datatype.cpp_type, rhs_vector_rank, rhs_vec_param)
         rhs_var_name, rhs_copy_code = self._prepare_contiguous_input(
-            "ntt_input_rhs", datatype, rhs_vector_rank, rhs_vec_param,
+            "ntt_input_rhs", rhs_element_type,
             rhs_is_dynamic_shape, rhs_dims_spec, rhs_continuity
         )
         code.extend(rhs_copy_code)
@@ -472,7 +474,7 @@ def _generate_ort_cast_golden_output(self, datatype,
         is_outer_product = "true" if ntt_op_str == "outer_product" else "false"
 
         code.extend([f"auto [ort_input_lhs, ort_input_rhs] = NttTest::convert_and_align_to_ort({ntt2ort_lhs},{ntt2ort_rhs}, {need_cast_str}, {is_outer_product});"])
- 
+
         code.extend(self.generate_ort_output(datatype, ntt_op_str))
 
         if need_cast_in_ort:
@@ -480,8 +482,8 @@ def _generate_ort_cast_golden_output(self, datatype,
             code.extend(cast_to_orig_type_code)
         else:
             code.append(f"auto ort_golden = ort_output;")
-            
-        
+
+
         cast_code, golden_var_name = self.generate_ort_back2ntt(
             datatype,
             output_element_type,
@@ -497,50 +499,50 @@ def is_div_operation(self) -> bool:
         result = (hasattr(self, 'ntt_op_str') and self.ntt_op_str in ["div", "mod", "floor_mod", "ceil_div"])
         return result
 
-    def generate_test_name(self, datatype, lhs_is_dynamic_shape, rhs_is_dynamic_shape, 
-        lhs_dims_spec, rhs_dims_spec, 
-        lhs_vector_rank, rhs_vector_rank, 
+    def generate_test_name(self, lhs_is_dynamic_shape, rhs_is_dynamic_shape,
+        lhs_dims_spec, rhs_dims_spec,
+        lhs_vector_rank, rhs_vector_rank,
         lhs_continuity, rhs_continuity, test_name_suffix):
-        
+
         parts = []
-        
+
         #1. datatype
-        parts.append(f"{datatype.name_suffix}")
-        
+        # parts.append(f"{datatype.name_suffix}")
+
         # 2.  lhs dynamic
         lhs_shape_type = "dynamic" if lhs_is_dynamic_shape else "fixed"
         parts.append(f"lhs_{lhs_shape_type}")
-        
+
         # lhs vector rank
         if lhs_vector_rank == 0:
             parts.append("scalar")
         else:
             parts.append(f"{lhs_vector_rank}D_vector")
-        
+
         #  contiguous->view, non_contiguous->raw_tensor
         if lhs_continuity.is_contiguous:
             parts.append("raw_tensor")
         else:
             op_str = "mul2" if lhs_continuity.big_tensor_op == "*2" else "add3" if lhs_continuity.big_tensor_op == "+3" else "add7"
             parts.append(f"view_{lhs_continuity.non_contiguous_dim}_{op_str}")
-        
+
         # 3. rhs
         rhs_shape_type = "dynamic" if rhs_is_dynamic_shape else "fixed"
         parts.append(f"rhs_{rhs_shape_type}")
-        
+
         # rhs vector rank
         if rhs_vector_rank == 0:
             parts.append("scalar")
         else:
             parts.append(f"{rhs_vector_rank}D_vector")
-        
+
         #  continuity
         if rhs_continuity.is_contiguous:
             parts.append("raw_tensor")
         else:
             op_str = "mul2" if rhs_continuity.big_tensor_op == "*2" else "add3" if rhs_continuity.big_tensor_op == "+3" else "add7"
             parts.append(f"view_dim{rhs_continuity.non_contiguous_dim}_{op_str}")
-        
+
         # 4. braodcast type
         if lhs_dims_spec == rhs_dims_spec:
             broadcast_info = "no_broadcast"
@@ -554,11 +556,11 @@ def generate_test_name(self, datatype, lhs_is_dynamic_shape, rhs_is_dynamic_shap
             broadcast_info = "rhs_1d_broadcast"  # 右操作数是一维张量广播
         else:
             broadcast_info = "multi_broadcast"  # 多维广播
-            
+
         parts.append(broadcast_info)
         if test_name_suffix:
             parts.append(test_name_suffix)
-        
+
         return "_".join(parts)
 
     def get_binary_output_shape(self, lhs_is_dynamic_shape, rhs_is_dynamic_shape,
@@ -573,15 +575,15 @@ def get_binary_output_shape(self, lhs_is_dynamic_shape, rhs_is_dynamic_shape,
         # Prepend 1s to the shorter shape to match the rank of the longer shape for broadcasting.
         rank_diff = len(longer_shape) - len(shorter_shape)
         padded_shorter_shape = [1] * rank_diff + shorter_shape
-        
+
         # Check for broadcasting compatibility.
         for dim1, dim2 in zip(longer_shape, padded_shorter_shape):
             assert dim1 == dim2 or min(dim1, dim2) == 1, \
                 f"Shapes {lhs_shape} and {rhs_shape} are not broadcast-compatible"
-        
+
         # The output shape is the element-wise maximum of the two shapes.
         output_shape = [max(dim1, dim2) for dim1, dim2 in zip(longer_shape, padded_shorter_shape)]
-        
+
         return output_is_dynamic_shape, output_shape
 
 
@@ -606,7 +608,7 @@ def _get_output_vector_rank(self, ntt_op_str, lhs_vector_rank, rhs_vector_rank):
                 return 2
         else:
             return max(lhs_vector_rank, rhs_vector_rank)
-        
+
     def _get_output_vec_param(self, ntt_op_str, lhs_vec_param, rhs_vec_param):
         """Determine the output pack parameter based on the operation type and input pack parameters."""
         if ntt_op_str == "outer_product":
@@ -614,7 +616,7 @@ def _get_output_vec_param(self, ntt_op_str, lhs_vec_param, rhs_vec_param):
             return (lhs_vec_param, rhs_vec_param)
         else:
             return lhs_vec_param if lhs_vec_param else rhs_vec_param
-    def generate_ntt_golden_output(self, datatype, 
+    def generate_ntt_golden_output(self, datatype,
                                     lhs_is_dynamic_shape, rhs_is_dynamic_shape,
                                     lhs_dims_spec, rhs_dims_spec,
                                     lhs_vector_rank, rhs_vector_rank,
@@ -623,11 +625,11 @@ def generate_ntt_golden_output(self, datatype,
                                     output_element_type, output_shape_expr,
                                     ntt_op_str):
         code = []
-        
+
         # Check if datatype needs special fp8 handling
         need_cast_in_ntt = datatype.cpp_type in self.types_need_cast_in_ntt
         golden_var_name = "ntt_golden"
-        
+
         if need_cast_in_ntt:
             # Special handling for fp8 types that cannot be cast in ORT
             code.extend(self._generate_ntt_cast_golden_output(
@@ -660,25 +662,25 @@ def generate_ntt_output_to_test(self, lhs_datatype, rhs_datatype,
         datatype = lhs_datatype  # Assume same datatype for both inputs
         # generate ntt_input_lhs, ntt_input_rhs, ntt_output
         code.append(f"{indent}//---init ntt_input_lhs---")
+        lhs_element_cpp_type = self.get_element_cpp_type(lhs_datatype.cpp_type, lhs_vector_rank, lhs_vec_param)
         tensor_init_lhs_code = self.generate_tensor_init( datatype=lhs_datatype,
             shape_type=lhs_is_dynamic_shape, dim_spec=lhs_dims_spec,
             continuity=lhs_continuity, var_name="ntt_input_lhs",
-            name_suffix="_lhs", vector_rank=lhs_vector_rank,
-            P=lhs_vec_param, integer_only= lhs_datatype.integer_only)
+            name_suffix="_lhs", element_cpp_type=lhs_element_cpp_type, integer_only= lhs_datatype.integer_only)
         code.extend([f"{indent}{line}" for line in tensor_init_lhs_code])
 
         code.append(f"{indent}//---init ntt_input_rhs---")
+        rhs_element_cpp_type = self.get_element_cpp_type(rhs_datatype.cpp_type, rhs_vector_rank, rhs_vec_param)
         tensor_init_rhs_code = self.generate_tensor_init( datatype=rhs_datatype,
             shape_type=rhs_is_dynamic_shape, dim_spec=rhs_dims_spec,
             continuity=rhs_continuity, var_name="ntt_input_rhs",
-            name_suffix="_rhs", vector_rank=rhs_vector_rank,
-            P=rhs_vec_param, integer_only= rhs_datatype.integer_only)
+            name_suffix="_rhs", element_cpp_type=rhs_element_cpp_type, integer_only= rhs_datatype.integer_only)
         code.extend([f"{indent}{line}" for line in tensor_init_rhs_code])
 
         output_is_dynamic_shape, output_dims_spec = self.get_binary_output_shape(
             lhs_is_dynamic_shape, rhs_is_dynamic_shape,
             lhs_dims_spec, rhs_dims_spec)
-        
+
         output_vector_rank = self._get_output_vector_rank( ntt_op_str, lhs_vector_rank, rhs_vector_rank)
         code.append(f"{indent}//---generate output tensor---")
 
@@ -706,7 +708,7 @@ def generate_ntt_output_to_test(self, lhs_datatype, rhs_datatype,
     # rhs_dynamic: bool, rhs is dynamic or fixed
     # lhs_shape: list[int], lhs shape, [1, 77, 3]
     # rhs_shape: list[int], rhs shape, [1, 77, 3]
-    # braodcast_ways: list[int], broadcast ways, 0: no_broadcast 1: lhs_to_rhs, 2: rhs_to_lhs, 
+    # braodcast_ways: list[int], broadcast ways, 0: no_broadcast 1: lhs_to_rhs, 2: rhs_to_lhs,
     # lhs_vector_ranks: list[int], lhs vector ranks, 0, 1, 2
     # rhs_vector_ranks: list[int], rhs vector ranks, 0, 1, 2, 3
     # lhs_tensor: list[int], lhs is tensor or view, 0: tensor, 1: view
@@ -726,11 +728,11 @@ def generate_test_case(
             ntt_op_str, test_name_suffix=None):
         # only support same datatype but different range now
         assert lhs_datatype.cpp_type == rhs_datatype.cpp_type
-        
+
         datatype = lhs_datatype
         self.ntt_op_str = ntt_op_str  # Store operation type for allow_zr check
 
-        test_name = self.generate_test_name(datatype, lhs_is_dynamic_shape, rhs_is_dynamic_shape,
+        test_name = self.generate_test_name(lhs_is_dynamic_shape, rhs_is_dynamic_shape,
             lhs_dims_spec, rhs_dims_spec,
             lhs_vector_rank, rhs_vector_rank,
             lhs_continuity, rhs_continuity, test_name_suffix)
@@ -742,7 +744,7 @@ def generate_test_case(
         rhs_vec_param = "P" if rhs_vector_rank > 0 else None
 
         # 1. Test header and constants
-        code.extend(self.generate_function_name(f"BinaryTest{ntt_op_str}", datatype, test_name))
+        code.extend(self.generate_function_name(f"BinaryTest{ntt_op_str}", datatype.name_suffix, test_name))
         if lhs_vector_rank > 0 or rhs_vector_rank > 0:
             code.extend(self.generate_P_constants(P))
 
@@ -769,7 +771,7 @@ def generate_test_case(
         code.extend([f"    {line}" for line in golden_output_code])
         # cast_mode = 2 if datatype.cpp_type in types_to_cast else 0
         # set cast mode for back to ntt function
-       
+
 
 
         compare_code = self.generate_compare(
@@ -791,9 +793,9 @@ def _generate_pow_test_case_pair(
             lhs_vector_rank, rhs_vector_rank,
             lhs_continuity, rhs_continuity,
             ntt_op_str):
-        
+
         test_cases = []
-        
+
         if lhs_datatype.cpp_type in self.integer_types:
             # Case 1: integer types - rhs is non-negative integer
             pow_ranges = self.ALL_POW_OPRANDS.get(rhs_datatype.cpp_type)
@@ -818,7 +820,7 @@ def _generate_pow_test_case_pair(
         else:
             # Case 2.1: floating point types - rhs as integer
             pow_ranges = self.ALL_POW_OPRANDS.get(lhs_datatype.cpp_type)
-            lhs_datatype = lhs_datatype._replace( 
+            lhs_datatype = lhs_datatype._replace(
                 integer_only=False,
                 min_val=pow_ranges["lhs_min"],
                 max_val=pow_ranges["lhs_max"]
@@ -850,7 +852,7 @@ def _generate_pow_test_case_pair(
             rhs_datatype = rhs_datatype._replace(
                 integer_only=False
             )
-            
+
             test_code2 = self.generate_test_case(
                 lhs_datatype, rhs_datatype,
                 lhs_is_dynamic_shape, rhs_is_dynamic_shape,
@@ -860,7 +862,7 @@ def _generate_pow_test_case_pair(
                 ntt_op_str, "rhs_float"
             )
             test_cases.append(test_code2)
-        
+
         return "\n".join(test_cases)
 
 
@@ -871,7 +873,7 @@ def _get_param_combinations(self, op_str):
 
         # Choose appropriate dims_specs based on op_str
         dims_specs_to_use = self.dims_specs_options.get(op_str, self.dims_specs_options["default"])
-        
+
         param_combinations_exhaustive = itertools.product(
             is_dynamic_options,          # lhs_is_dynamic_shape 2
             is_dynamic_options,          # rhs_is_dynamic_shape 2
@@ -896,9 +898,9 @@ def _get_param_combinations(self, op_str):
             return param_combinations_simplified
 
 
-    def generate_all_tests_for_type(self, datatype, op_str):
+    def generate_all_tests_for_type(self, op_str, datatype):
         code = []
-        
+
         code.append(self.generate_header())
 
         # Generate custom ORT functions if needed
@@ -921,13 +923,13 @@ def generate_all_tests_for_type(self, datatype, op_str):
                 lhs_continuity = lhs_continuity._replace(non_contiguous_dim=0)
             if not rhs_continuity.is_contiguous and rhs_shape == [16]:
                 rhs_continuity = rhs_continuity._replace(non_contiguous_dim=0)
-            
+
             # Filter vector rank combinations for inner_product
             if op_str == "inner_product" or op_str == "outer_product":
                 # Only allow: scalar x scalar, or 1D vector x 1D vector
                 if not ((lhs_vec_rank == 0 and rhs_vec_rank == 0) or (lhs_vec_rank == 1 and rhs_vec_rank == 1)):
                     continue
-            
+
             if(op_str == "pow"):
                 # 1. lhs is neg or pos, rhs is int
                 # 2. lhs is pos, rhs is float
@@ -960,16 +962,16 @@ def generate_tests_for_op(op_str, generator):
             # Skip ceil_div for non-integer types, as it is only supported for integers
             continue
 
-        test_code = generator.generate_all_tests_for_type(datatype, op_str)
-        filename = f"test_ntt_binary_{datatype.name_suffix.lower()}_{op_str}_generated.cpp"
+        test_code = generator.generate_all_tests_for_type(op_str, datatype)
+        filename = f"test_ntt_binary_{op_str}_{datatype.name_suffix.lower()}.cpp"
         output_filepath = os.path.join(generated_directory, filename)
 
         with open(output_filepath, "w") as f:
             f.write(test_code)
-        
+
         print(f"Test file generated: {output_filepath}")
         generated_filenames.append(filename)
-    
+
 
 if __name__ == "__main__":
     generator = BinaryTestGenerator()
@@ -977,10 +979,10 @@ def generate_tests_for_op(op_str, generator):
     # Get the parent directory (ctest) and then the generated subdirectory
     ctest_directory = os.path.dirname(script_directory)
     generated_directory = os.path.join(ctest_directory, "generated")
-    
+
     # Ensure generated directory exists
     os.makedirs(generated_directory, exist_ok=True)
-    
+
     generated_filenames = []  # collect all generated file names
 
     # for datatype in ALL_DATATYPES:
@@ -990,11 +992,11 @@ def generate_tests_for_op(op_str, generator):
 
     #     with open(output_filepath, "w") as f:
     #         f.write(test_code)
-        
+
     #     print(f"Test file generated: {output_filepath}")
     #     generated_filenames.append(filename)
 
     for op_str in (generator.op_str_map_exhaustive.keys() | generator.op_str_map_simplified.keys()):
         generate_tests_for_op(op_str, generator)
     # Generate cmake list file in the generated directory
-    generate_cmake_list(generated_directory, generated_filenames, "generated_binary_tests.cmake", "GENERATED_BINARY_TEST_SOURCES")
\ No newline at end of file
+    generate_cmake_list(generated_directory, generated_filenames, "binary_test.cmake", "BINARY_TESTS")
\ No newline at end of file
diff --git a/ntt/test/ctest/test_generator/generate_cast_tests.py b/ntt/test/ctest/test_generator/cast_test.py
similarity index 57%
rename from ntt/test/ctest/test_generator/generate_cast_tests.py
rename to ntt/test/ctest/test_generator/cast_test.py
index b005a96c13..26aa62978d 100644
--- a/ntt/test/ctest/test_generator/generate_cast_tests.py
+++ b/ntt/test/ctest/test_generator/cast_test.py
@@ -17,7 +17,7 @@
 class CastTestGenerator(BaseTestGenerator):
     def __init__(self):
         super().__init__()
-        
+
         # Element type sizes in bytes
         self.element_type_lengths = {
             'uint8_t': 1, 'int8_t': 1, 'bool': 1,
@@ -27,17 +27,16 @@ def __init__(self):
             'float_e4m3_t': 1, 'float_e5m2_t': 1
         }
 
-        
-    def generate_test_name(self, from_type, to_type, shape_type, vector_rank, continuity: Continuity, ndim, repackedAxes=None):
+    def generate_test_name(self, from_type, to_type, shape_type, vector_rank, continuity: Continuity, ndim):
         parts = []
-        parts.append(f"from_{from_type.name_suffix}_to_{to_type.name_suffix}")
+        # parts.append(f"from_{from_type.name_suffix}_to_{to_type.name_suffix}")
         parts.append(shape_type)
-        
+
         if vector_rank == 0:
             parts.append("scalar")
         else:
             parts.append(f"{vector_rank}D_vector")
-        
+
         if continuity.is_contiguous:
             parts.append("contiguous")
         else:
@@ -45,10 +44,7 @@ def generate_test_name(self, from_type, to_type, shape_type, vector_rank, contin
             parts.append(f"non_contiguous_dim{continuity.non_contiguous_dim}_{op_str}")
 
         parts.append(f"{ndim}D")
-        
-        if repackedAxes is not None:
-            parts.append(f"repack_axis_{repackedAxes[0]}")
-        
+
         return "_".join(parts)
 
     def generate_ort_output(self, to_type):
@@ -60,76 +56,39 @@ def generate_ort_output(self, to_type):
             ""
         ]
 
-    def generate_ntt_ops(self, repackedAxes=None):
+    def generate_ntt_ops(self):
         """Generate NTT cast operation code"""
-        if repackedAxes is not None:
-            axes_str = f"ntt::fixed_shape_v<{repackedAxes[0]}>"
-            return [
-                "// Execute cast operation",
-                f"ntt::cast(ntt_input, ntt_output1, {axes_str});",
-                ""
-            ]
-        else:
-            return [
-                "// Execute cast operation",
-                "ntt::cast(ntt_input, ntt_output1);",
-                ""
-            ]
-
+        return [
+            "// Execute cast operation",
+            "ntt::cast(ntt_input, ntt_output);",
+            ""
+        ]
 
-    def generate_ntt_output_to_test(self, from_type, to_type, shape_type, dims_spec, continuity, vector_rank, P, repackedAxes=None):
+    def generate_ntt_output_to_test(self, from_type, to_type, shape_type, dims_spec, continuity, input_element_type, output_element_type):
         """Generate the NTT output to be tested"""
         code = []
 
-        cast_min_value, cast_max_value = clamp_value_strings(from_type, to_type) 
+        cast_min_value, cast_max_value = clamp_value_strings(from_type, to_type)
         cast_data_type = from_type._replace(min_val=cast_min_value, max_val=cast_max_value)
+
         # 1. NTT input creation
         code.extend(self.generate_tensor_init(
             datatype=cast_data_type,
             shape_type=shape_type,
             dim_spec=dims_spec,
             continuity=continuity,
-            vector_rank=vector_rank,
-            P=P,
+            element_cpp_type=input_element_type,
             var_name="ntt_input",
             name_suffix=""))
 
         # 2. NTT output tensor creation
-        from_ele_len = self.element_type_lengths.get(from_type.cpp_type, 4)
-        to_ele_len = self.element_type_lengths.get(to_type.cpp_type, 4)
-        if(from_type.cpp_type == "bool"):
-            from_ele_len = to_ele_len
-        if(to_type.cpp_type == "bool"):
-            to_ele_len = from_ele_len
-
-        # Calculate output P and adjust dimensions for 1D vector with different element type length
-        if vector_rank == 1 and repackedAxes is not None and from_ele_len != to_ele_len:
-            # Adjust the P of output tensor: P = P / (output_ele_len / input_ele_len)
-            scale_factor = to_ele_len // from_ele_len if to_ele_len > from_ele_len else from_ele_len // to_ele_len
-            if to_ele_len > from_ele_len:
-                output_P = f"P / {scale_factor}"
-            else:
-                output_P = f"P * {scale_factor}"
-            
-            # Adjust the axes of output tensor: axes[repackedAxes[0]] = axes[repackedAxes[0]] * (output_ele_len / input_ele_len)
-            adjusted_dims_spec = [str(dim) for dim in dims_spec]
-            repack_axis = repackedAxes[0]
-            if to_ele_len > from_ele_len:
-                adjusted_dims_spec[repack_axis] = f"{dims_spec[repack_axis]} * {scale_factor}"
-            else:
-                adjusted_dims_spec[repack_axis] = f"{dims_spec[repack_axis]} / {scale_factor}"
-            output_element_type = self.get_element_cpp_type(to_type.cpp_type, vector_rank, output_P)
-            output_shape_expr = self.generate_shape_init(shape_type, adjusted_dims_spec)
-        else:
-            output_element_type = self.get_element_cpp_type(to_type.cpp_type, vector_rank, P)
-            output_shape_expr = self.generate_shape_init(shape_type, [str(dim) for dim in dims_spec])
-
+        output_shape_expr = self.generate_shape_init(shape_type, [str(dim) for dim in dims_spec])
         code.append(f"// Create output tensor")
-        code.append(f"auto ntt_output1 = ntt::make_tensor<{output_element_type}>({output_shape_expr});")
+        code.append(f"auto ntt_output = ntt::make_tensor<{output_element_type}>({output_shape_expr});")
         code.append("")
 
         # 3. NTT operation (cast)
-        cast_call_code = self.generate_ntt_ops(repackedAxes)
+        cast_call_code = self.generate_ntt_ops()
 
         op_code = self.generate_ntt_operation_section(cast_call_code)
         code.extend(op_code)
@@ -137,62 +96,46 @@ def generate_ntt_output_to_test(self, from_type, to_type, shape_type, dims_spec,
         return code, output_shape_expr, output_element_type
 
     # for fp8, golden is derived from the apply operation to cast tensor elementwisely.
-    def generate_ntt_cast_golden_output_fp8(self, from_type, to_type, shape_type, dims_spec, continuity, P, vector_rank):
+    def generate_ntt_cast_golden_output_fp8(self, from_type, to_type, shape_type, dims_spec, continuity, input_element_type, output_element_type, P, vector_rank):
         code = []
         from_ele_len = self.element_type_lengths.get(from_type.cpp_type, 4)
         to_ele_len = self.element_type_lengths.get(to_type.cpp_type, 4)
         scale = from_ele_len // to_ele_len if from_ele_len > to_ele_len else to_ele_len // from_ele_len
-        tensor_element_type = self.get_element_cpp_type(from_type.cpp_type, vector_rank, P)
-
-
-        output_element_type = self.get_element_cpp_type(to_type.cpp_type, vector_rank, P)
 
         # 1. copy to contiguous tensor of scalar or vector
         if not continuity.is_contiguous:
-            copy_code, continuous_input_var_name = self.generate_copy_to_contiguous_code(tensor_element_type, shape_type, dims_spec)
+            copy_code, continuous_input_var_name = self.generate_copy_to_contiguous_code(input_element_type, shape_type, dims_spec)
             code.extend(copy_code)
         else:
             continuous_input_var_name = "ntt_input"
 
-        unpack_axes = [len(dims_spec)-1] if vector_rank == 1 else [len(dims_spec)-2, len(dims_spec)-1]
         # 2. unpack to scalar tensor
-        if 'vector' in tensor_element_type:
-            # 2x4 vector<int32, 8> to 2x(4/2) vector<int16, 8*2>
-            out_vec_dims_spec = dims_spec.copy()
-            out_vec_dims_spec[-1]  = ((dims_spec[-1] // scale) if from_ele_len > to_ele_len 
-                                    else (dims_spec[-1] * scale))
-            
-
-            output_element_type = self.get_element_cpp_type(
-                    to_type.cpp_type, vector_rank, 
-                    (f"{P} * {scale}" if from_ele_len > to_ele_len else f"{P} / {scale}") )
-
-            unpacked_dims = self.get_unpacked_dims(dims_spec, unpack_axes)
-            code.append(f"auto ntt_scalar_input = ntt::make_tensor<{from_type.cpp_type}>({self.generate_shape_init(shape_type, unpacked_dims)});")
-            code.append(f"ntt::unpack({continuous_input_var_name}, ntt_scalar_input, {self.generate_pack_axes_str(unpack_axes)});")
+        if 'vector' in input_element_type:
+            code.append(f"auto ntt_golden = ntt::make_tensor<{output_element_type}>({self.generate_shape_init(shape_type, dims_spec)});")
+            code.append(
+                f"ntt::apply(({continuous_input_var_name}).shape(), [&](auto& index1){{\n"
+                f"    auto &v_in = ({continuous_input_var_name})(index1);\n"
+                f"    auto &v_out = ntt_golden(index1);\n"
+                f"    ntt::apply(v_in.shape(), [&](auto& index2) {{\n"
+                f"           auto offset = linear_offset(index2, v_in.shape());\n"
+                f"           auto index3 = unravel_index(offset, v_out.shape());\n"
+                f"           auto val = static_cast<{to_type.cpp_type}>(v_in(index2));\n"
+                f"           v_out(index3) = val;\n"
+                f"    }});\n"
+                f"}});"
+            )
         else:
             code.append(f"auto ntt_scalar_input = {continuous_input_var_name};")
-        #3. generate golden output
-        code.append(f"auto ntt_golden_scalar = ntt::make_tensor<{to_type.cpp_type}>(ntt_scalar_input.shape());")
-        code.append(
-            f"ntt::apply(ntt_golden_scalar.shape(), [&](auto& index){{\n"
-            f"      (ntt_golden_scalar)(index) = static_cast<{to_type.cpp_type}>(ntt_scalar_input(index));\n"
-            f"    }});"
-        )
-
-        # 4. generate under test scalar output 
-        if "vector" in tensor_element_type:
-            code.append(f"auto ntt_golden_vector = ntt::make_tensor<{output_element_type}>({self.generate_shape_init(shape_type, out_vec_dims_spec)});")
-            code.append(f"ntt::pack(ntt_golden_scalar, ntt_golden_vector, {self.generate_pack_axes_str(unpack_axes)});")
-            code.append(f"auto& ntt_golden = ntt_golden_vector;")
-        else:
-            code.append(f"auto& ntt_golden = ntt_golden_scalar;")
-
+            code.append(f"auto ntt_golden = ntt::make_tensor<{to_type.cpp_type}>(ntt_scalar_input.shape());")
+            code.append(
+                f"ntt::apply(ntt_golden.shape(), [&](auto& index){{\n"
+                f"      (ntt_golden)(index) = static_cast<{to_type.cpp_type}>(ntt_scalar_input(index));\n"
+                f"    }});"
+            )
 
         return code
 
-
-    def generate_ort_golden_output(self, from_type, to_type, shape_type, dims_spec, continuity, P,  vector_rank, deal_fp8, repackedAxes=None):
+    def generate_ort_golden_output(self, from_type, to_type, shape_type, dims_spec, continuity, input_element_type, output_element_type, P, vector_rank, deal_fp8):
         """Generate golden output using ORT or lambda-based reference"""
         code = []
         is_fp8_cast = 'float_e' in from_type.cpp_type or 'float_e' in to_type.cpp_type
@@ -200,47 +143,54 @@ def generate_ort_golden_output(self, from_type, to_type, shape_type, dims_spec,
         if not is_fp8_cast:
             # Generate ORT input section using _prepare_contiguous_input
             continuity_var_name, copy_code = self._prepare_contiguous_input(
-                "ntt_input", from_type, vector_rank, P,
+                "ntt_input", input_element_type,
                 shape_type, dims_spec, continuity
             )
+
             code.extend(copy_code)
             ort_input_var_name = continuity_var_name
-            
+
             # Add logic for 1D vector with different element type lengths
             from_ele_len = self.element_type_lengths.get(from_type.cpp_type, 4)
             to_ele_len = self.element_type_lengths.get(to_type.cpp_type, 4)
             scale = from_ele_len // to_ele_len if from_ele_len > to_ele_len else to_ele_len // from_ele_len
-            if("bool" == from_type.cpp_type or "bool" == to_type.cpp_type):
-                scale = 1
+            # if("bool" == from_type.cpp_type or "bool" == to_type.cpp_type):
+            #     scale = 1
 
-            if vector_rank == 1 and repackedAxes is not None and from_ele_len != to_ele_len:
+            if vector_rank > 0 and from_ele_len != to_ele_len:
                 # Calculate scale factor
                 input_rank = len(dims_spec)
-                packed_axis = repackedAxes[0]
-                
+                # packed_axis = repackedAxes[0]
+
                 ort_dims_spec = [str(dim) for dim in dims_spec]
                 if from_ele_len > to_ele_len:
-                    ort_dims_spec[packed_axis] = f"{ort_dims_spec[packed_axis]} / {scale}"
-                    ort_dims_spec.insert(packed_axis + 1, str(scale))
+                    # ort_dims_spec[packed_axis] = f"{ort_dims_spec[packed_axis]} / {scale}"
+                    if "bool" == to_type.cpp_type:
+                        ort_dims_spec.append(f"4")
+                    else:
+                        ort_dims_spec.append(str(scale))
                     ort_dims_spec.append("P")
-                    
+
                     # Create perms_data: move second to last element after packed_axis
                     perms_data = list(range(input_rank + 2))
                     # Move element at index input_rank-1 (the second to last element) to position packed_axis + 1
-                    element = perms_data.pop(input_rank ) # input_rank + 1 - 1
-                    perms_data.insert(packed_axis + 1, element)
+                    # element = perms_data.pop(input_rank ) # input_rank + 1 - 1
+                    # perms_data.insert(packed_axis + 1, element)
                 else:
                     # scale < 1 case (from_ele_len < to_ele_len)
+                    if "bool" == from_type.cpp_type:
+                        scale = 1
+
                     ort_dims_spec.append(str(scale))
                     ort_dims_spec.append(f"P / {scale}")
-                    
+
                     # Create perms_data: move second to last element after packed_axis
                     perms_data = list(range(input_rank + 2))
                     # Move element at index input_rank (the second to last element) to position packed_axis + 1
-                    element = perms_data.pop(input_rank ) # input_rank + 1 - 1
-                    perms_data.insert(packed_axis + 1, element)
-                
-                
+                    # element = perms_data.pop(input_rank ) # input_rank + 1 - 1
+                    # perms_data.insert(packed_axis + 1, element)
+
+
                 # Generate reshape and transpose code
                 code.append("// Reshape and transpose for 1D vector cast")
                 code.append(f"int64_t reshape_data[] = {{{', '.join(ort_dims_spec)}}};")
@@ -254,7 +204,7 @@ def generate_ort_golden_output(self, from_type, to_type, shape_type, dims_spec,
                 code.append(f"int64_t perms_data[] = {{{', '.join(map(str, perms_data))}}};")
                 code.append("auto ort_cast_input = ortki_Transpose(reshaped_tensor1, perms_data, std::size(perms_data));")
                 code.append("")
-                
+
                 # Use the transposed tensor as input for cast
                 ort_type = self.ort_datatype_map.get(to_type.cpp_type, 'DataType_FLOAT')
                 code.append(f"auto ort_output = ortki_Cast(ort_cast_input, 1, {ort_type});")
@@ -265,13 +215,11 @@ def generate_ort_golden_output(self, from_type, to_type, shape_type, dims_spec,
                 code.extend(ort_kernel_lines)
         else:
             # Use lambda-based reference
-            code.extend(self.generate_ntt_cast_golden_output_fp8(from_type, to_type, shape_type, dims_spec, continuity, P, vector_rank))
-            
-        return code
-    
+            code.extend(self.generate_ntt_cast_golden_output_fp8(from_type, to_type, shape_type, dims_spec, continuity, input_element_type, output_element_type, P, vector_rank))
 
+        return code
 
-    def generate_test_case(self, from_type, to_type, shape_type, vector_rank, continuity, ndim, repackedAxes=None):
+    def generate_test_case(self, from_type, to_type, shape_type, vector_rank, continuity, ndim):
         """Generate a single test case"""
         # 1. Initialize dimensions and other basic variables
         is_from_fp8 = 'float_e' in from_type.cpp_type
@@ -290,26 +238,51 @@ def generate_test_case(self, from_type, to_type, shape_type, vector_rank, contin
             dims_spec= [2, 8, 4, 4, 4]
 
 
-        test_name = self.generate_test_name(from_type, to_type, shape_type, vector_rank, continuity, ndim, repackedAxes)
-        
+        test_name = self.generate_test_name(from_type, to_type, shape_type, vector_rank, continuity, ndim)
+
         code: List[str] = []
 
 
         # 1. Test header and constants
-        code.extend(self.generate_function_name("CastTest", from_type, test_name))
+        code.extend(self.generate_function_name("CastTest", f"{from_type.name_suffix}_{to_type.name_suffix}", test_name))
         P_would_be_used = True if vector_rank > 0 else False
 
         if(P_would_be_used):
             code.extend(self.generate_P_constants(P))
+
+        from_ele_len = self.element_type_lengths.get(from_type.cpp_type, 4)
+        to_ele_len = self.element_type_lengths.get(to_type.cpp_type, 4)
+        if(from_type.cpp_type == "bool"):
+            from_ele_len = to_ele_len
+        if(to_type.cpp_type == "bool"):
+            to_ele_len = from_ele_len
+
+        # Calculate output P and adjust dimensions for 1D vector with different element type length
+        if vector_rank > 0 and from_ele_len != to_ele_len:
+            # Adjust the P of output tensor
+            scale_factor = from_ele_len // to_ele_len if from_ele_len > to_ele_len else to_ele_len // from_ele_len
+            if from_ele_len > to_ele_len:
+                input_P = f"{scale_factor}, P"
+                output_P = f"{scale_factor} * P"
+            else:
+                input_P = f"P"
+                output_P = f"{scale_factor}, P / {scale_factor}"
+
+            input_element_type = f"ntt::vector<{from_type.cpp_type}, {input_P}>"
+            output_element_type = f"ntt::vector<{to_type.cpp_type}, {output_P}>"
+        else:
+            input_element_type = self.get_element_cpp_type(from_type.cpp_type, vector_rank, "P")
+            output_element_type = self.get_element_cpp_type(to_type.cpp_type, vector_rank, "P")
+
         # 2. Generate output to test in NTT format
         ntt_output_code, output_shape_expr, output_element_type = self.generate_ntt_output_to_test(
-            from_type, to_type, shape_type, dims_spec, continuity, vector_rank, "P", repackedAxes)
+            from_type, to_type, shape_type, dims_spec, continuity, input_element_type, output_element_type)
         code.extend([f"    {line}" for line in ntt_output_code])
 
         # 3. Generate golden output in ORT format, or in ntt format for fp8 cast
         golden_output_code = self.generate_ort_golden_output(
-            from_type, to_type, shape_type, dims_spec, continuity, P,  vector_rank, deal_fp8, repackedAxes)
-    
+            from_type, to_type, shape_type, dims_spec, continuity, input_element_type, output_element_type, P, vector_rank, deal_fp8)
+
         code.extend([f"    {line}" for line in golden_output_code])
 
         # 4. Compare outputs
@@ -317,7 +290,7 @@ def generate_test_case(self, from_type, to_type, shape_type, vector_rank, contin
             # Direct comparison for FP8 cast
             code.extend([
                 "    // Compare results",
-                "    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_golden));",
+                "    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));",
                 "}"
             ])
         else:
@@ -327,17 +300,17 @@ def generate_test_case(self, from_type, to_type, shape_type, vector_rank, contin
                 output_element_type,
                 output_shape_expr,
                 deal_fp8,
-                ntt_output_var_name="ntt_output1",
+                ntt_output_var_name="ntt_output",
                 ort_output_var_name="ort_output")
             code.extend([f"    {line}" for line in compare_code])
 
         return "\n".join(code)
 
-    def generate_all_tests_for_from_type(self, from_type):
+    def generate_all_tests(self, from_type, to_type):
         """Generate all test combinations for a given input datatype"""
         shape_types = ["fixed", "dynamic"]
         vector_ranks = [0, 1, 2]  # scalar, 1D vector, 2D vector
-        
+
         # Full continuity test combinations, mainly for 4D
         full_continuities = [
             Continuity(is_contiguous=True, non_contiguous_dim=None, big_tensor_op=None),
@@ -352,62 +325,40 @@ def generate_all_tests_for_from_type(self, from_type):
             Continuity(is_contiguous=True, non_contiguous_dim=None, big_tensor_op=None),
             Continuity(is_contiguous=False, non_contiguous_dim=1, big_tensor_op="*2"),
         ]
-        
+
         code = []
-        
+
         # Generate file header
         code.append(self.generate_header())
-        
+
         # Generate test cases for all target types (except the same type)
-        for to_type in ALL_DATATYPES:
-            if from_type.cpp_type == to_type.cpp_type:
-                continue  # Skip same type cast
-            
-            # Generate test cases for different dimensions
-            for ndim in [3, 4]:
-                # Select continuity test strategy based on dimension
-                current_continuities = full_continuities if ndim == 3 else simple_continuities
-
-                for shape_type, vector_rank, continuity in itertools.product(shape_types, vector_ranks, current_continuities):
-                    # Skip unreasonable combinations
-                    if vector_rank > ndim:  # Can't have more vector dimensions than tensor dimensions
-                        continue
-                    
-                    # Determine repackedAxes choices based on vector_rank and element type lengths
-                    from_ele_len = self.element_type_lengths.get(from_type.cpp_type, 4)
-                    to_ele_len = self.element_type_lengths.get(to_type.cpp_type, 4)
-                    
-                    repackedAxes_choices = []
-                    
-                    if vector_rank == 0:  # scalar
-                        # No filter, but repackedAxes should not be set
-                        repackedAxes_choices = [None]
-                    elif vector_rank == 1:  # 1D vector
-                        if from_ele_len == to_ele_len:
-                            # For equal element type length, repackedAxes should not be set
-                            repackedAxes_choices = [None]
-                        else:
-                            # For different element type length, add repackedAxes
-                            # Only test with repackedAxes when element type lengths differ
-                            repackedAxes_choices = [[ndim-1]]  # Add repack on last axis
-                    elif vector_rank == 2:  # 2D vector
-                        # Only element type length equal case should be tested
-                        if from_ele_len == to_ele_len:
-                            repackedAxes_choices = [None]
-                        else:
-                            continue  # Skip different element type length for 2D vector
-                    # if "float_e" in to_type.cpp_type :
-                    #     continue
-                    
-                    for repackedAxes in repackedAxes_choices:
-                        test_code = self.generate_test_case(from_type, to_type, shape_type, vector_rank, continuity, ndim, repackedAxes)
-                        code.append(test_code)
-                    
+        # Generate test cases for different dimensions
+        for ndim in [3, 4]:
+            # Select continuity test strategy based on dimension
+            current_continuities = full_continuities if ndim == 3 else simple_continuities
+
+            for shape_type, vector_rank, continuity in itertools.product(shape_types, vector_ranks, current_continuities):
+                # Skip unreasonable combinations
+                if vector_rank > ndim:  # Can't have more vector dimensions than tensor dimensions
+                    continue
+
+                # Determine repackedAxes choices based on vector_rank and element type lengths
+                from_ele_len = self.element_type_lengths.get(from_type.cpp_type, 4)
+                to_ele_len = self.element_type_lengths.get(to_type.cpp_type, 4)
+
+                if from_ele_len > to_ele_len and vector_rank == 1:
+                    continue
+
+                if from_ele_len < to_ele_len and vector_rank == 2:
+                    continue
+
+                test_code = self.generate_test_case(from_type, to_type, shape_type, vector_rank, continuity, ndim)
+                code.append(test_code)
+
         # Generate main function
         code.append(self.generate_footer())
-        
-        return "\n".join(code)
 
+        return "\n".join(code)
 
 if __name__ == "__main__":
     generator = CastTestGenerator()
@@ -415,22 +366,25 @@ def generate_all_tests_for_from_type(self, from_type):
     # Get the parent directory (ctest) and then the generated subdirectory
     ctest_directory = os.path.dirname(script_directory)
     generated_directory = os.path.join(ctest_directory, "generated")
-    
+
     # Ensure generated directory exists
     os.makedirs(generated_directory, exist_ok=True)
-    
+
     generated_filenames = []  # collect all generated file names
 
     for from_type in ALL_DATATYPES:
-        test_code = generator.generate_all_tests_for_from_type(from_type)
-        filename = f"test_ntt_cast_from_{from_type.name_suffix.lower()}_generated.cpp"
-        output_filepath = os.path.join(generated_directory, filename)
-
-        with open(output_filepath, "w") as f:
-            f.write(test_code)
-        
-        print(f"Test file generated: {output_filepath}")
-        generated_filenames.append(filename)
-    
+        for to_type in ALL_DATATYPES:
+            if from_type.cpp_type == to_type.cpp_type:
+                continue  # Skip same type cast
+            test_code = generator.generate_all_tests(from_type, to_type)
+            filename = f"test_ntt_cast_{from_type.name_suffix.lower()}_{to_type.name_suffix.lower()}.cpp"
+            output_filepath = os.path.join(generated_directory, filename)
+
+            with open(output_filepath, "w") as f:
+                f.write(test_code)
+
+            print(f"Test file generated: {output_filepath}")
+            generated_filenames.append(filename)
+
     # Generate cmake list file in the generated directory
-    generate_cmake_list(generated_directory, generated_filenames, "generated_cast_tests.cmake", "GENERATED_CAST_TEST_SOURCES") 
\ No newline at end of file
+    generate_cmake_list(generated_directory, generated_filenames, "cast_test.cmake", "CAST_TESTS")
\ No newline at end of file
diff --git a/ntt/test/ctest/test_generator/generate_pack_tests.py b/ntt/test/ctest/test_generator/pack_test.py
similarity index 92%
rename from ntt/test/ctest/test_generator/generate_pack_tests.py
rename to ntt/test/ctest/test_generator/pack_test.py
index 27314812cd..2f948f9ad1 100644
--- a/ntt/test/ctest/test_generator/generate_pack_tests.py
+++ b/ntt/test/ctest/test_generator/pack_test.py
@@ -16,13 +16,12 @@
 class PackTestGenerator(BaseTestGenerator):
     def __init__(self):
         super().__init__()
-        
-    def generate_test_name(self, datatype, shape_type, vector_dim, continuity: Continuity, pack_axis_str, ndim):
+
+    def generate_test_name(self, shape_type, vector_dim, continuity: Continuity, pack_axis_str, ndim):
         parts = []
-        parts.append(datatype.name_suffix)
         parts.append(shape_type)
         parts.append(f"{vector_dim}D_vector")
-        
+
         if continuity.is_contiguous:
             parts.append("contiguous")
         else:
@@ -32,13 +31,13 @@ def generate_test_name(self, datatype, shape_type, vector_dim, continuity: Conti
         parts.append(f"pack_axis_{pack_axis_str}")
         parts.append(f"{ndim}D")
         return "_".join(parts)
-    
-    
-    
+
+
+
     def generate_ort_reference(self, input_dims, input_dim_names, pack_axes):
         code = []
         ndim = len(input_dims)
-        
+
         # Calculate reshaped dimensions (for code string generation)
         reshape_dims_str = []
         dim_idx = 0
@@ -51,7 +50,7 @@ def generate_ort_reference(self, input_dims, input_dim_names, pack_axes):
                 reshape_dims_str.append(f"(int64_t){vec_param}")
             else:
                 reshape_dims_str.append(f"(int64_t){input_dim_names[i]}")
-        
+
         # Generate reshape code
         code.append("// ORT reference implementation (kernel part)")
         code.append(f"int64_t reshape_data[] = {{{', '.join(reshape_dims_str)}}};")
@@ -60,7 +59,7 @@ def generate_ort_reference(self, input_dims, input_dim_names, pack_axes):
         code.append("auto shape_tensor = make_tensor(reinterpret_cast<void *>(reshape_data), ort_type,")
         code.append("                         reshape_shape, std::size(reshape_shape));")
         code.append("auto reshaped_tensor = ortki_Reshape(ort_input, shape_tensor, 0);")
-        
+
         # Generate transpose permutation
         if len(pack_axes) > 0:
             # Calculate permutation
@@ -76,15 +75,15 @@ def generate_ort_reference(self, input_dims, input_dim_names, pack_axes):
                     perm.append(j)
                     j += 1
             perm.extend(packd_dims)
-            
+
             code.append("")
             code.append(f"int64_t perms[] = {{{', '.join(map(str, perm))}}};")
             code.append("auto ort_output = ortki_Transpose(reshaped_tensor, perms, std::size(perms));")
         else:
             code.append("auto ort_output = reshaped_tensor;")
-        
+
         return code
-    
+
     def generate_ntt_ops(self, pack_axes):
         pack_axes_str = self.generate_pack_axes_str(pack_axes)
         return [
@@ -123,7 +122,7 @@ def generate_ntt_output_to_test(self, datatype, shape_type, dim_names, continuit
             else:
                 output_dims.append(name)
         output_shape_expr = self.generate_shape_init(shape_type, output_dims)
-        
+
         output_element_type = self.get_element_cpp_type(datatype.cpp_type, vector_dim, 'P')
 
         pack_call_code = self.generate_ntt_ops(pack_axes)
@@ -136,7 +135,7 @@ def generate_ntt_output_to_test(self, datatype, shape_type, dim_names, continuit
             output_element_type=output_element_type
         )
         code.extend(op_code)
-        
+
         return code, output_shape_expr, output_element_type
 
     def generate_ort_golden_output(self, datatype, shape_type, dims, dim_names, continuity, P, pack_axes, deal_fp8):
@@ -181,9 +180,9 @@ def generate_test_case(self, datatype, shape_type, vector_dim, continuity, pack_
             dims, dim_names = [2, 8, 4, 4], ['N', 'C', 'H', 'W']
         else:
             dims, dim_names = [2, 8, 4, 4, 2], ['N', 'C', 'H', 'W', 'D']
-        
-        test_name = self.generate_test_name(datatype, shape_type, vector_dim, continuity, "_".join(map(str, pack_axes)), ndim)
-        
+
+        test_name = self.generate_test_name(shape_type, vector_dim, continuity, "_".join(map(str, pack_axes)), ndim)
+
         code: List[str] = []
 
         # 1. Test header and constants
@@ -225,12 +224,12 @@ def generate_all_tests_for_type(self, datatype):
         """
         shape_types = ["fixed", "dynamic"]
         vector_dims = [1, 2]
-        
+
         # Define pack axis options for different dimensions
         pack_axes_options = {
-            3: [[2], [1], [0], [0, 1], [1, 2]],  
-            4: [[3], [2], [1], [0], [0, 1], [1, 2], [2, 3]],  
-            5: [[4], [3], [2], [1], [0], [0, 1], [1, 2], [2, 3], [3, 4]]  
+            3: [[2], [1], [0], [0, 1], [1, 2]],
+            4: [[3], [2], [1], [0], [0, 1], [1, 2], [2, 3]],
+            5: [[4], [3], [2], [1], [0], [0, 1], [1, 2], [2, 3], [3, 4]]
         }
 
         # Full continuity test combinations, mainly for 4D
@@ -247,12 +246,12 @@ def generate_all_tests_for_type(self, datatype):
             Continuity(is_contiguous=True, non_contiguous_dim=None, big_tensor_op=None),
             Continuity(is_contiguous=False, non_contiguous_dim=1, big_tensor_op="*2"), # Choose a representative non-contiguous case
         ]
-        
+
         code = []
-        
+
         # Generate file header
         code.append(self.generate_header())
-        
+
         # Generate test cases
         for ndim in [3, 4, 5]:
             # Select continuity test strategy based on dimension
@@ -263,25 +262,25 @@ def generate_all_tests_for_type(self, datatype):
                     # Skip unreasonable combinations
                     if vector_dim != len(pack_axes):
                         continue
-                    
+
                     test_code = self.generate_test_case(datatype, shape_type, vector_dim, continuity, pack_axes, ndim)
-                    code.append(test_code)       
+                    code.append(test_code)
         # Generate main function
         code.append(self.generate_footer())
-        
+
         return "\n".join(code)
-    
-    
+
+
 
 
 if __name__ == "__main__":
     generator = PackTestGenerator()
     script_directory = os.path.dirname(os.path.abspath(__file__))
-    
+
     # Get the parent directory (ctest) and then the generated subdirectory
     ctest_directory = os.path.dirname(script_directory)
     generated_directory = os.path.join(ctest_directory, "generated")
-    
+
     # Ensure generated directory exists
     os.makedirs(generated_directory, exist_ok=True)
 
@@ -289,13 +288,13 @@ def generate_all_tests_for_type(self, datatype):
 
     for datatype in ALL_DATATYPES:
         test_code = generator.generate_all_tests_for_type(datatype)
-        filename = f"test_ntt_pack_generated_{datatype.name_suffix}.cpp"
+        filename = f"test_ntt_pack_{datatype.name_suffix}.cpp"
         output_filepath = os.path.join(generated_directory, filename)
 
         with open(output_filepath, "w") as f:
             f.write(test_code)
-        
+
         print(f"Test file generated: {output_filepath}")
-        generated_filenames.append(filename) 
-    
-    generate_cmake_list(generated_directory, generated_filenames, "generated_pack_tests.cmake", "GENERATED_PACK_TEST_SOURCES")
\ No newline at end of file
+        generated_filenames.append(filename)
+
+    generate_cmake_list(generated_directory, generated_filenames, "pack_test.cmake", "PACK_TESTS")
\ No newline at end of file
diff --git a/ntt/test/ctest/test_generator/test_generator_base.py b/ntt/test/ctest/test_generator/test_generator_base.py
index f8b01525ab..f216e68768 100644
--- a/ntt/test/ctest/test_generator/test_generator_base.py
+++ b/ntt/test/ctest/test_generator/test_generator_base.py
@@ -43,21 +43,21 @@ def is_fixed(self):
         return self == ShapeType.FIXED
 
 ALL_DATATYPES = [
-    DataType('bool', 'Bool', 'false', 'true', False),
-    DataType('uint8_t', 'Uint8', '0', '16', True),
-    DataType('uint16_t', 'Uint16', '0', '256', True),
-    DataType('uint32_t', 'Uint32', '0', '15536', True),
-    DataType('uint64_t', 'Uint64', '0', '1000000', True),
-    DataType('int8_t', 'Int8', '-11', '11', True),
-    DataType('int16_t', 'Int16', '-181', '181', True),
-    DataType('int32_t', 'Int32', '-32761', '32761', True),
-    DataType('int64_t', 'Int64', '-1000000', '1000000', True),
-    DataType('half', 'Float16', 'half(-100.0f)', 'half(100.0f)', False),
-    DataType('float', 'Float32', '-3.4e15', '3.4e15', False),
-    DataType('double', 'Float64', '-1.7e150', '1.7e150', False),
-    DataType('bfloat16', 'Bfloat16', '-1.0e10_bf16', '1.0e10_bf16', False),
-    DataType('float_e4m3_t', 'Float8e4m3', 'float_e4m3_t(-16.0f)', 'float_e4m3_t(16.0f)', False),
-    DataType('float_e5m2_t', 'Float8e5m2', 'float_e5m2_t(-32.0f)', 'float_e5m2_t(32.0f)', False)
+    DataType('bool', 'b', 'false', 'true', False),
+    DataType('uint8_t', 'u8', '0', '16', True),
+    DataType('uint16_t', 'u16', '0', '256', True),
+    DataType('uint32_t', 'u32', '0', '15536', True),
+    DataType('uint64_t', 'u64', '0', '1000000', True),
+    DataType('int8_t', 'i8', '-11', '11', True),
+    DataType('int16_t', 'i16', '-181', '181', True),
+    DataType('int32_t', 'i32', '-32761', '32761', True),
+    DataType('int64_t', 'i64', '-1000000', '1000000', True),
+    DataType('half', 'fp16', 'half(-100.0f)', 'half(100.0f)', False),
+    DataType('float', 'fp32', '-3.4e15', '3.4e15', False),
+    DataType('double', 'fp64', '-1.7e150', '1.7e150', False),
+    DataType('bfloat16', 'bf16', '-1.0e10_bf16', '1.0e10_bf16', False),
+    DataType('float_e4m3_t', 'fp8e4m3', 'float_e4m3_t(-16.0f)', 'float_e4m3_t(16.0f)', False),
+    DataType('float_e5m2_t', 'fp8e5m2', 'float_e5m2_t(-32.0f)', 'float_e5m2_t(32.0f)', False)
 ]
 
 class BaseTestGenerator:
@@ -66,7 +66,7 @@ def __init__(self):
         self.ort_datatype_map = {
             'bool': 'DataType_BOOL',
             'uint8_t': 'DataType_UINT8',
-            'uint16_t': 'DataType_UINT16', 
+            'uint16_t': 'DataType_UINT16',
             'uint32_t': 'DataType_UINT32',
             'uint64_t': 'DataType_UINT64',
             'int8_t': 'DataType_INT8',
@@ -156,10 +156,10 @@ def _get_allow_zr(self, var_name ):
 #dim_spec: dim_names(list[str]) or dim_spec(list[int])
     def generate_tensor_init(self, datatype, shape_type,
                              dim_spec, continuity,
-                             vector_rank, var_name, name_suffix, P=None, integer_only=False):
+                             element_cpp_type, var_name, name_suffix, integer_only=False):
         code = []
         shape_expr = self.generate_shape_init(shape_type, dim_spec)
-        element_cpp_type = self.get_element_cpp_type(datatype.cpp_type, vector_rank, P)
+        # element_cpp_type = self.get_element_cpp_type(datatype.cpp_type, vector_rank, P)
 
         if continuity.is_contiguous:
             code.append(f"auto {var_name} = ntt::make_tensor<{element_cpp_type}>({shape_expr});")
@@ -212,8 +212,8 @@ def generate_demension_constants(self, dim_names, dims, datatype, P):
            code.append(f"    constexpr size_t {name} = {size};")
         return code
 
-    def generate_function_name(self, test_suite_prefix, datatype, test_name):
-        code = [f"TEST({test_suite_prefix}_{datatype.name_suffix}, {test_name}) {{"]
+    def generate_function_name(self, test_suite_prefix, test_suite_suffix, test_name):
+        code = [f"TEST({test_suite_prefix}_{test_suite_suffix}, {test_name}) {{"]
         return code
 
     def generate_test_prologue(self, test_suite_prefix, datatype, test_name, P, dim_names, dims, pack_axes=None):
@@ -306,7 +306,7 @@ def generate_reference_and_comparison_code(self,
             code.append(f"    auto ntt_output2 = ntt::make_tensor<{output_element_type}>({output_shape_expr});")
             code.append(f"    NttTest::ort2ntt(ort_output, ntt_output2);")
             code.append(f"    EXPECT_TRUE(NttTest::compare_tensor({ntt_output_for_comp}, ntt_output2));")
-        
+
         code.append("}")
         code.append("")
         return code
@@ -369,9 +369,10 @@ def get_element_cpp_type(self, base_cpp_type: str, vector_rank: int, P: Optional
 
         if vector_rank == 0:
             return base_cpp_type
+
         if P is None:
             raise ValueError("P must be provided when vector_rank > 0")
-        
+
         # Handle tuple/list case for multi-dimensional vectors
         if isinstance(P, (tuple, list)):
             if len(P) != vector_rank:
@@ -416,14 +417,15 @@ def generate_ntt_input_section(self,
 
 
         # Re-use the existing, well-tested generate_tensor_init helper
+        element_type = self.get_element_cpp_type(datatype.cpp_type, vector_rank, P)
         body = self.generate_tensor_init(datatype,
                                          shape_type,
                                          dims_spec,
                                          continuity,
-                                         vector_rank,
+                                         element_type,
                                          var_name,
                                          name_suffix,
-                                         P)
+                                         )
         return comment_lines + body + [""]
 
     def generate_ntt_operation_section(self,
@@ -462,7 +464,7 @@ def generate_ntt_output_and_op_section(self,
             ])
 
         return self.generate_ntt_operation_section(op_section)
-    
+
     def generate_ort_cast_back(self, datatype, cast_input_var = "ort_output", cast_output_var = "ort_golden"):
         """cast ort tensor of double back to ort tensor of original type"""
         """if original type is uint, cast to int64 first"""
@@ -489,7 +491,7 @@ def _cast_ort_golden_double_into_ntt_shape(self, code, datatype, ntt_op_str,
         # 3. transform ort_golden_double to ntt_golden{cpp_type}_scalar
         code.append(f"//  transform ort_golden_{cast_target} to ntt_golden{datatype.cpp_type}_scalar")
 
-        
+
         # # Get shape of ntt_golden_double_scalar based on aligned shapes and operation
         golden_scalar_dims = self.generate_ntt_golden_double_scalar_dims_spec(ntt_op_str, output_dims_spec, output_vector_rank)
 
@@ -536,9 +538,9 @@ def generate_ntt_golden_double_scalar_dims_spec(self, ntt_op_str, output_dims_sp
             golden_scalar_dims = output_dims_spec
 
         return golden_scalar_dims
-    
+
     def generate_ort_output(self, datatype, ntt_op_str):
-        
+
         # Check both dictionaries for the operation string
         if ntt_op_str in self.op_str_map_exhaustive:
             op_str = self.op_str_map_exhaustive[ntt_op_str]
@@ -546,7 +548,7 @@ def generate_ort_output(self, datatype, ntt_op_str):
             op_str = self.op_str_map_simplified[ntt_op_str]
         else:
             raise KeyError(f"Operation '{ntt_op_str}' not found in either op_str_map_exhaustive or op_str_map_simplified")
-            
+
         if callable(op_str):
             op_str = op_str(datatype)
         return [
@@ -555,13 +557,13 @@ def generate_ort_output(self, datatype, ntt_op_str):
             ""
         ]
 
-    def _prepare_contiguous_input(self, input_name, datatype, vector_rank, vec_param, 
+    def _prepare_contiguous_input(self, input_name, element_type,
                                   is_dynamic_shape, dims_spec, continuity):
-        
+
         continuity_var_name = input_name
-        element_type = self.get_element_cpp_type(datatype.cpp_type, vector_rank, vec_param)
+        # element_type = self.get_element_cpp_type(datatype.cpp_type, vector_rank, vec_param)
         code = []
-        
+
         if not continuity.is_contiguous:
             continuity_var_name = f"{input_name}_contiguous"
             copy_code, _ = self.generate_copy_to_contiguous_code(
@@ -573,7 +575,7 @@ def _prepare_contiguous_input(self, input_name, datatype, vector_rank, vec_param
             )
             continuity_var_name = f"*{continuity_var_name}"
             code.extend(copy_code)
-        
+
         return continuity_var_name, code
 
     """ Not a good abstraction """
@@ -640,7 +642,7 @@ def generate_ort_operation_section(self, ort_operation_lines: list[str]) -> list
                   "// 2. call ortki kernel to generate ORT output",
                   "// ------------------------------------------------------------------"]
         return header + ort_operation_lines + [""]
-    
+
 
     #back2ntt early version
     def generate_ort_back2ntt_and_compare_section(self,
@@ -656,7 +658,7 @@ def generate_ort_back2ntt_and_compare_section(self,
         lines = ["// ------------------------------------------------------------------",
                  "// 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output",
                  "// ------------------------------------------------------------------"]
-        
+
         if cast_mode == 0:  #  no cast
             golden_var_name = "ntt_golden"
             lines.append(f"auto {golden_var_name} = ntt::make_tensor<{output_element_cpp_type}>({output_shape_expr});")
@@ -687,7 +689,7 @@ def generate_ort_back2ntt_and_compare_section(self,
                 golden_cast_source_var = golden_signed_int_var
             else:
                 golden_cast_source_var = golden_ntt_in_ort_type_var
-            
+
             golden_origin_var = "ntt_golden"
             lines.append(f"auto {golden_origin_var} = ntt::make_unique_tensor<{output_element_cpp_type}>({output_shape_expr});")
             lines.append(f"ntt::cast(*{golden_cast_source_var}, *{golden_origin_var});")
@@ -700,7 +702,7 @@ def generate_ort_back2ntt_and_compare_section(self,
         lines.append("")
         return lines
 
-    #back2ntt used for cast in ort 
+    #back2ntt used for cast in ort
     def generate_ort_back2ntt(self,
                                 datatype: DataType,
                                 output_element_cpp_type: str,
@@ -743,7 +745,7 @@ def generate_ort_back2ntt(self,
                 golden_cast_source_var = golden_signed_int_var
             else:
                 golden_cast_source_var = golden_ntt_in_ort_type_var
-            
+
             golden_var_name = "*ntt_golden"
             lines.append(f"auto {generate_var_name} = ntt::make_unique_tensor<{output_element_cpp_type}>({output_shape_expr});")
             lines.append(f"ntt::cast(*{golden_cast_source_var}, {golden_var_name});")
@@ -824,11 +826,11 @@ def clamp_value_strings(from_type: DataType, to_type: DataType) -> tuple[str, st
     """
     Clamp the min/max values of from_type to the range of to_type.
     Returns (clamped_min_str, clamped_max_str) in the format of to_type.
-    
+
     Args:
         from_type: Source data type with min_val and max_val as strings
         to_type: Target data type with min_val and max_val as strings
-        
+
     Returns:
         Tuple of (min_value_str, max_value_str) formatted for to_type
     """
@@ -837,15 +839,15 @@ def clamp_value_strings(from_type: DataType, to_type: DataType) -> tuple[str, st
     from_max = get_numeric_value(from_type.max_val, from_type.cpp_type)
     to_min = get_numeric_value(to_type.min_val, to_type.cpp_type)
     to_max = get_numeric_value(to_type.max_val, to_type.cpp_type)
-    
+
     # Clamp the values
     clamped_min = max(from_min, to_min)
     clamped_max = min(from_max, to_max)
-    
+
     # Format back to strings for to_type
     clamped_min_str = format_value_for_type(clamped_min, from_type.cpp_type)
     clamped_max_str = format_value_for_type(clamped_max, from_type.cpp_type)
-    
+
     return clamped_min_str, clamped_max_str
 
 def generate_cmake_list(directory, filenames, output_filename, variable_name):
diff --git a/ntt/test/ctest/test_generator/generate_unary_tests.py b/ntt/test/ctest/test_generator/unary_test.py
similarity index 94%
rename from ntt/test/ctest/test_generator/generate_unary_tests.py
rename to ntt/test/ctest/test_generator/unary_test.py
index 4fea44b8c8..7500a17df8 100644
--- a/ntt/test/ctest/test_generator/generate_unary_tests.py
+++ b/ntt/test/ctest/test_generator/unary_test.py
@@ -9,7 +9,7 @@ class UnaryTestGenerator(BaseTestGenerator):
     def __init__(self):
         super().__init__()
         self.op_str_map_exhaustive= {
-            "abs": f"auto ort_output = ortki_Abs(ort_input);", 
+            "abs": f"auto ort_output = ortki_Abs(ort_input);",
             "cos": f"auto ort_output = ortki_Cos(ort_input);",
             "sin": f"auto ort_output = ortki_Sin(ort_input);",
             "exp": f"auto ort_output = ortki_Exp(ort_input);"
@@ -32,7 +32,7 @@ def __init__(self):
             ]
         }
 
-        # ORT *unary operations* do not support these data types, need to cast to double 
+        # ORT *unary operations* do not support these data types, need to cast to double
         # fortunately, they could be *cast* in ort( fp8 are unfortunate)
         default_cast_types_in_ort = [
             'bool', 'int8_t', 'int16_t', 'bfloat16', 'half',
@@ -46,7 +46,7 @@ def __init__(self):
             "exp": default_cast_types_in_ort + ['int32_t', 'uint64_t', 'int64_t'],
         }
         self.types_need_cast_in_ntt = {
-            'float_e4m3_t', 'float_e5m2_t' 
+            'float_e4m3_t', 'float_e5m2_t'
         }
 
         self.OPRATOR_SPECICAL_TYPES = {
@@ -102,34 +102,31 @@ def _get_param_combinations(self, op_str):
         )
         return param_combinations_exhaustive
 
-    def generate_test_name(self, datatype, input_is_dynamic, output_is_dynamic,
+    def generate_test_name(self, input_is_dynamic, output_is_dynamic,
                            dims_spec, vector_rank, input_continuity):
         parts = []
-        
-        # 1. datatype
-        parts.append(f"{datatype.name_suffix}")
-        
+
         # 2. input dynamic/fixed
         input_shape_type = "dynamic" if input_is_dynamic else "fixed"
         parts.append(f"input_{input_shape_type}")
-        
+
         # 3. output dynamic/fixed
         output_shape_type = "dynamic" if output_is_dynamic else "fixed"
         parts.append(f"output_{output_shape_type}")
-        
+
         # 4. vector rank
         if vector_rank == 0:
             parts.append("scalar")
         else:
             parts.append(f"{vector_rank}D_vector")
-        
+
         # 5. continuity - contiguous->raw_tensor, non_contiguous->view
         if input_continuity.is_contiguous:
             parts.append("raw_tensor")
         else:
             op_str = "mul2" if input_continuity.big_tensor_op == "*2" else "add3" if input_continuity.big_tensor_op == "+3" else "add7"
             parts.append(f"view_dim{input_continuity.non_contiguous_dim}_{op_str}")
-        
+
         # 6. shape information
         if dims_spec == [2, 3, 16, 16]:
             parts.append("shape1")
@@ -139,10 +136,10 @@ def generate_test_name(self, datatype, input_is_dynamic, output_is_dynamic,
             # Fallback for other shapes
             shape_str = "x".join(map(str, dims_spec))
             parts.append(f"shape_{shape_str}")
-        
+
         return "_".join(parts)
 
-    
+
 
     def get_op_call_lines(self, ntt_op_str):
         """Generate NTT unary operation code"""
@@ -152,19 +149,19 @@ def get_op_call_lines(self, ntt_op_str):
             ""
         ]
 
-    def generate_ntt_output_to_test(self, datatype, op_str, 
+    def generate_ntt_output_to_test(self, datatype, op_str,
                                 input_is_dynamic, output_is_dynamic,
-                                dims_spec, 
+                                dims_spec,
                                 vec_rank, vec_param,
                                 input_continuity):
         code = []
 
         code.append(f"{self.indent}//---init ntt_input---")
+        input_element_type = self.get_element_cpp_type(datatype.cpp_type, vec_rank, vec_param)
         tensor_init_lhs_code = self.generate_tensor_init(
             datatype = datatype, shape_type = input_is_dynamic, dim_spec = dims_spec,
             continuity = input_continuity, var_name="ntt_input",
-            name_suffix = "", vector_rank = vec_rank,
-            P = vec_param, integer_only = False
+            name_suffix = "", element_cpp_type=input_element_type, integer_only = False
         )
         code.extend([f"{self.indent}{line}" for line in tensor_init_lhs_code])
 
@@ -185,12 +182,12 @@ def generate_ntt_output_to_test(self, datatype, op_str,
         return code, output_shape_expr, output_element_type
 
     def _generate_vector_to_scalar_conversion(
-        self, code, 
+        self, code,
         datatype, input_var_name, input_is_dynamic,
                 input_dims_spec, vec_rank
     ):
         assert(vec_rank > 0)
-    
+
         unsqueeze_dims = ""
         unpack_dims = ""
         scalar_dims = None
@@ -212,7 +209,7 @@ def _generate_vector_to_scalar_conversion(
         return scalar_dims
 
     def _prepare_double_scalar_input(
-        self, code, datatype, input_is_dynamic, input_dims_spec, 
+        self, code, datatype, input_is_dynamic, input_dims_spec,
         vector_rank, vec_param, input_continuity, cast_target = "double"
     ):
         """
@@ -266,9 +263,9 @@ def _execute_ort_operation(self, code, datatype, ntt_op_str, cast_target):
 
 
 
-    def _generate_ntt_cast_golden_output(self, datatype, op_str, 
+    def _generate_ntt_cast_golden_output(self, datatype, op_str,
                                    input_is_dynamic, output_is_dynamic,
-                                   dims_spec , vector_rank, vec_param, 
+                                   dims_spec , vector_rank, vec_param,
                                    input_continuity, cast_target):
         """Special handling for types that cannot be cast in ORT"""
         code = []
@@ -285,7 +282,7 @@ def _generate_ntt_cast_golden_output(self, datatype, op_str,
             code, datatype, op_str, output_is_dynamic, dims_spec, vector_rank,
             vec_param, ort_golden_double_var, cast_target
         )
-            
+
         return code
 
     def _generate_ort_cast_golden_output(self, datatype, op_str,
@@ -294,7 +291,7 @@ def _generate_ort_cast_golden_output(self, datatype, op_str,
                                    input_continuity, cast_target):
         """Generate golden output using ORT with optional casting"""
         code = []
-        
+
         need_cast_in_ort = self._need_cast_in_ort(datatype, op_str)
         """
         input_var_name, input_copy_code = self._prepare_contiguous_input(
@@ -325,7 +322,7 @@ def _generate_ort_cast_golden_output(self, datatype, op_str,
         # Generate output shape and element type for ort2ntt conversion
         output_shape_expr = self.generate_shape_init(output_is_dynamic, dims_spec)
         output_element_type = self.get_element_cpp_type(datatype.cpp_type, vector_rank, vec_param)
-        
+
         cast_code, golden_var_name = self.generate_ort_back2ntt(
             datatype,
             output_element_type,
@@ -348,7 +345,7 @@ def generate_ntt_golden_output(self, datatype, op_str,
                                    dims_spec, vector_rank, vec_param,
                                    input_continuity):
         code = []
-        
+
         # Check if datatype needs special fp8 handling
         need_cast_in_ntt = datatype.cpp_type in self.types_need_cast_in_ntt
         golden_var_name = "ntt_golden"
@@ -380,7 +377,7 @@ def generate_test_case(
             dims_spec,
             vector_rank,
             input_continuity):
-        test_name = self.generate_test_name(datatype, input_is_dynamic, output_is_dynamic,
+        test_name = self.generate_test_name(input_is_dynamic, output_is_dynamic,
                                              dims_spec, vector_rank, input_continuity)
 
         P = f"NTT_VLEN / (sizeof({datatype.cpp_type}) * 8)"
@@ -390,15 +387,15 @@ def generate_test_case(
         vec_param = "P" if vector_rank > 0 else None
 
         # 1. Test header and constants
-        code.extend(self.generate_function_name(f"UnaryTest{op_str}", datatype, test_name))
+        code.extend(self.generate_function_name(f"UnaryTest{op_str}", datatype.name_suffix, test_name))
         if vector_rank > 0:
             code.extend(self.generate_P_constants(P))
 
 
         ntt_output_code, output_shape_expr, output_element_type = self.generate_ntt_output_to_test(
-                                        datatype, op_str, 
+                                        datatype, op_str,
                                         input_is_dynamic, output_is_dynamic,
-                                        dims_spec, 
+                                        dims_spec,
                                         vector_rank, vec_param,
                                         input_continuity)
         code.extend(ntt_output_code)
@@ -413,7 +410,7 @@ def generate_test_case(
         # Add comparison code
         output_shape_expr = self.generate_shape_init(output_is_dynamic, dims_spec)
         output_element_type = self.get_element_cpp_type(datatype.cpp_type, vector_rank, vec_param)
-        
+
         compare_code = self.generate_compare(
             ntt_output_var_name="ntt_output",
             golden_var_name=golden_var_name,
@@ -474,15 +471,15 @@ def generate_tests_for_op(op_str, generator):
                 datatype = special_types[datatype.cpp_type]
 
         test_code = generator.generate_all_tests_for_type(datatype, op_str)
-        filename = f"test_ntt_unary_{datatype.name_suffix.lower()}_{op_str}_generated.cpp"
+        filename = f"test_ntt_unary_{op_str}_{datatype.name_suffix.lower()}.cpp"
         output_filepath = os.path.join(generated_directory, filename)
 
         with open(output_filepath, "w") as f:
             f.write(test_code)
-        
+
         print(f"Test file generated: {output_filepath}")
         generated_filenames.append(filename)
-    
+
 
 if __name__ == "__main__":
     generator = UnaryTestGenerator()
@@ -490,10 +487,10 @@ def generate_tests_for_op(op_str, generator):
     # Get the parent directory (ctest) and then the generated subdirectory
     ctest_directory = os.path.dirname(script_directory)
     generated_directory = os.path.join(ctest_directory, "generated")
-    
+
     # Ensure generated directory exists
     os.makedirs(generated_directory, exist_ok=True)
-    
+
     generated_filenames = []  # collect all generated file names
 
     # for datatype in ALL_DATATYPES:
@@ -503,11 +500,11 @@ def generate_tests_for_op(op_str, generator):
 
     #     with open(output_filepath, "w") as f:
     #         f.write(test_code)
-        
+
     #     print(f"Test file generated: {output_filepath}")
     #     generated_filenames.append(filename)
 
     for op_str in (generator.op_str_map_exhaustive.keys() | generator.op_str_map_simplified.keys()):
         generate_tests_for_op(op_str, generator)
     # Generate cmake list file in the generated directory
-    generate_cmake_list(generated_directory, generated_filenames, "generated_unary_tests.cmake", "GENERATED_UNARY_TEST_SOURCES")
+    generate_cmake_list(generated_directory, generated_filenames, "unary_test.cmake", "UNARY_TESTS")
diff --git a/ntt/test/ctest/test_generator/generate_unpack_tests.py b/ntt/test/ctest/test_generator/unpack_test.py
similarity index 95%
rename from ntt/test/ctest/test_generator/generate_unpack_tests.py
rename to ntt/test/ctest/test_generator/unpack_test.py
index 2c773684ee..b4c0e8c007 100644
--- a/ntt/test/ctest/test_generator/generate_unpack_tests.py
+++ b/ntt/test/ctest/test_generator/unpack_test.py
@@ -18,9 +18,8 @@ class UnpackTestGenerator(BaseTestGenerator):
     def __init__(self):
         super().__init__()
 
-    def generate_test_name(self, datatype, shape_type, vector_dim, continuity: Continuity, unpack_axis_str, ndim):
+    def generate_test_name(self, shape_type, vector_dim, continuity: Continuity, unpack_axis_str, ndim):
         parts = []
-        parts.append(datatype.name_suffix)
         parts.append(shape_type)
         parts.append(f"{vector_dim}D_vector")
 
@@ -110,7 +109,7 @@ def generate_ntt_output_to_test(self, datatype, shape_type, dim_names, continuit
         # 2. NTT operation (unpack)
         output_dims = self.get_unpacked_dims(dim_names, unpack_axes)
         output_shape_expr = self.generate_shape_init(shape_type, output_dims)
-        
+
         unpack_call_code = self.generate_ntt_ops(unpack_axes)
 
         op_code = self.generate_ntt_output_and_op_section(
@@ -120,7 +119,7 @@ def generate_ntt_output_to_test(self, datatype, shape_type, dim_names, continuit
             ntt_op_call_lines=unpack_call_code
         )
         code.extend(op_code)
-        
+
         return code, output_shape_expr
 
     def generate_ort_golden_output(self, datatype, shape_type, dims, dim_names, continuity, vector_dim, P, unpack_axes, deal_fp8, output_shape_expr):
@@ -160,13 +159,13 @@ def generate_test_case(self, datatype, shape_type, vector_dim, continuity, unpac
         else:
             dims, dim_names = [2, 8, 4, 4, 2], ['N', 'C', 'H', 'W', 'D']
 
-        test_name = self.generate_test_name(datatype, shape_type, vector_dim, continuity, "_".join(map(str, unpack_axes)), ndim)
+        test_name = self.generate_test_name(shape_type, vector_dim, continuity, "_".join(map(str, unpack_axes)), ndim)
 
         code: List[str] = []
 
         # 1. Test header and constants
         code.extend(self.generate_test_prologue("UnpackTest", datatype, test_name, P, dim_names, dims))
-        
+
         # Generate output to test in ntt format
         ntt_output_code, output_shape_expr = self.generate_ntt_output_to_test(datatype, shape_type, dim_names, continuity, vector_dim, P, unpack_axes, deal_fp8)
         code.extend([f"    {line}" for line in ntt_output_code])
@@ -222,7 +221,7 @@ def generate_all_tests_for_type(self, datatype):
                     # The vector dimension must match the number of axes to unpack.
                     if vector_dim != len(unpack_axes) and vector_dim > 0:
                         continue
-                    
+
                     test_code = self.generate_test_case(datatype, shape_type, vector_dim, continuity, unpack_axes, ndim)
                     code.append(test_code)
 
@@ -238,7 +237,7 @@ def generate_all_tests_for_type(self, datatype):
     # Get the parent directory (ctest) and then the generated subdirectory
     ctest_directory = os.path.dirname(script_directory)
     generated_directory = os.path.join(ctest_directory, "generated")
-    
+
     # Ensure generated directory exists
     os.makedirs(generated_directory, exist_ok=True)
 
@@ -246,7 +245,7 @@ def generate_all_tests_for_type(self, datatype):
 
     for datatype in ALL_DATATYPES:
         test_code = generator.generate_all_tests_for_type(datatype)
-        filename = f"test_ntt_unpack_generated_{datatype.name_suffix}.cpp"
+        filename = f"test_ntt_unpack_{datatype.name_suffix}.cpp"
         output_filepath = os.path.join(generated_directory, filename)
 
         with open(output_filepath, "w") as f:
@@ -255,4 +254,4 @@ def generate_all_tests_for_type(self, datatype):
         print(f"Test file generated: {output_filepath}")
         generated_filenames.append(filename)
 
-    generate_cmake_list(generated_directory, generated_filenames, "generated_unpack_tests.cmake", "GENERATED_UNPACK_TEST_SOURCES")
+    generate_cmake_list(generated_directory, generated_filenames, "unpack_test.cmake", "UNPACK_TESTS")
diff --git a/ntt/test/ctest/test_ntt_cast.cpp b/ntt/test/ctest/test_ntt_cast.cpp
index 28b5a1d5cd..14e54561e7 100644
--- a/ntt/test/ctest/test_ntt_cast.cpp
+++ b/ntt/test/ctest/test_ntt_cast.cpp
@@ -25,644 +25,479 @@
 using namespace nncase;
 using namespace ortki;
 
-TEST(CastTestFloat32ToInt32, NoVectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
-    float min_input = -100.0f;
-    float max_input = 100.0f;
+TEST(CastTest_fp32_i32, NoVectorize) {
+    auto ntt_input = ntt::make_tensor<float>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -32761.0f, 32761.0f, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<int32_t>(ntt::fixed_shape_v<8, 80, 8>);
 
-    // init
-    auto ntt_input = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
 
-    // ntt
-    auto ntt_output1 = ntt::make_tensor<int32_t>(ntt::fixed_shape_v<M, N>);
-    ntt::cast(ntt_input, ntt_output1, ntt::fixed_shape_v<>);
 
-    // ort
     auto ort_input = NttTest::ntt2ort(ntt_input);
+    // ORT reference implementation
     auto ort_output = ortki_Cast(ort_input, 1, DataType_INT32);
 
-    // compare
-    auto ntt_output2 = ntt::make_tensor<int32_t>(ntt::fixed_shape_v<M, N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    // ------------------------------------------------------------------
+    // 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output
+    // ------------------------------------------------------------------
+    auto ntt_golden = ntt::make_tensor<int32_t>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::ort2ntt(ort_output, ntt_golden);
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
-TEST(CastTestFloat32ToInt32_ranked, NoVectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
-    float min_input = -100.0f;
-    float max_input = 100.0f;
-
-    auto shape = ntt::make_shape(M, N);
+TEST(CastTest_fp32_i32, 1D_Vectorize) {
+    constexpr size_t P = NTT_VLEN / (sizeof(float) * 8);
+    auto ntt_input = ntt::make_tensor<ntt::vector<float, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -32761.0f, 32761.0f, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<ntt::vector<int32_t, P>>(ntt::fixed_shape_v<8, 80, 8>);
 
-    // init
-    auto ntt_input = ntt::make_tensor<float>(shape);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
 
-    // ntt
-    auto ntt_output1 = ntt::make_tensor<int32_t>(shape);
-    ntt::cast(ntt_input, ntt_output1, ntt::fixed_shape_v<>);
 
-    // ort
     auto ort_input = NttTest::ntt2ort(ntt_input);
+    // ORT reference implementation
     auto ort_output = ortki_Cast(ort_input, 1, DataType_INT32);
 
-    // compare
-    auto ntt_output2 = ntt::make_tensor<int32_t>(shape);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    // ------------------------------------------------------------------
+    // 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output
+    // ------------------------------------------------------------------
+    auto ntt_golden = ntt::make_tensor<ntt::vector<int32_t, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::ort2ntt(ort_output, ntt_golden);
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
-TEST(CastTestFloat32ToInt32, Vectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
+TEST(CastTest_fp32_i32, 2D_Vectorize) {
     constexpr size_t P = NTT_VLEN / (sizeof(float) * 8);
-    float min_input = -100.0f;
-    float max_input = 100.0f;
-
-    // init
-    auto ntt_input = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto vectorize_input =
-        ntt::make_tensor<ntt::vector<float, P>>(ntt::fixed_shape_v<M / P, N>);
-    auto vectorize_output =
-        ntt::make_tensor<ntt::vector<int32_t, P>>(ntt::fixed_shape_v<M / P, N>);
-    ntt::pack(ntt_input, vectorize_input, ntt::fixed_shape_v<0>);
-    ntt::cast(vectorize_input, vectorize_output, ntt::fixed_shape_v<0>);
-    auto ntt_output1 = ntt::make_tensor<int32_t>(ntt::fixed_shape_v<M, N>);
-    ntt::unpack(vectorize_output, ntt_output1, ntt::fixed_shape_v<0>);
-
-    // ort
-    auto ort_input = NttTest::ntt2ort(ntt_input);
-    auto ort_output = ortki_Cast(ort_input, 1, DataType_INT32);
+    auto ntt_input = ntt::make_tensor<ntt::vector<float, 4, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -32761.0f, 32761.0f, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<ntt::vector<int32_t, 4, P>>(ntt::fixed_shape_v<8, 80, 8>);
 
-    // compare
-    auto ntt_output2 = ntt::make_tensor<int32_t>(ntt::fixed_shape_v<M, N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
-}
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
 
-TEST(CastTestInt32ToFloat32, NoVectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
-    int32_t min_input = -100;
-    int32_t max_input = 100;
 
-    // init
-    auto ntt_input = ntt::make_tensor<int32_t>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto ntt_output1 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    ntt::cast(ntt_input, ntt_output1, ntt::fixed_shape_v<>);
-
-    // ort
     auto ort_input = NttTest::ntt2ort(ntt_input);
-    auto ort_output = ortki_Cast(ort_input, 1, DataType_FLOAT);
+    // ORT reference implementation
+    auto ort_output = ortki_Cast(ort_input, 1, DataType_INT32);
 
-    // compare
-    auto ntt_output2 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    // ------------------------------------------------------------------
+    // 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output
+    // ------------------------------------------------------------------
+    auto ntt_golden = ntt::make_tensor<ntt::vector<int32_t, 4, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::ort2ntt(ort_output, ntt_golden);
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
-TEST(CastTestInt32ToFloat32, Vectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
-    constexpr size_t P = NTT_VLEN / (sizeof(float) * 8);
-    int32_t min_input = -100;
-    int32_t max_input = 100;
-
-    // init
-    auto ntt_input = ntt::make_tensor<int32_t>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto vectorize_input =
-        ntt::make_tensor<ntt::vector<int32_t, P>>(ntt::fixed_shape_v<M / P, N>);
-    auto vectorize_output =
-        ntt::make_tensor<ntt::vector<float, P>>(ntt::fixed_shape_v<M / P, N>);
-    ntt::pack(ntt_input, vectorize_input, ntt::fixed_shape_v<0>);
-    ntt::cast(vectorize_input, vectorize_output, ntt::fixed_shape_v<0>);
-    auto ntt_output1 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    ntt::unpack(vectorize_output, ntt_output1, ntt::fixed_shape_v<0>);
-
-    // ort
-    auto ort_input = NttTest::ntt2ort(ntt_input);
-    auto ort_output = ortki_Cast(ort_input, 1, DataType_FLOAT);
-
-    // compare
-    auto ntt_output2 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
-}
 
-TEST(CastTestFloat32ToUint32, NoVectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
-    float min_input = 0.f;
-    float max_input = 100.0f;
+TEST(CastTest_fp32_i8, NoVectorize) {
+    auto ntt_input = ntt::make_tensor<float>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -11.0f, 11.0f, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<int8_t>(ntt::fixed_shape_v<8, 80, 8>);
 
-    // init
-    auto ntt_input = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
 
-    // ntt
-    auto ntt_output1 = ntt::make_tensor<unsigned int>(ntt::fixed_shape_v<M, N>);
-    ntt::cast(ntt_input, ntt_output1, ntt::fixed_shape_v<>);
 
-    // ort
     auto ort_input = NttTest::ntt2ort(ntt_input);
-    auto ort_output = ortki_Cast(ort_input, 1, DataType_UINT32);
-
-    // compare
-    auto ntt_output2 = ntt::make_tensor<unsigned int>(ntt::fixed_shape_v<M, N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    // ORT reference implementation
+    auto ort_output = ortki_Cast(ort_input, 1, DataType_INT8);
+
+    // ------------------------------------------------------------------
+    // 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output
+    // ------------------------------------------------------------------
+    auto ntt_golden = ntt::make_tensor<int8_t>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::ort2ntt(ort_output, ntt_golden);
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
-TEST(CastTestFloat32ToUint32, Vectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
+TEST(CastTest_fp32_i8, Vectorize) {
     constexpr size_t P = NTT_VLEN / (sizeof(float) * 8);
-    float min_input = 0.f;
-    float max_input = 100.0f;
-
-    // init
-    auto ntt_input = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto vectorize_input =
-        ntt::make_tensor<ntt::vector<float, P>>(ntt::fixed_shape_v<M / P, N>);
-    auto vectorize_output = ntt::make_tensor<ntt::vector<unsigned int, P>>(
-        ntt::fixed_shape_v<M / P, N>);
-    ntt::pack(ntt_input, vectorize_input, ntt::fixed_shape_v<0>);
-    ntt::cast(vectorize_input, vectorize_output, ntt::fixed_shape_v<0>);
-    auto ntt_output1 = ntt::make_tensor<unsigned int>(ntt::fixed_shape_v<M, N>);
-    ntt::unpack(vectorize_output, ntt_output1, ntt::fixed_shape_v<0>);
-
-    // ort
+    auto ntt_input = ntt::make_tensor<ntt::vector<float, 4, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -11.0f, 11.0f, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<ntt::vector<int8_t, 4 * P>>(ntt::fixed_shape_v<8, 80, 8>);
+
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
+
+    // Reshape and transpose for 1D vector cast
+    int64_t reshape_data[] = {8, 80, 8, 4, P};
+    int64_t reshape_shape[] = {std::size(reshape_data)};
+    auto ort_type = NttTest::primitive_type2ort_type<int64_t>();
+    auto shape_tensor1 = make_tensor(reinterpret_cast<void *>(reshape_data), ort_type,
+                             reshape_shape, std::size(reshape_shape));
     auto ort_input = NttTest::ntt2ort(ntt_input);
-    auto ort_output = ortki_Cast(ort_input, 1, DataType_UINT32);
-
-    // compare
-    auto ntt_output2 = ntt::make_tensor<unsigned int>(ntt::fixed_shape_v<M, N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    auto reshaped_tensor1 = ortki_Reshape(ort_input, shape_tensor1, 0);
+
+    int64_t perms_data[] = {0, 1, 2, 3, 4};
+    auto ort_cast_input = ortki_Transpose(reshaped_tensor1, perms_data, std::size(perms_data));
+
+    auto ort_output = ortki_Cast(ort_cast_input, 1, DataType_INT8);
+    // ------------------------------------------------------------------
+    // 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output
+    // ------------------------------------------------------------------
+    auto ntt_golden = ntt::make_tensor<ntt::vector<int8_t, 4 * P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::ort2ntt(ort_output, ntt_golden);
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
-TEST(CastTestUint32ToFloat32, NoVectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
-    unsigned int min_input = 0;
-    unsigned int max_input = 100;
 
-    // init
-    auto ntt_input = ntt::make_tensor<unsigned int>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
+TEST(CastTest_i8_fp32, NoVectorize) {
+    auto ntt_input = ntt::make_tensor<int8_t>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -11, 11, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<float>(ntt::fixed_shape_v<8, 80, 8>);
+
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
 
-    // ntt
-    auto ntt_output1 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    ntt::cast(ntt_input, ntt_output1, ntt::fixed_shape_v<>);
 
-    // ort
     auto ort_input = NttTest::ntt2ort(ntt_input);
+    // ORT reference implementation
     auto ort_output = ortki_Cast(ort_input, 1, DataType_FLOAT);
 
-    // compare
-    auto ntt_output2 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    // ------------------------------------------------------------------
+    // 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output
+    // ------------------------------------------------------------------
+    auto ntt_golden = ntt::make_tensor<float>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::ort2ntt(ort_output, ntt_golden);
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
-TEST(CastTestUint32ToFloat32, Vectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
-    constexpr size_t P = NTT_VLEN / (sizeof(float) * 8);
-    unsigned int min_input = 0;
-    unsigned int max_input = 100;
-
-    // init
-    auto ntt_input = ntt::make_tensor<unsigned int>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto vectorize_input = ntt::make_tensor<ntt::vector<unsigned int, P>>(
-        ntt::fixed_shape_v<M / P, N>);
-    auto vectorize_output =
-        ntt::make_tensor<ntt::vector<float, P>>(ntt::fixed_shape_v<M / P, N>);
-    ntt::pack(ntt_input, vectorize_input, ntt::fixed_shape_v<0>);
-    ntt::cast(vectorize_input, vectorize_output, ntt::fixed_shape_v<0>);
-    auto ntt_output1 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    ntt::unpack(vectorize_output, ntt_output1, ntt::fixed_shape_v<0>);
-
-    // ort
+TEST(CastTest_i8_fp32, Vectorize) {
+    constexpr size_t P = NTT_VLEN / (sizeof(int8_t) * 8);
+    auto ntt_input = ntt::make_tensor<ntt::vector<int8_t, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -11, 11, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<ntt::vector<float, 4, P / 4>>(ntt::fixed_shape_v<8, 80, 8>);
+
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
+
+
+    // Reshape and transpose for 1D vector cast
+    int64_t reshape_data[] = {8, 80, 8, 4, P / 4};
+    int64_t reshape_shape[] = {std::size(reshape_data)};
+    auto ort_type = NttTest::primitive_type2ort_type<int64_t>();
+    auto shape_tensor1 = make_tensor(reinterpret_cast<void *>(reshape_data), ort_type,
+                             reshape_shape, std::size(reshape_shape));
     auto ort_input = NttTest::ntt2ort(ntt_input);
-    auto ort_output = ortki_Cast(ort_input, 1, DataType_FLOAT);
-
-    // compare
-    auto ntt_output2 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    auto reshaped_tensor1 = ortki_Reshape(ort_input, shape_tensor1, 0);
+
+    int64_t perms_data[] = {0, 1, 2, 3, 4};
+    auto ort_cast_input = ortki_Transpose(reshaped_tensor1, perms_data, std::size(perms_data));
+
+    auto ort_output = ortki_Cast(ort_cast_input, 1, DataType_FLOAT);
+    // ------------------------------------------------------------------
+    // 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output
+    // ------------------------------------------------------------------
+    auto ntt_golden = ntt::make_tensor<ntt::vector<float, 4, P / 4>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::ort2ntt(ort_output, ntt_golden);
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
-TEST(CastTestFloat32ToBool, NoVectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
-    float min_input = -100.0f;
-    float max_input = 100.0f;
-
-    // init
-    auto ntt_input = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
+TEST(CastTest_fp32_b, NoVectorize) {
+    auto ntt_input = ntt::make_tensor<float>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -11.0f, 11.0f, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<bool>(ntt::fixed_shape_v<8, 80, 8>);
 
-    // ntt
-    auto ntt_output1 = ntt::make_tensor<bool>(ntt::fixed_shape_v<M, N>);
-    ntt::cast(ntt_input, ntt_output1, ntt::fixed_shape_v<>);
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
 
-    // ort
     auto ort_input = NttTest::ntt2ort(ntt_input);
+    // ORT reference implementation
     auto ort_output = ortki_Cast(ort_input, 1, DataType_BOOL);
 
-    // compare
-    auto ntt_output2 = ntt::make_tensor<bool>(ntt::fixed_shape_v<M, N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    // ------------------------------------------------------------------
+    // 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output
+    // ------------------------------------------------------------------
+    auto ntt_golden = ntt::make_tensor<bool>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::ort2ntt(ort_output, ntt_golden);
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
-TEST(CastTestFloat32ToBool_1D, Vectorize) {
-    constexpr size_t N = 128;
+TEST(CastTest_fp32_b, 1D_Vectorize) {
     constexpr size_t P = NTT_VLEN / (sizeof(float) * 8);
-    float min_input = -100.0f;
-    float max_input = 100.0f;
-
-    // init
-    auto ntt_input = ntt::make_tensor<float>(ntt::fixed_shape_v<N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto vectorize_input =
-        ntt::make_tensor<ntt::vector<float, P>>(ntt::fixed_shape_v<N / P>);
-    auto vectorize_output = ntt::make_tensor<ntt::vector<bool, P * 4>>(
-        ntt::fixed_shape_v<N / P / 4>);
-    ntt::pack(ntt_input, vectorize_input, ntt::fixed_shape_v<0>);
-    ntt::cast(vectorize_input, vectorize_output, ntt::fixed_shape_v<0>);
-    auto ntt_output1 = ntt::make_tensor<bool>(ntt::fixed_shape_v<N>);
-    ntt::unpack(vectorize_output, ntt_output1, ntt::fixed_shape_v<0>);
-
-    // ort
+    auto ntt_input = ntt::make_tensor<ntt::vector<float, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -11.0f, 11.0f, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<ntt::vector<bool, P>>(ntt::fixed_shape_v<8, 80, 8>);
+
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
+
+    // Reshape and transpose for 1D vector cast
+    int64_t reshape_data[] = {8, 80, 8, 1, P};
+    int64_t reshape_shape[] = {std::size(reshape_data)};
+    auto ort_type = NttTest::primitive_type2ort_type<int64_t>();
+    auto shape_tensor1 = make_tensor(reinterpret_cast<void *>(reshape_data), ort_type,
+                             reshape_shape, std::size(reshape_shape));
     auto ort_input = NttTest::ntt2ort(ntt_input);
-    auto ort_output = ortki_Cast(ort_input, 1, DataType_BOOL);
-
-    // compare
-    auto ntt_output2 = ntt::make_tensor<bool>(ntt::fixed_shape_v<N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    auto reshaped_tensor1 = ortki_Reshape(ort_input, shape_tensor1, 0);
+
+    int64_t perms_data[] = {0, 1, 2, 3, 4};
+    auto ort_cast_input = ortki_Transpose(reshaped_tensor1, perms_data, std::size(perms_data));
+
+    auto ort_output = ortki_Cast(ort_cast_input, 1, DataType_BOOL);
+    // ------------------------------------------------------------------
+    // 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output
+    // ------------------------------------------------------------------
+    auto ntt_golden = ntt::make_tensor<ntt::vector<bool, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::ort2ntt(ort_output, ntt_golden);
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
-TEST(CastTestFloat32ToBool_2D, Vectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
+TEST(CastTest_fp32_b, 2D_Vectorize) {
     constexpr size_t P = NTT_VLEN / (sizeof(float) * 8);
-    float min_input = -100.0f;
-    float max_input = 100.0f;
-
-    // init
-    auto ntt_input = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto vectorize_input =
-        ntt::make_tensor<ntt::vector<float, P>>(ntt::fixed_shape_v<M / P, N>);
-    auto vectorize_output =
-        ntt::make_tensor<ntt::vector<bool, P>>(ntt::fixed_shape_v<M / P, N>);
-    ntt::pack(ntt_input, vectorize_input, ntt::fixed_shape_v<0>);
-    ntt::cast(vectorize_input, vectorize_output, ntt::fixed_shape_v<0>);
-    auto ntt_output1 = ntt::make_tensor<bool>(ntt::fixed_shape_v<M, N>);
-    ntt::unpack(vectorize_output, ntt_output1, ntt::fixed_shape_v<0>);
-
-    // ort
+    auto ntt_input = ntt::make_tensor<ntt::vector<float, 4, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -11.0f, 11.0f, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<ntt::vector<bool, 4, P>>(ntt::fixed_shape_v<8, 80, 8>);
+
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
+
+    // Reshape and transpose for 1D vector cast
+    int64_t reshape_data[] = {8, 80, 8, 4, P};
+    int64_t reshape_shape[] = {std::size(reshape_data)};
+    auto ort_type = NttTest::primitive_type2ort_type<int64_t>();
+    auto shape_tensor1 = make_tensor(reinterpret_cast<void *>(reshape_data), ort_type,
+                             reshape_shape, std::size(reshape_shape));
     auto ort_input = NttTest::ntt2ort(ntt_input);
-    auto ort_output = ortki_Cast(ort_input, 1, DataType_BOOL);
-
-    // compare
-    auto ntt_output2 = ntt::make_tensor<bool>(ntt::fixed_shape_v<M, N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    auto reshaped_tensor1 = ortki_Reshape(ort_input, shape_tensor1, 0);
+
+    int64_t perms_data[] = {0, 1, 2, 3, 4};
+    auto ort_cast_input = ortki_Transpose(reshaped_tensor1, perms_data, std::size(perms_data));
+
+    auto ort_output = ortki_Cast(ort_cast_input, 1, DataType_BOOL);
+    // ------------------------------------------------------------------
+    // 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output
+    // ------------------------------------------------------------------
+    auto ntt_golden = ntt::make_tensor<ntt::vector<bool, 4, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::ort2ntt(ort_output, ntt_golden);
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
-TEST(CastTestBoolToFloat32, NoVectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
-    bool min_input = 0;
-    bool max_input = 1;
-
-    // init
-    auto ntt_input = ntt::make_tensor<bool>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto ntt_output1 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    ntt::cast(ntt_input, ntt_output1, ntt::fixed_shape_v<>);
+TEST(CastTest_b_fp32, NoVectorize) {
+    auto ntt_input = ntt::make_tensor<bool>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -11, 11, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<float>(ntt::fixed_shape_v<8, 80, 8>);
 
-    // ort
-    auto ort_input = NttTest::ntt2ort(ntt_input);
-    auto ort_output = ortki_Cast(ort_input, 1, DataType_FLOAT);
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
 
-    // compare
-    auto ntt_output2 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
-}
 
-TEST(CastTestBoolToFloat32_1D, Vectorize) {
-    constexpr size_t N = 128;
-    constexpr size_t P = NTT_VLEN / (sizeof(float) * 8);
-    bool min_input = 0;
-    bool max_input = 1;
-
-    // init
-    auto ntt_input = ntt::make_tensor<bool>(ntt::fixed_shape_v<N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto vectorize_input =
-        ntt::make_tensor<ntt::vector<bool, P>>(ntt::fixed_shape_v<N / P>);
-    auto vectorize_output =
-        ntt::make_tensor<ntt::vector<float, P>>(ntt::fixed_shape_v<N / P>);
-    ntt::pack(ntt_input, vectorize_input, ntt::fixed_shape_v<0>);
-    ntt::cast(vectorize_input, vectorize_output, ntt::fixed_shape_v<0>);
-    auto ntt_output1 = ntt::make_tensor<float>(ntt::fixed_shape_v<N>);
-    ntt::unpack(vectorize_output, ntt_output1, ntt::fixed_shape_v<0>);
-
-    // ort
     auto ort_input = NttTest::ntt2ort(ntt_input);
+    // ORT reference implementation
     auto ort_output = ortki_Cast(ort_input, 1, DataType_FLOAT);
 
-    // compare
-    auto ntt_output2 = ntt::make_tensor<float>(ntt::fixed_shape_v<N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    // ------------------------------------------------------------------
+    // 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output
+    // ------------------------------------------------------------------
+    auto ntt_golden = ntt::make_tensor<float>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::ort2ntt(ort_output, ntt_golden);
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
-TEST(CastTestBoolToFloat32_2D, Vectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
+TEST(CastTest_b_fp32, 1D_Vectorize) {
     constexpr size_t P = NTT_VLEN / (sizeof(float) * 8);
-    bool min_input = 0;
-    bool max_input = 1;
-
-    // init
-    auto ntt_input = ntt::make_tensor<bool>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto vectorize_input =
-        ntt::make_tensor<ntt::vector<bool, P>>(ntt::fixed_shape_v<M / P, N>);
-    auto vectorize_output =
-        ntt::make_tensor<ntt::vector<float, P>>(ntt::fixed_shape_v<M / P, N>);
-    ntt::pack(ntt_input, vectorize_input, ntt::fixed_shape_v<0>);
-    ntt::cast(vectorize_input, vectorize_output, ntt::fixed_shape_v<0>);
-    auto ntt_output1 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    ntt::unpack(vectorize_output, ntt_output1, ntt::fixed_shape_v<0>);
-
-    // ort
+    auto ntt_input = ntt::make_tensor<ntt::vector<bool, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -11, 11, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<ntt::vector<float, P>>(ntt::fixed_shape_v<8, 80, 8>);
+
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
+
+
+    // Reshape and transpose for 1D vector cast
+    int64_t reshape_data[] = {8, 80, 8, P};
+    int64_t reshape_shape[] = {std::size(reshape_data)};
+    auto ort_type = NttTest::primitive_type2ort_type<int64_t>();
+    auto shape_tensor1 = make_tensor(reinterpret_cast<void *>(reshape_data), ort_type,
+                             reshape_shape, std::size(reshape_shape));
     auto ort_input = NttTest::ntt2ort(ntt_input);
-    auto ort_output = ortki_Cast(ort_input, 1, DataType_FLOAT);
-
-    // compare
-    auto ntt_output2 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::ort2ntt(ort_output, ntt_output2);
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    auto reshaped_tensor1 = ortki_Reshape(ort_input, shape_tensor1, 0);
+
+    int64_t perms_data[] = {0, 1, 2, 3};
+    auto ort_cast_input = ortki_Transpose(reshaped_tensor1, perms_data, std::size(perms_data));
+
+    auto ort_output = ortki_Cast(ort_cast_input, 1, DataType_FLOAT);
+    // ------------------------------------------------------------------
+    // 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output
+    // ------------------------------------------------------------------
+    auto ntt_golden = ntt::make_tensor<ntt::vector<float, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::ort2ntt(ort_output, ntt_golden);
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
-TEST(CastTestFloat32ToFloat8E4M3, NoVectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
-    float min_input = -500.0f;
-    float max_input = 500.0f;
-//#  generate ntt output to test
-    // init
-    auto ntt_input = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto ntt_output1 = ntt::make_tensor<float_e4m3_t>(ntt::fixed_shape_v<M, N>);
-    ntt::cast(ntt_input, ntt_output1);
-//# generate_ort_golden_output
-    // float8
-    auto ntt_output2 = ntt::make_tensor<float_e4m3_t>(ntt::fixed_shape_v<M, N>);
-    nncase::ntt::apply(ntt_input.shape(), [&](auto index) {
-        (ntt_output2)(index) = (float_e4m3_t)(ntt_input)(index);
-    });
-//# compare
-    // compare
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
-}
 
-TEST(CastTestFloat32ToFloat8E4M3, Vectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
+TEST(CastTest_b_fp32, 2D_Vectorize) {
     constexpr size_t P = NTT_VLEN / (sizeof(float) * 8);
-    float min_input = -500.0f;
-    float max_input = 500.0f;
-//#  generate ntt output to test
-    // init
-    auto ntt_input = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto vectorize_input =
-        ntt::make_tensor<ntt::vector<float, P>>(ntt::fixed_shape_v<M / P, N>);
-    auto vectorize_output = ntt::make_tensor<ntt::vector<float_e4m3_t, P>>(
-        ntt::fixed_shape_v<M / P, N>);
-    ntt::pack(ntt_input, vectorize_input, ntt::fixed_shape_v<0>);
-    ntt::cast(vectorize_input, vectorize_output, ntt::fixed_shape_v<0>);
-    auto ntt_output1 = ntt::make_tensor<float_e4m3_t>(ntt::fixed_shape_v<M, N>);
-    ntt::unpack(vectorize_output, ntt_output1, ntt::fixed_shape_v<0>);
-
-//# generate_ort_golden_output
-    // float8
-    auto ntt_output2 = ntt::make_tensor<float_e4m3_t>(ntt::fixed_shape_v<M, N>);
-    nncase::ntt::apply(ntt_input.shape(), [&](auto index) {
-        (ntt_output2)(index) = float_e4m3_t((ntt_input)(index));
-    });
-//# compare
-    // compare
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
-}
-
-TEST(CastTestFloat8E4M3ToFloat32, NoVectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
-    float_e4m3_t min_input = (float_e4m3_t)-448.0f;
-    float_e4m3_t max_input = (float_e4m3_t)448.0f;
-
-    // init
-    auto ntt_input = ntt::make_tensor<float_e4m3_t>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto ntt_output1 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    ntt::cast(ntt_input, ntt_output1, ntt::fixed_shape_v<>);
-
-    // float8
-    auto ntt_output2 = ntt::make_tensor<float>(ntt::fixed_shape_v<M, N>);
-    nncase::ntt::apply(ntt_input.shape(), [&](auto index) {
-        (ntt_output2)(index) = (float)(ntt_input)(index);
-    });
-
-    // compare
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
-}
-
-TEST(CastTestFloat8E4M3ToFloat32, Vectorize) {
-    constexpr size_t M = 64;
-    constexpr size_t P1 = NTT_VLEN / (sizeof(float_e4m3_t) * 8);
-    constexpr size_t P2 = NTT_VLEN / (sizeof(float) * 8);
-    float_e4m3_t min_input = (float_e4m3_t)-500.0f;
-    float_e4m3_t max_input = (float_e4m3_t)500.0f;
-
-    // init
-    auto ntt_input = ntt::make_tensor<float_e4m3_t>(ntt::fixed_shape_v<M>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    auto vectorize_input = ntt::make_tensor<ntt::vector<float_e4m3_t, P1>>(
-        ntt::fixed_shape_v<M / P1>);
-    ntt::pack(ntt_input, vectorize_input, ntt::fixed_shape_v<0>);
-
-    auto vectorize_output =
-        ntt::make_tensor<ntt::vector<float, P2>>(ntt::fixed_shape_v<M / P2>);
-    ntt::cast(vectorize_input, vectorize_output, ntt::fixed_shape_v<0>);
-
-    auto ntt_output1 = ntt::make_tensor<float>(ntt::fixed_shape_v<M>);
-    ntt::unpack(vectorize_output, ntt_output1, ntt::fixed_shape_v<0>);
-
-    auto ntt_output2 = ntt::make_tensor<float>(ntt::fixed_shape_v<M>);
-    nncase::ntt::apply(ntt_input.shape(), [&](auto index) {
-        (ntt_output2)(index) = (float)((ntt_input)(index));
-    });
-
-    // compare
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    auto ntt_input = ntt::make_tensor<ntt::vector<bool, 4, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -11, 11, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<ntt::vector<float, 4, P>>(ntt::fixed_shape_v<8, 80, 8>);
+
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
+
+
+    // Reshape and transpose for 1D vector cast
+    int64_t reshape_data[] = {8, 80, 8, 4, P};
+    int64_t reshape_shape[] = {std::size(reshape_data)};
+    auto ort_type = NttTest::primitive_type2ort_type<int64_t>();
+    auto shape_tensor1 = make_tensor(reinterpret_cast<void *>(reshape_data), ort_type,
+                             reshape_shape, std::size(reshape_shape));
+    auto ort_input = NttTest::ntt2ort(ntt_input);
+    auto reshaped_tensor1 = ortki_Reshape(ort_input, shape_tensor1, 0);
+
+    int64_t perms_data[] = {0, 1, 2, 3, 4};
+    auto ort_cast_input = ortki_Transpose(reshaped_tensor1, perms_data, std::size(perms_data));
+
+    auto ort_output = ortki_Cast(ort_cast_input, 1, DataType_FLOAT);
+    // ------------------------------------------------------------------
+    // 3. convert ORT output back to NTT tensor (golden) and compare with tested NTT output
+    // ------------------------------------------------------------------
+    auto ntt_golden = ntt::make_tensor<ntt::vector<float, 4, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::ort2ntt(ort_output, ntt_golden);
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
-TEST(CastTestFloat8E4M3ToBFloat16, NoVectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
-    float_e4m3_t min_input = (float_e4m3_t)-448.0f;
-    float_e4m3_t max_input = (float_e4m3_t)448.0f;
-
-    // init
-    auto ntt_input = ntt::make_tensor<float_e4m3_t>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    // ntt
-    auto ntt_output1 = ntt::make_tensor<bfloat16>(ntt::fixed_shape_v<M, N>);
-    ntt::cast(ntt_input, ntt_output1, ntt::fixed_shape_v<>);
-
-    // float8
-    auto ntt_output2 = ntt::make_tensor<bfloat16>(ntt::fixed_shape_v<M, N>);
-    nncase::ntt::apply(ntt_input.shape(), [&](auto index) {
-        (ntt_output2)(index) = (bfloat16)(ntt_input)(index);
+TEST(CastTest_bf16_fp8e4m3, fixed_2D_vector_contiguous_3D) {
+    constexpr size_t P = NTT_VLEN / (sizeof(bfloat16) * 8);
+    auto ntt_input = ntt::make_tensor<ntt::vector<bfloat16, 2, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, -10.0_bf16, 10.0_bf16, true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<ntt::vector<float_e4m3_t, 2 * P>>(ntt::fixed_shape_v<8, 80, 8>);
+
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
+
+
+#if 1
+    // auto ntt_input2 = ntt::make_tensor<ntt::vector<bfloat16, 2, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    // ntt::cast(ntt_output, ntt_input2);
+    // EXPECT_TRUE(NttTest::compare_tensor(ntt_input, ntt_input2));
+    auto ntt_golden = ntt::make_tensor<ntt::vector<float_e4m3_t, 2 * P>>(ntt::fixed_shape_v<8, 80, 8>);
+
+    ntt::apply(ntt_input.shape(), [&](auto& index){
+      ntt::apply(ntt_input(index).shape(), [&](auto& sub_index){
+        auto val = static_cast<float_e4m3_t>(ntt_input(index)(sub_index));
+        size_t linear_idx = linear_offset(sub_index, ntt_input(index).shape());
+        (ntt_golden)(index)(linear_idx) = val;
+      });
     });
-
-    // compare
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
-}
-
-TEST(CastTestFloat8E4M3ToBFloat16, Vectorize) {
-    constexpr size_t M = 64;
-    constexpr size_t P1 = NTT_VLEN / (sizeof(float_e4m3_t) * 8);
-    constexpr size_t P2 = NTT_VLEN / (sizeof(bfloat16) * 8);
-    float_e4m3_t min_input = (float_e4m3_t)-500.0f;
-    float_e4m3_t max_input = (float_e4m3_t)500.0f;
-
-    // init
-    auto ntt_input = ntt::make_tensor<float_e4m3_t>(ntt::fixed_shape_v<M>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    auto vectorize_input = ntt::make_tensor<ntt::vector<float_e4m3_t, P1>>(
-        ntt::fixed_shape_v<M / P1>);
-    ntt::pack(ntt_input, vectorize_input, ntt::fixed_shape_v<0>);
-
-    auto vectorize_output =
-        ntt::make_tensor<ntt::vector<bfloat16, P2>>(ntt::fixed_shape_v<M / P2>);
-    ntt::cast(vectorize_input, vectorize_output, ntt::fixed_shape_v<0>);
-
-    auto ntt_output1 = ntt::make_tensor<bfloat16>(ntt::fixed_shape_v<M>);
-    ntt::unpack(vectorize_output, ntt_output1, ntt::fixed_shape_v<0>);
-
-    auto ntt_output2 = ntt::make_tensor<bfloat16>(ntt::fixed_shape_v<M>);
-    nncase::ntt::apply(ntt_input.shape(), [&](auto index) {
-        (ntt_output2)(index) = (bfloat16)((ntt_input)(index));
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
+
+#else
+    auto ntt_scalar_input = ntt::make_tensor<bfloat16>(ntt::fixed_shape_v<8, 80 * 2, 8 * P>);
+    ntt::unpack(ntt_input, ntt_scalar_input, ntt::fixed_shape_v<1, 2>);
+    auto ntt_golden_scalar = ntt::make_tensor<float_e4m3_t>(ntt_scalar_input.shape());
+    ntt::apply(ntt_golden_scalar.shape(), [&](auto& index){
+      (ntt_golden_scalar)(index) = static_cast<float_e4m3_t>(ntt_scalar_input(index));
     });
 
-    // compare
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
-}
-
-TEST(CastTestFloat8E4M3ToHalf, NoVectorize) {
-    constexpr size_t M = 32;
-    constexpr size_t N = 32;
-    float_e4m3_t min_input = (float_e4m3_t)-448.0f;
-    float_e4m3_t max_input = (float_e4m3_t)448.0f;
+    // auto ntt_scalar_reshape = ntt::make_tensor<float_e4m3_t>(ntt::fixed_shape_v<8, 80, 2 * 8 * P>);
+    // ntt::reshape(ntt_golden_scalar, ntt_scalar_reshape);
 
-    // init
-    auto ntt_input = ntt::make_tensor<float_e4m3_t>(ntt::fixed_shape_v<M, N>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
+    auto ntt_golden_vector = ntt::make_tensor<ntt::vector<float_e4m3_t, 2, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    ntt::pack(ntt_golden_scalar, ntt_golden_vector, ntt::fixed_shape_v<1, 2>);
 
-    // ntt
-    auto ntt_output1 = ntt::make_tensor<half>(ntt::fixed_shape_v<M, N>);
-    ntt::cast(ntt_input, ntt_output1, ntt::fixed_shape_v<>);
 
-    // float8
-    auto ntt_output2 = ntt::make_tensor<half>(ntt::fixed_shape_v<M, N>);
-    nncase::ntt::apply(ntt_input.shape(), [&](auto index) {
-        (ntt_output2)(index) = (half)(ntt_input)(index);
+    auto ntt_golden = ntt::make_tensor<ntt::vector<float_e4m3_t, 2 * P>>(ntt::fixed_shape_v<8, 80, 8>);
+    ntt::apply(ntt_golden.shape(), [&](auto& index){
+    //   (ntt_golden)(index) = static_cast<ntt::vector<float_e4m3_t, 2 * P>>(ntt_golden_vector(index));
+      ntt::reshape(ntt_golden_vector(index), (ntt_golden)(index) );
     });
 
-    // compare
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    // auto& ntt_golden = ntt_golden_vector;
+    // Compare results
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
+#endif
 }
 
-TEST(CastTestFloat8E4M3ToHalf, Vectorize) {
-    constexpr size_t M = 64;
-    constexpr size_t P1 = NTT_VLEN / (sizeof(float_e4m3_t) * 8);
-    constexpr size_t P2 = NTT_VLEN / (sizeof(half) * 8);
-    float_e4m3_t min_input = (float_e4m3_t)-500.0f;
-    float_e4m3_t max_input = (float_e4m3_t)500.0f;
-
-    // init
-    auto ntt_input = ntt::make_tensor<float_e4m3_t>(ntt::fixed_shape_v<M>);
-    NttTest::init_tensor(ntt_input, min_input, max_input);
-
-    auto vectorize_input = ntt::make_tensor<ntt::vector<float_e4m3_t, P1>>(
-        ntt::fixed_shape_v<M / P1>);
-    ntt::pack(ntt_input, vectorize_input, ntt::fixed_shape_v<0>);
-
-    auto vectorize_output =
-        ntt::make_tensor<ntt::vector<half, P2>>(ntt::fixed_shape_v<M / P2>);
-    ntt::cast(vectorize_input, vectorize_output, ntt::fixed_shape_v<0>);
-
-    auto ntt_output1 = ntt::make_tensor<half>(ntt::fixed_shape_v<M>);
-    ntt::unpack(vectorize_output, ntt_output1, ntt::fixed_shape_v<0>);
-
-    auto ntt_output2 = ntt::make_tensor<half>(ntt::fixed_shape_v<M>);
-    nncase::ntt::apply(ntt_input.shape(), [&](auto index) {
-        (ntt_output2)(index) = (half)((ntt_input)(index));
+TEST(CastTest_fp8e4m3_fp16, fixed_1D_vector_contiguous_3D) {
+    constexpr size_t P = NTT_VLEN / (sizeof(float_e4m3_t) * 8);
+    auto ntt_input = ntt::make_tensor<ntt::vector<float_e4m3_t, P>>(ntt::fixed_shape_v<8, 80, 8>);
+    NttTest::init_tensor(ntt_input, float_e4m3_t(-16.0f), float_e4m3_t(16.0f), true, false);
+    // Create output tensor
+    auto ntt_output = ntt::make_tensor<ntt::vector<half, 2, P / 2>>(ntt::fixed_shape_v<8, 80, 8>);
+
+    // ------------------------------------------------------------------
+    // 2. call NTT operation to get NTT output (under test)
+    // ------------------------------------------------------------------
+    // Execute cast operation
+    ntt::cast(ntt_input, ntt_output);
+
+
+    auto ntt_golden = ntt::make_tensor<ntt::vector<half, 2, P / 2>>(ntt::fixed_shape_v<8, 80, 8>);
+    ntt::apply((ntt_input).shape(), [&](auto& index1){
+        auto &v_in = (ntt_input)(index1);
+        auto &v_out = ntt_golden(index1);
+        ntt::apply(v_in.shape(), [&](auto& index2) {
+            auto val = static_cast<half>(v_in(index2));
+            auto offset = linear_offset(index2, v_in.shape());
+            auto index3 = unravel_index(offset, v_out.shape());
+            v_out(index3) = val;
+        });
     });
 
-    // compare
-    EXPECT_TRUE(NttTest::compare_tensor(ntt_output1, ntt_output2));
+    // Compare results
+    EXPECT_TRUE(NttTest::compare_tensor(ntt_output, ntt_golden));
 }
 
 int main(int argc, char *argv[]) {
     ::testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();
-}
+}
\ No newline at end of file
diff --git a/src/Native/src/test.cpp b/src/Native/src/test.cpp
index c8298c3ee7..adf9bc11d0 100644
--- a/src/Native/src/test.cpp
+++ b/src/Native/src/test.cpp
@@ -1215,13 +1215,13 @@ void test_im2col() {
                     ntt::fixed_paddings_v<1, 1, 1, 1>);
         // clang-format off
       assert(output(0,0) == 0.f); assert(output(0,1) == 0.f); assert(output(0,2) == 0.f); assert(output(0,3) == 0.f); assert(output(0,4) == 0.f); assert(output(0,5) == 0.f); assert(output(0,6) == 1.f); assert(output(0,7) == 2.f); assert(output(0,8) == 0.f); assert(output(0,9) == 4.f); assert(output(0,10) == 5.f); assert(output(0,11) == 6.f); assert(output(0,12) == 0.f); assert(output(0,13) == 8.f); assert(output(0,14) == 9.f); assert(output(0,15) == 10.f);
-      assert(output(1,0) == 0.f); assert(output(1,1) == 0.f); assert(output(1,2) == 0.f); assert(output(1,3) == 0.f); assert(output(1,4) == 0.f); assert(output(1,5) == 1.f); assert(output(1,6) == 2.f); assert(output(1,7) == 3.f); assert(output(1,8) == 4.f); assert(output(1,9) == 5.f); assert(output(1,10) == 6.f); assert(output(1,11) == 7.f); assert(output(1,12) == 8.f); assert(output(1,13) == 9.f); assert(output(1,14) == 10.f); assert(output(1,15) == 11.f); 
-      assert(output(2,0) == 0.f); assert(output(2,1) == 0.f); assert(output(2,2) == 0.f); assert(output(2,3) == 0.f); assert(output(2,4) == 1.f); assert(output(2,5) == 2.f); assert(output(2,6) == 3.f); assert(output(2,7) == 0.f); assert(output(2,8) == 5.f); assert(output(2,9) == 6.f); assert(output(2,10) == 7.f); assert(output(2,11) == 0.f); assert(output(2,12) == 9.f); assert(output(2,13) == 10.f); assert(output(2,14) == 11.f); assert(output(2,15) == 0.f); 
-      assert(output(3,0) == 0.f); assert(output(3,1) == 0.f); assert(output(3,2) == 1.f); assert(output(3,3) == 2.f); assert(output(3,4) == 0.f); assert(output(3,5) == 4.f); assert(output(3,6) == 5.f); assert(output(3,7) == 6.f); assert(output(3,8) == 0.f); assert(output(3,9) == 8.f); assert(output(3,10) == 9.f); assert(output(3,11) == 10.f); assert(output(3,12) == 0.f); assert(output(3,13) == 12.f); assert(output(3,14) == 13.f); assert(output(3,15) == 14.f); 
-      assert(output(4,0) == 0.f); assert(output(4,1) == 1.f); assert(output(4,2) == 2.f); assert(output(4,3) == 3.f); assert(output(4,4) == 4.f); assert(output(4,5) == 5.f); assert(output(4,6) == 6.f); assert(output(4,7) == 7.f); assert(output(4,8) == 8.f); assert(output(4,9) == 9.f); assert(output(4,10) == 10.f); assert(output(4,11) == 11.f); assert(output(4,12) == 12.f); assert(output(4,13) == 13.f); assert(output(4,14) == 14.f); assert(output(4,15) == 15.f); 
-      assert(output(5,0) == 1.f); assert(output(5,1) == 2.f); assert(output(5,2) == 3.f); assert(output(5,3) == 0.f); assert(output(5,4) == 5.f); assert(output(5,5) == 6.f); assert(output(5,6) == 7.f); assert(output(5,7) == 0.f); assert(output(5,8) == 9.f); assert(output(5,9) == 10.f); assert(output(5,10) == 11.f); assert(output(5,11) == 0.f); assert(output(5,12) == 13.f); assert(output(5,13) == 14.f); assert(output(5,14) == 15.f); assert(output(5,15) == 0.f); 
-      assert(output(6,0) == 0.f); assert(output(6,1) == 4.f); assert(output(6,2) == 5.f); assert(output(6,3) == 6.f); assert(output(6,4) == 0.f); assert(output(6,5) == 8.f); assert(output(6,6) == 9.f); assert(output(6,7) == 10.f); assert(output(6,8) == 0.f); assert(output(6,9) == 12.f); assert(output(6,10) == 13.f); assert(output(6,11) == 14.f); assert(output(6,12) == 0.f); assert(output(6,13) == 0.f); assert(output(6,14) == 0.f); assert(output(6,15) == 0.f); 
-      assert(output(7,0) == 4.f); assert(output(7,1) == 5.f); assert(output(7,2) == 6.f); assert(output(7,3) == 7.f); assert(output(7,4) == 8.f); assert(output(7,5) == 9.f); assert(output(7,6) == 10.f); assert(output(7,7) == 11.f); assert(output(7,8) == 12.f); assert(output(7,9) == 13.f); assert(output(7,10) == 14.f); assert(output(7,11) == 15.f); assert(output(7,12) == 0.f); assert(output(7,13) == 0.f); assert(output(7,14) == 0.f); assert(output(7,15) == 0.f); 
+      assert(output(1,0) == 0.f); assert(output(1,1) == 0.f); assert(output(1,2) == 0.f); assert(output(1,3) == 0.f); assert(output(1,4) == 0.f); assert(output(1,5) == 1.f); assert(output(1,6) == 2.f); assert(output(1,7) == 3.f); assert(output(1,8) == 4.f); assert(output(1,9) == 5.f); assert(output(1,10) == 6.f); assert(output(1,11) == 7.f); assert(output(1,12) == 8.f); assert(output(1,13) == 9.f); assert(output(1,14) == 10.f); assert(output(1,15) == 11.f);
+      assert(output(2,0) == 0.f); assert(output(2,1) == 0.f); assert(output(2,2) == 0.f); assert(output(2,3) == 0.f); assert(output(2,4) == 1.f); assert(output(2,5) == 2.f); assert(output(2,6) == 3.f); assert(output(2,7) == 0.f); assert(output(2,8) == 5.f); assert(output(2,9) == 6.f); assert(output(2,10) == 7.f); assert(output(2,11) == 0.f); assert(output(2,12) == 9.f); assert(output(2,13) == 10.f); assert(output(2,14) == 11.f); assert(output(2,15) == 0.f);
+      assert(output(3,0) == 0.f); assert(output(3,1) == 0.f); assert(output(3,2) == 1.f); assert(output(3,3) == 2.f); assert(output(3,4) == 0.f); assert(output(3,5) == 4.f); assert(output(3,6) == 5.f); assert(output(3,7) == 6.f); assert(output(3,8) == 0.f); assert(output(3,9) == 8.f); assert(output(3,10) == 9.f); assert(output(3,11) == 10.f); assert(output(3,12) == 0.f); assert(output(3,13) == 12.f); assert(output(3,14) == 13.f); assert(output(3,15) == 14.f);
+      assert(output(4,0) == 0.f); assert(output(4,1) == 1.f); assert(output(4,2) == 2.f); assert(output(4,3) == 3.f); assert(output(4,4) == 4.f); assert(output(4,5) == 5.f); assert(output(4,6) == 6.f); assert(output(4,7) == 7.f); assert(output(4,8) == 8.f); assert(output(4,9) == 9.f); assert(output(4,10) == 10.f); assert(output(4,11) == 11.f); assert(output(4,12) == 12.f); assert(output(4,13) == 13.f); assert(output(4,14) == 14.f); assert(output(4,15) == 15.f);
+      assert(output(5,0) == 1.f); assert(output(5,1) == 2.f); assert(output(5,2) == 3.f); assert(output(5,3) == 0.f); assert(output(5,4) == 5.f); assert(output(5,5) == 6.f); assert(output(5,6) == 7.f); assert(output(5,7) == 0.f); assert(output(5,8) == 9.f); assert(output(5,9) == 10.f); assert(output(5,10) == 11.f); assert(output(5,11) == 0.f); assert(output(5,12) == 13.f); assert(output(5,13) == 14.f); assert(output(5,14) == 15.f); assert(output(5,15) == 0.f);
+      assert(output(6,0) == 0.f); assert(output(6,1) == 4.f); assert(output(6,2) == 5.f); assert(output(6,3) == 6.f); assert(output(6,4) == 0.f); assert(output(6,5) == 8.f); assert(output(6,6) == 9.f); assert(output(6,7) == 10.f); assert(output(6,8) == 0.f); assert(output(6,9) == 12.f); assert(output(6,10) == 13.f); assert(output(6,11) == 14.f); assert(output(6,12) == 0.f); assert(output(6,13) == 0.f); assert(output(6,14) == 0.f); assert(output(6,15) == 0.f);
+      assert(output(7,0) == 4.f); assert(output(7,1) == 5.f); assert(output(7,2) == 6.f); assert(output(7,3) == 7.f); assert(output(7,4) == 8.f); assert(output(7,5) == 9.f); assert(output(7,6) == 10.f); assert(output(7,7) == 11.f); assert(output(7,8) == 12.f); assert(output(7,9) == 13.f); assert(output(7,10) == 14.f); assert(output(7,11) == 15.f); assert(output(7,12) == 0.f); assert(output(7,13) == 0.f); assert(output(7,14) == 0.f); assert(output(7,15) == 0.f);
       assert(output(8,0) == 5.f); assert(output(8,1) == 6.f); assert(output(8,2) == 7.f); assert(output(8,3) == 0.f); assert(output(8,4) == 9.f); assert(output(8,5) == 10.f); assert(output(8,6) == 11.f); assert(output(8,7) == 0.f); assert(output(8,8) == 13.f); assert(output(8,9) == 14.f); assert(output(8,10) == 15.f); assert(output(8,11) == 0.f); assert(output(8,12) == 0.f); assert(output(8,13) == 0.f); assert(output(8,14) == 0.f); assert(output(8,15) == 0.f);
         // clang-format on
     }
@@ -1509,7 +1509,7 @@ void test_cast() {
         auto ta = ntt::make_tensor<float>(ntt::fixed_shape_v<1, 16>);
         auto tb = ntt::make_tensor<int32_t>(ntt::fixed_shape_v<1, 16>);
         std::iota(ta.elements().begin(), ta.elements().end(), 0.f);
-        ntt::cast(ta, tb.view(), ntt::fixed_shape_v<>);
+        ntt::cast(ta, tb.view());
         assert(tb(0, 0) == 0);
         assert(tb(0, 2) == 2);
     }
@@ -1523,7 +1523,7 @@ void test_cast() {
         ntt::pack(ta, tb.view(), ntt::fixed_shape_v<1>);
         auto tc = ntt::make_tensor<ntt::vector<int32_t, 4>>(
             ntt::fixed_shape_v<1, 16, 32>);
-        ntt::cast(tb, tc, ntt::fixed_shape_v<1>);
+        ntt::cast(tb, tc);
         assert(tc(0, 0, 0)(0) == 0);
         assert(tc(0, 0, 0)(1) == 32);
         assert(tc(0, 0, 0)(2) == 64);
@@ -1534,7 +1534,7 @@ void test_cast() {
         auto ta = ntt::make_tensor<int32_t>(ntt::fixed_shape_v<1, 16>);
         auto tb = ntt::make_tensor<float>(ntt::fixed_shape_v<1, 16>);
         std::iota(ta.elements().begin(), ta.elements().end(), 0);
-        ntt::cast<mul_scalar>(ta, tb.view(), ntt::fixed_shape_v<>);
+        ntt::cast<mul_scalar>(ta, tb.view());
         assert(tb(0, 0) == 0.f);
         assert(tb(0, 2) == (2.f * 1.2f));
     }
@@ -1548,7 +1548,7 @@ void test_cast() {
         ntt::pack(ta, tb.view(), ntt::fixed_shape_v<0>);
         auto tc =
             ntt::make_tensor<ntt::vector<float, 4>>(ntt::fixed_shape_v<1, 8>);
-        ntt::cast<mul_scalar>(tb, tc, ntt::fixed_shape_v<0>);
+        ntt::cast<mul_scalar>(tb, tc);
         assert(tc(0, 0)(0) == (0.f * 1.2f));
         assert(tc(0, 0)(1) == (8.f * 1.2f));
         assert(tc(0, 0)(2) == (16.f * 1.2f));