[Cpp API Compatibility] add Compat API (clamp, clamp_, clamp_max, clamp_max_, clamp_min, clamp_min_, as_strided, as_strided_, as_strided_scatter, std, tensor_data, variable_data, index, index_put_, index_put)

paddle/phi/api/include/compat/ATen/Functions.h

@@ -20,8 +20,10 @@
 #include <ATen/ops/abs.h>
 #include <ATen/ops/any.h>
 #include <ATen/ops/arange.h>
+#include <ATen/ops/as_strided.h>
 #include <ATen/ops/cat.h>
 #include <ATen/ops/chunk.h>
+#include <ATen/ops/clamp.h>
 #include <ATen/ops/coalesce.h>
 #include <ATen/ops/detach.h>
 #include <ATen/ops/dsplit.h>
@@ -36,6 +38,7 @@
 #include <ATen/ops/full.h>
 #include <ATen/ops/hsplit.h>
 #include <ATen/ops/index.h>
+#include <ATen/ops/index_put.h>
 #include <ATen/ops/is_coalesced.h>
 #include <ATen/ops/item.h>
 #include <ATen/ops/masked_select.h>
@@ -53,6 +56,7 @@
 #include <ATen/ops/split.h>
 #include <ATen/ops/split_with_sizes.h>
 #include <ATen/ops/squeeze.h>
+#include <ATen/ops/std.h>
 #include <ATen/ops/sum.h>
 #include <ATen/ops/t.h>
 #include <ATen/ops/tensor_split.h>

paddle/phi/api/include/compat/ATen/core/TensorBody.h

@@ -31,10 +31,28 @@
 #endif
 
 #include <c10/core/Device.h>
+#include <c10/core/List.h>
+#include <c10/core/ScalarType.h>
+#include <c10/core/SymIntArrayRef.h>
+#include <limits>
+#include <optional>
 #include <utility>
 #include <vector>
+#include "paddle/common/ddim.h"
 #include "paddle/phi/common/place.h"
 
