// torch/headeronly/core/ScalarType.h
enum class ScalarType : int8_t {
    Byte,           // 0  - uint8_t
    Char,           // 1  - int8_t
    Short,          // 2  - int16_t
    Int,            // 3  - int
    Long,           // 4  - int64_t
    Half,           // 5  - c10::Half (float16)
    Float,          // 6  - float
    Double,         // 7  - double
    ComplexHalf,    // 8  - complex<Half>
    ComplexFloat,   // 9  - complex<float>
    ComplexDouble,  // 10 - complex<double>
    Bool,           // 11 - bool
    QInt8,          // 12 - 量化 int8
    QUInt8,         // 13 - 量化 uint8
    QInt32,         // 14 - 量化 int32
    BFloat16,       // 15 - Brain Float16
    // ... Bits 类型、Float8 类型、UInt 扩展类型
    Undefined,
    NumOptions
};

inline bool isFloatingType(ScalarType t) {
  return t == ScalarType::Double || t == ScalarType::Float ||
      isReducedFloatingType(t);
}

inline bool isReducedFloatingType(ScalarType t) {
  return t == ScalarType::Half || t == ScalarType::BFloat16 ||
      isFloat8Type(t) || t == ScalarType::Float4_e2m1fn_x2;
}

enum class DeviceType : int8_t {
  CPU = 0,
  CUDA = 1,        // NVIDIA GPU
  MKLDNN = 2,      // Intel MKL-DNN（保留）
  OPENGL = 3,      // OpenGL（保留）
  OPENCL = 4,      // OpenCL（保留）
  IDEEP = 5,       // Intel IDEEP（保留）
  HIP = 6,         // AMD ROCm
  FPGA = 7,        // FPGA（保留）
  MAIA = 8,        // ONNX Runtime / Microsoft
  XLA = 9,         // Google TPU (via XLA)
  Vulkan = 10,     // Vulkan（移动端 GPU）
  Metal = 11,      // Apple Metal
  XPU = 12,        // Intel GPU
  MPS = 13,        // Apple Metal Performance Shaders
  Meta = 14,       // Meta 设备（无实际数据）
  HPU = 15,        // Habana Gaudi
  VE = 16,         // NEC SX-Aurora
  Lazy = 17,       // Lazy Tensor（延迟执行）
  IPU = 18,        // Graphcore IPU
  MTIA = 19,       // Meta 训练推理加速器
  PrivateUse1 = 20 // 第三方自定义设备
};

struct Device final {
  DeviceType type_;
  DeviceIndex index_;  // int8_t, -1 表示"当前设备"
};

device.is_cuda()           // 是否为 CUDA 设备
device.is_cpu()            // 是否为 CPU 设备
device.is_meta()           // 是否为 Meta 设备
device.has_index()         // 是否指定了具体设备编号
device.supports_as_strided() // 是否支持任意 stride 操作

enum class Layout : int8_t {
  Strided,    // 默认密集布局
  Sparse,     // COO 稀疏格式
  SparseCsr,  // CSR 压缩稀疏行
  Mkldnn,     // Intel MKL-DNN 优化布局
  SparseCsc,  // CSC 压缩稀疏列
  SparseBsr,  // BSR 块稀疏行
  SparseBsc,  // BSC 块稀疏列
  Jagged,     // 嵌套张量 (NestedTensor) 使用
  NumOptions
};

inline Layout layout_from_backend(Backend backend) {
  switch (backend) {
    case Backend::SparseCPU:
    case Backend::SparseCUDA:
      return Layout::Sparse;
    case Backend::MkldnnCPU:
      return Layout::Mkldnn;
    default:
      return Layout::Strided;
  }
}

enum class MemoryFormat : int8_t {
  Contiguous,     // 行优先 (Row-major, NCHW)
  Preserve,       // 保留输入的格式
  ChannelsLast,   // 通道在最后 (NHWC) - 4D
  ChannelsLast3d, // 通道在最后 (NDHWC) - 5D
  NumOptions
};

template <typename T>
inline bool is_channels_last_strides_2d_s4(
    const ArrayRef<T> sizes,
    const ArrayRef<T> strides) {
  T min = 0;
  if (strides[1] == 0) return false;
  // 检查 stride 顺序: C=1, W=C, H=W*C, N=H*W*C
  for (auto& d : {1, 3, 2, 0}) {
    if (sizes[d] == 0) return false;
    if (strides[d] < min) return false;
    if (d == 0 && min == strides[1]) return false;
    min = strides[d];
    if (sizes[d] > 1) min *= sizes[d];
  }
  return true;
}

TensorOptions options = TensorOptions()
    .dtype(kFloat)
    .device(kCUDA, 0)
    .layout(kStrided)
    .memory_format(MemoryFormat::ChannelsLast);

x = torch.randn(1, 3, 224, 224,
                 dtype=torch.float32,
                 device='cuda:0',
                 layout=torch.strided)
x = x.to(memory_format=torch.channels_last)