Class Array

mlx/data/Array.h:20–112

inline constexpr bool dependent_false_v = false;

class Array {
 public:
  Array();
  Array(const std::shared_ptr<const Array>& src);
  Array(ArrayType type);
  Array(const std::string& str);
  Array(std::string_view str);
  Array(ArrayType type, const std::vector<int64_t>& shape);
  Array(
      ArrayType type,
      const std::vector<int64_t>& shape,
      std::shared_ptr<void> data);

  template <class... Args>
  Array(ArrayType type, Args... dim)
      : Array(type, std::vector<int64_t>({dim...})){};

  template <class T>
  Array(const std::vector<T>& vec) {
    init_(to_array_type<T>(), {static_cast<int64_t>(vec.size())});
    memcpy(data(), vec.data(), vec.size() * itemsize_);
  };

  template <class T>
  Array(T scalar) {
    init_(to_array_type<T>(), {});
    *reinterpret_cast<T*>(data()) = scalar;
  };

  template <class T>
  static ArrayType to_array_type() {
    if constexpr (std::is_same_v<T, char>) {
      return ArrayType::Int8;
    } else if constexpr (std::is_same_v<T, unsigned char>) {
      return ArrayType::UInt8;
    } else if constexpr (std::is_same_v<T, int32_t>) {
      return ArrayType::Int32;
    } else if constexpr (std::is_same_v<T, int64_t>) {
      return ArrayType::Int64;
    } else if constexpr (std::is_same_v<T, float>) {
      return ArrayType::Float;
    } else if constexpr (std::is_same_v<T, double>) {
      return ArrayType::Double;
    } else {
      static_assert(dependent_false_v<T>, "unsupported type");
    }
  };

  const std::vector<int64_t>& shape() const;
  int64_t shape(int d) const;
  int ndim() const;
  int64_t itemsize() const;

  template <class T>
  T* data() const {
    if (type_ != to_array_type<T>()) {
      throw std::runtime_error("Array: incompatible array type");
    }