+namespace at {
+class Tensor;
+
+// Type aliases for ATen compatibility
+using Scalar = c10::Scalar;
+using TensorOptions = c10::TensorOptions;
+using MemoryFormat = c10::MemoryFormat;
+using IntArrayRef = c10::IntArrayRef;
+using OptionalIntArrayRef = c10::OptionalIntArrayRef;
+using ScalarType = c10::ScalarType;
+}  // namespace at
+
 namespace at {  // NOLINT(build/namespaces)
 using PaddleTensor = paddle::Tensor;
 using PaddlePlace = phi::Place;
@@ -209,6 +227,119 @@ class Tensor : public TensorBase {
 
   bool equal(const at::Tensor& other) const;
 
+  // Clamp functions
+  at::Tensor clamp(
+      const ::std::optional<at::Scalar>& min,
+      const ::std::optional<at::Scalar>& max = ::std::nullopt) const;
+
+  at::Tensor clamp(const ::std::optional<at::Tensor>& min = {},
+                   const ::std::optional<at::Tensor>& max = {}) const;
+
+  at::Tensor& clamp_(
+      const ::std::optional<at::Scalar>& min,
+      const ::std::optional<at::Scalar>& max = ::std::nullopt) const;
+
+  at::Tensor& clamp_(const ::std::optional<at::Tensor>& min = {},
+                     const ::std::optional<at::Tensor>& max = {}) const;
+
+  at::Tensor clamp_max(const at::Scalar& max) const;
+  at::Tensor clamp_max(const at::Tensor& max) const;
+  at::Tensor& clamp_max_(const at::Scalar& max) const;
+  at::Tensor& clamp_max_(const at::Tensor& max) const;
+
+  at::Tensor clamp_min(const at::Scalar& min) const;
+  at::Tensor clamp_min(const at::Tensor& min) const;
+  at::Tensor& clamp_min_(const at::Scalar& min) const;
+  at::Tensor& clamp_min_(const at::Tensor& min) const;
+
+  // as_strided: Create a tensor view with custom size, stride, and
+  // storage_offset
+  at::Tensor as_strided(
+      at::IntArrayRef size,
+      at::IntArrayRef stride,
+      ::std::optional<int64_t> storage_offset = ::std::nullopt) const;
+
+  // as_strided_: Inplace version
+  const at::Tensor& as_strided_(
+      at::IntArrayRef size,
+      at::IntArrayRef stride,
+      ::std::optional<int64_t> storage_offset = ::std::nullopt) const;
+
+  // as_strided_scatter: Scatter src into a strided view
+  at::Tensor as_strided_scatter(
+      const at::Tensor& src,
+      at::IntArrayRef size,
+      at::IntArrayRef stride,
+      ::std::optional<int64_t> storage_offset = ::std::nullopt) const;
+
+  // Standard deviation functions
+  Tensor std(int dim) const;
+  Tensor std(bool unbiased = true) const;
+  Tensor std(at::OptionalIntArrayRef dim,
+             bool unbiased = true,
+             bool keepdim = false) const;
+  Tensor std(at::OptionalIntArrayRef dim,
+             const ::std::optional<at::Scalar>& correction,
+             bool keepdim = false) const;
+
+  Tensor tensor_data() const {
+    PaddleTensor result;
+    if (tensor_.initialized()) {
+      auto src_impl = tensor_.impl();
+      auto* src_tensor =
+          std::dynamic_pointer_cast<phi::DenseTensor>(src_impl).get();
+      if (src_tensor && src_tensor->meta().is_contiguous()) {
+        result.set_impl(std::make_shared<phi::DenseTensor>());
+        auto* dst_tensor =
+            std::dynamic_pointer_cast<phi::DenseTensor>(result.impl()).get();
+        dst_tensor->ShareDataWith(*src_tensor);
+      } else {
+        result = paddle::experimental::assign(tensor_);
+      }
+    }
+    // For uninitialized tensor, return an uninitialized tensor (no assign
+    // needed)
+    return Tensor(result);
+  }
+
+  Tensor variable_data() const {
+    PaddleTensor result;
+    if (tensor_.initialized()) {
+      auto src_impl = tensor_.impl();
+      auto* src_tensor =
+          std::dynamic_pointer_cast<phi::DenseTensor>(src_impl).get();
+      if (src_tensor && src_tensor->meta().is_contiguous()) {
+        result.set_impl(std::make_shared<phi::DenseTensor>());
+        auto* dst_tensor =
+            std::dynamic_pointer_cast<phi::DenseTensor>(result.impl()).get();
+        dst_tensor->ShareDataWith(*src_tensor);
+      } else {
+        result = paddle::experimental::assign(tensor_);
+      }
+    }
+    // For uninitialized tensor, return an uninitialized tensor (no assign
+    // needed)
+    return Tensor(result);
+  }
+
+  // index: Get values at specified tensor indices
+  at::Tensor index(const c10::List<::std::optional<at::Tensor>>& indices) const;
+
+  // index_put_: Set values at specified indices in-place
+  at::Tensor& index_put_(const c10::List<::std::optional<at::Tensor>>& indices,
+                         const at::Tensor& values,
+                         bool accumulate = false) const;
+
+  // index_put_: Set scalar value at specified indices in-place
+  at::Tensor& index_put_(const c10::List<::std::optional<at::Tensor>>& indices,
+                         const at::Scalar& v,
+                         bool accumulate = false) const;
+
+  // index_put: Non-inplace version of index_put_
+  at::Tensor index_put(const c10::List<::std::optional<at::Tensor>>& indices,
+                       const at::Tensor& values,
+                       bool accumulate = false) const;
+
   Tensor toType(ScalarType t) const {
     return Tensor(paddle::experimental::cast(
         tensor_, compat::_PD_AtenScalarTypeToPhiDataType(t)));

paddle/phi/api/include/compat/ATen/ops/as_strided.h

@@ -0,0 +1,100 @@
+// Copyright (c) 2026 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <ATen/core/Tensor.h>
+#include <c10/util/ArrayRef.h>
+#include <optional>
+#include <vector>
+
+#include "paddle/common/ddim.h"
+#include "paddle/phi/core/dense_tensor.h"
+
+namespace at {
+
+// as_strided: Create a tensor view with custom size, stride, and storage_offset
+inline at::Tensor Tensor::as_strided(
+    at::IntArrayRef size,
+    at::IntArrayRef stride,
+    ::std::optional<int64_t> storage_offset) const {
+  auto src_impl = tensor_.impl();
+  auto* src_tensor =
+      std::dynamic_pointer_cast<phi::DenseTensor>(src_impl).get();
+  if (!src_tensor) {
+    PD_THROW("as_strided: tensor must be a DenseTensor");
+  }
+  auto new_tensor = std::make_shared<phi::DenseTensor>();
+  new_tensor->ShareDataWith(*src_tensor);
+  std::vector<int64_t> size_vec(size.begin(), size.end());
+  std::vector<int64_t> stride_vec(stride.begin(), stride.end());
+  new_tensor->Resize(common::make_ddim(size_vec));
+  new_tensor->set_strides(common::make_ddim(stride_vec));
+  int64_t offset = storage_offset.has_value() ? storage_offset.value() : 0;
+  if (offset != 0) {
+    auto meta = phi::DenseTensorMeta(new_tensor->meta());
+    // meta.offset is in bytes; storage_offset is in elements
+    meta.offset =
+        static_cast<size_t>(offset) * phi::SizeOf(new_tensor->dtype());
+    new_tensor->set_meta(meta);
+  }
+  PaddleTensor result;
+  result.set_impl(new_tensor);
+  return Tensor(result);
+}
+
+// as_strided_: Inplace version
+inline const at::Tensor& Tensor::as_strided_(
+    at::IntArrayRef size,
+    at::IntArrayRef stride,
+    ::std::optional<int64_t> storage_offset) const {
+  auto src_impl = tensor_.impl();
+  auto* src_tensor =
+      std::dynamic_pointer_cast<phi::DenseTensor>(src_impl).get();
+  if (!src_tensor) {
+    PD_THROW("as_strided_: tensor must be a DenseTensor");
+  }
+  std::vector<int64_t> size_vec(size.begin(), size.end());
+  std::vector<int64_t> stride_vec(stride.begin(), stride.end());
+  src_tensor->Resize(common::make_ddim(size_vec));
+  src_tensor->set_strides(common::make_ddim(stride_vec));
+  int64_t offset = storage_offset.has_value() ? storage_offset.value() : 0;
+  if (offset != 0) {
+    auto meta = phi::DenseTensorMeta(src_tensor->meta());
+    // meta.offset is in bytes; storage_offset is in elements
+    meta.offset =
+        static_cast<size_t>(offset) * phi::SizeOf(src_tensor->dtype());
+    src_tensor->set_meta(meta);
+  }
+  return *this;
+}
+
+// as_strided_scatter: Scatter src into a strided view
+// Returns a new tensor (copy of self) with the strided window filled by src.
+// The original tensor is NOT modified.
+inline at::Tensor Tensor::as_strided_scatter(
+    const at::Tensor& src,
+    at::IntArrayRef size,
+    at::IntArrayRef stride,
+    ::std::optional<int64_t> storage_offset) const {
+  // Clone self to an independent copy so the original tensor is left unchanged
+  PaddleTensor self_copy = tensor_.copy_to(tensor_.place(), /*blocking=*/true);
+  at::Tensor copy_tensor(self_copy);
+  at::Tensor strided_view =
+      copy_tensor.as_strided(size, stride, storage_offset);
+  strided_view.copy_(src);
+  return strided_view;
+}
+
+}  // namespace at