Function ComputeStrides

cpp/src/arrow/extension/tensor_internal.cc:83–127

}

Result<std::vector<int64_t>> ComputeStrides(const std::shared_ptr<DataType>& value_type,
                                            std::span<const int64_t> shape,
                                            std::span<const int64_t> permutation) {
  const auto ndim = shape.size();
  const int byte_width = value_type->byte_width();

  // Use identity permutation if none provided
  std::vector<int64_t> perm;
  if (permutation.empty()) {
    perm.resize(ndim);
    std::iota(perm.begin(), perm.end(), 0);
  } else {
    perm.assign(permutation.begin(), permutation.end());
  }

  int64_t remaining = 0;
  if (!shape.empty() && shape[0] > 0) {
    remaining = byte_width;
    for (auto i : perm) {
      if (i > 0) {
        if (MultiplyWithOverflow(remaining, shape[i], &remaining)) {
          return Status::Invalid(
              "Strides computed from shape would not fit in 64-bit integer");
        }
      }
    }
  }

  std::vector<int64_t> strides;
  if (remaining == 0) {
    strides.assign(ndim, byte_width);
    return strides;
  }

  strides.push_back(remaining);
  for (auto i : perm) {
    if (i > 0) {
      remaining /= shape[i];
      strides.push_back(remaining);
    }
  }
  Permute(perm, &strides);

  return strides;
}

Result<std::shared_ptr<Buffer>> SliceTensorBuffer(const Array& data_array,
                                                  const DataType& value_type,