// Auto Generated, DO NOT EDIT!

#pragma once

#include "paddle/fluid/primitive/backend/backend.h"


namespace paddle {
namespace primitive {

using Tensor = paddle::Tensor;
using IntArray = paddle::experimental::IntArray;

template <typename T>
Tensor abs(const Tensor& x) {
    return backend::abs<T>(x);
}

template <typename T>
Tensor bitwise_and(const Tensor& x, const Tensor& y) {
    return backend::bitwise_and<T>(x, y);
}

template <typename T>
Tensor bitwise_not(const Tensor& x) {
    return backend::bitwise_not<T>(x);
}

template <typename T>
Tensor bitwise_or(const Tensor& x, const Tensor& y) {
    return backend::bitwise_or<T>(x, y);
}

template <typename T>
Tensor bitwise_xor(const Tensor& x, const Tensor& y) {
    return backend::bitwise_xor<T>(x, y);
}

template <typename T>
Tensor concat(const std::vector<Tensor>& x, const Scalar& axis = 0) {
    return backend::concat<T>(x, axis);
}

template <typename T>
Tensor cos(const Tensor& x) {
    return backend::cos<T>(x);
}

template <typename T>
Tensor cumsum(const Tensor& x, const Scalar& axis = -1, bool flatten = false, bool exclusive = false, bool reverse = false) {
    return backend::cumsum<T>(x, axis, flatten, exclusive, reverse);
}

template <typename T>
Tensor erf(const Tensor& x) {
    return backend::erf<T>(x);
}

template <typename T>
Tensor exp(const Tensor& x) {
    return backend::exp<T>(x);
}

template <typename T>
Tensor expand(const Tensor& x, const IntArray& shape = {}) {
    return backend::expand<T>(x, shape);
}

template <typename T>
Tensor floor(const Tensor& x) {
    return backend::floor<T>(x);
}

template <typename T>
Tensor gather(const Tensor& x, const Tensor& index, const Scalar& axis = 0) {
    return backend::gather<T>(x, index, axis);
}

template <typename T>
Tensor gather_nd(const Tensor& x, const Tensor& index) {
    return backend::gather_nd<T>(x, index);
}

template <typename T>
Tensor log(const Tensor& x) {
    return backend::log<T>(x);
}

template <typename T>
Tensor put_along_axis(const Tensor& arr, const Tensor& indices, const Tensor& values, int axis, const std::string& reduce = "assign") {
    return backend::put_along_axis<T>(arr, indices, values, axis, reduce);
}

template <typename T>
Tensor roll(const Tensor& x, const IntArray& shifts = {}, const std::vector<int64_t>& axis = {}) {
    return backend::roll<T>(x, shifts, axis);
}

template <typename T>
Tensor scale(const Tensor& x, const Scalar& scale = 1.0, float bias = 0.0, bool bias_after_scale = true) {
    return backend::scale<T>(x, scale, bias, bias_after_scale);
}

template <typename T>
Tensor scatter(const Tensor& x, const Tensor& index, const Tensor& updates, bool overwrite = true) {
    return backend::scatter<T>(x, index, updates, overwrite);
}

template <typename T>
Tensor scatter_nd_add(const Tensor& x, const Tensor& index, const Tensor& updates) {
    return backend::scatter_nd_add<T>(x, index, updates);
}

template <typename T>
Tensor sign(const Tensor& x) {
    return backend::sign<T>(x);
}

template <typename T>
Tensor sin(const Tensor& x) {
    return backend::sin<T>(x);
}

template <typename T>
Tensor sqrt(const Tensor& x) {
    return backend::sqrt<T>(x);
}

template <typename T>
Tensor tanh(const Tensor& x) {
    return backend::tanh<T>(x);
}

template <typename T>
Tensor where(const Tensor& condition, const Tensor& x, const Tensor& y) {
    return backend::where<T>(condition, x, y);
}

template <typename T>
Tensor add(const Tensor& x, const Tensor& y) {
    return backend::add<T>(x, y);
}

template <typename T>
Tensor assign(const Tensor& x) {
    return backend::assign<T>(x);
}

template <typename T>
Tensor cast(const Tensor& x, DataType dtype) {
    return backend::cast<T>(x, dtype);
}

template <typename T>
Tensor divide(const Tensor& x, const Tensor& y) {
    return backend::divide<T>(x, y);
}

template <typename T>
Tensor elementwise_pow(const Tensor& x, const Tensor& y) {
    return backend::elementwise_pow<T>(x, y);
}

template <typename T>
Tensor equal(const Tensor& x, const Tensor& y) {
    return backend::equal<T>(x, y);
}

template <typename T>
Tensor full(const IntArray& shape, const Scalar& value, DataType dtype = DataType::FLOAT32, Place place = CPUPlace()) {
    return backend::full<T>(shape, value, dtype, place);
}

template <typename T>
Tensor greater_equal(const Tensor& x, const Tensor& y) {
    return backend::greater_equal<T>(x, y);
}

template <typename T>
Tensor greater_than(const Tensor& x, const Tensor& y) {
    return backend::greater_than<T>(x, y);
}

template <typename T>
Tensor less_equal(const Tensor& x, const Tensor& y) {
    return backend::less_equal<T>(x, y);
}

template <typename T>
Tensor less_than(const Tensor& x, const Tensor& y) {
    return backend::less_than<T>(x, y);
}

template <typename T>
Tensor matmul(const Tensor& x, const Tensor& y, bool transpose_x = false, bool transpose_y = false) {
    return backend::matmul<T>(x, y, transpose_x, transpose_y);
}

template <typename T>
Tensor max(const Tensor& x, const IntArray& axis = {}, bool keepdim = false) {
    return backend::max<T>(x, axis, keepdim);
}

template <typename T>
Tensor maximum(const Tensor& x, const Tensor& y) {
    return backend::maximum<T>(x, y);
}

template <typename T>
Tensor minimum(const Tensor& x, const Tensor& y) {
    return backend::minimum<T>(x, y);
}

template <typename T>
Tensor multiply(const Tensor& x, const Tensor& y) {
    return backend::multiply<T>(x, y);
}

template <typename T>
Tensor not_equal(const Tensor& x, const Tensor& y) {
    return backend::not_equal<T>(x, y);
}

template <typename T>
Tensor pad(const Tensor& x, const std::vector<int>& paddings, const Scalar& pad_value) {
    return backend::pad<T>(x, paddings, pad_value);
}

template <typename T>
Tensor prod(const Tensor& x, const IntArray& dims, bool keep_dim, bool reduce_all) {
    return backend::prod<T>(x, dims, keep_dim, reduce_all);
}

template <typename T>
Tensor reshape(const Tensor& x, const IntArray& shape) {
    return backend::reshape<T>(x, shape);
}

template <typename T>
Tensor slice(const Tensor& input, const std::vector<int64_t>& axes, const IntArray& starts, const IntArray& ends, const std::vector<int64_t>& infer_flags, const std::vector<int64_t>& decrease_axis) {
    return backend::slice<T>(input, axes, starts, ends, infer_flags, decrease_axis);
}

template <typename T>
std::vector<Tensor> split(const Tensor& x, const IntArray& sections, const Scalar& axis) {
    return backend::split<T>(x, sections, axis);
}

template <typename T>
Tensor subtract(const Tensor& x, const Tensor& y) {
    return backend::subtract<T>(x, y);
}

template <typename T>
Tensor sum(const Tensor& x, const IntArray& axis = {}, DataType dtype = DataType::UNDEFINED, bool keepdim = false) {
    return backend::sum<T>(x, axis, dtype, keepdim);
}

template <typename T>
Tensor tile(const Tensor& x, const IntArray& repeat_times = {}) {
    return backend::tile<T>(x, repeat_times);
}

template <typename T>
Tensor transpose(const Tensor& x, const std::vector<int>& perm) {
    return backend::transpose<T>(x, perm);
}


}  // namespace primitive
}  // namespace paddle
