diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_not_meta.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_not_meta.h new file mode 100644 index 0000000000000000000000000000000000000000..da1e3402c258cb5c34b47c00c6d1c4c389a3bcd8 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_not_meta.h @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_bitwise_not : public TensorIteratorBase { + + + void meta(const at::Tensor & self); +}; + +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_not_meta_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_not_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..5d78bf5906c610635664f99c8ec8e9c94c6c0811 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_not_meta_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor bitwise_not(const at::Tensor & self); +TORCH_API at::Tensor & bitwise_not_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & bitwise_not_outf(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor & bitwise_not_(at::Tensor & self); + +} // namespace meta +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_not_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_not_native.h new file mode 100644 index 0000000000000000000000000000000000000000..d8214bf6d64a1ccc6c36312231ab2162c3ccba3f --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_not_native.h @@ -0,0 +1,23 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_bitwise_not_out : public at::meta::structured_bitwise_not { +void impl(const at::Tensor & self, const at::Tensor & out); +}; +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_not_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_not_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..ff6954a16d37d103da461ea75e7fc1b164d39378 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_not_ops.h @@ -0,0 +1,51 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API bitwise_not { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_not"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "bitwise_not(Tensor self) -> Tensor"; + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +struct TORCH_API bitwise_not_ { + using schema = at::Tensor & (at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_not_"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "bitwise_not_(Tensor(a!) self) -> Tensor(a!)"; + static at::Tensor & call(at::Tensor & self); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self); +}; + +struct TORCH_API bitwise_not_out { + using schema = at::Tensor & (const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_not"; + static constexpr const char* overload_name = "out"; + static constexpr const char* schema_str = "bitwise_not.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Tensor & self, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or.h new file mode 100644 index 0000000000000000000000000000000000000000..ccb6cbdb8eb438bc871a4f2e4bb025039200c9d1 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or.h @@ -0,0 +1,68 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::bitwise_or.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_or_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { + return at::_ops::bitwise_or_Tensor_out::call(self, other, out); +} +// aten::bitwise_or.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_or_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { + return at::_ops::bitwise_or_Tensor_out::call(self, other, out); +} + +// aten::bitwise_or.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_or_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) { + return at::_ops::bitwise_or_Scalar_out::call(self, other, out); +} +// aten::bitwise_or.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_or_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { + return at::_ops::bitwise_or_Scalar_out::call(self, other, out); +} + +// aten::bitwise_or.Scalar(Tensor self, Scalar other) -> Tensor +inline at::Tensor bitwise_or(const at::Tensor & self, const at::Scalar & other) { + return at::_ops::bitwise_or_Scalar::call(self, other); +} + +// aten::bitwise_or.Scalar_Tensor(Scalar self, Tensor other) -> Tensor +inline at::Tensor bitwise_or(const at::Scalar & self, const at::Tensor & other) { + return at::_ops::bitwise_or_Scalar_Tensor::call(self, other); +} + +// aten::bitwise_or.Tensor(Tensor self, Tensor other) -> Tensor +inline at::Tensor bitwise_or(const at::Tensor & self, const at::Tensor & other) { + return at::_ops::bitwise_or_Tensor::call(self, other); +} + +// aten::bitwise_or.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_or_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other) { + return at::_ops::bitwise_or_Scalar_Tensor_out::call(self, other, out); +} +// aten::bitwise_or.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_or_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) { + return at::_ops::bitwise_or_Scalar_Tensor_out::call(self, other, out); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_compositeexplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..bdec6e3d71fd5efc00da8086432bdda3ba960679 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_compositeexplicitautograd_dispatch.h @@ -0,0 +1,29 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor bitwise_or(const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & bitwise_or_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & bitwise_or_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_or_(at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor bitwise_or(const at::Scalar & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_or_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_or_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_compositeexplicitautogradnonfunctional_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..c799ef5b6cf2a6c1a483e6ade2a4c9c0cae3845f --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_compositeexplicitautogradnonfunctional_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor bitwise_or(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_or_(at::Tensor & self, const at::Tensor & other); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_cpu_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..810b8552c3c244ef801aa5dcea6e1c0d528aea21 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_cpu_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor bitwise_or(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_or_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_or_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_or_(at::Tensor & self, const at::Tensor & other); + +} // namespace cpu +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_cuda_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..d9d6a6494bfa59432661e638f3774a2118985287 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_cuda_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor bitwise_or(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_or_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_or_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_or_(at::Tensor & self, const at::Tensor & other); + +} // namespace cuda +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_meta.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_meta.h new file mode 100644 index 0000000000000000000000000000000000000000..ccf036fb6714c61b3160f8dfd10db617701c3aba --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_meta.h @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_bitwise_or_Tensor : public TensorIteratorBase { + + + void meta(const at::Tensor & self, const at::Tensor & other); +}; + +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_meta_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..74958804b3329861f71999c15279ea78ab449482 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_meta_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor bitwise_or(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_or_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_or_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_or_(at::Tensor & self, const at::Tensor & other); + +} // namespace meta +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_native.h new file mode 100644 index 0000000000000000000000000000000000000000..39fd57d2013ddf3002652c85aca3e4c369577dd7 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_native.h @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_bitwise_or_out : public at::meta::structured_bitwise_or_Tensor { +void impl(const at::Tensor & self, const at::Tensor & other, const at::Tensor & out); +}; +TORCH_API at::Tensor bitwise_or(const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & bitwise_or_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_or_(at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor bitwise_or(const at::Scalar & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_or_Scalar_Tensor_out(const at::Scalar & self, const at::Tensor & other, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..417478310570fbe2fffbe90f59190e6e4fd9737e --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_or_ops.h @@ -0,0 +1,106 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API bitwise_or_Tensor_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_or"; + static constexpr const char* overload_name = "Tensor_out"; + static constexpr const char* schema_str = "bitwise_or.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +}; + +struct TORCH_API bitwise_or_Scalar_out { + using schema = at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_or"; + static constexpr const char* overload_name = "Scalar_out"; + static constexpr const char* schema_str = "bitwise_or.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Tensor & self, const at::Scalar & other, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other, at::Tensor & out); +}; + +struct TORCH_API bitwise_or_Scalar { + using schema = at::Tensor (const at::Tensor &, const at::Scalar &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_or"; + static constexpr const char* overload_name = "Scalar"; + static constexpr const char* schema_str = "bitwise_or.Scalar(Tensor self, Scalar other) -> Tensor"; + static at::Tensor call(const at::Tensor & self, const at::Scalar & other); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other); +}; + +struct TORCH_API bitwise_or_Scalar_Tensor { + using schema = at::Tensor (const at::Scalar &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_or"; + static constexpr const char* overload_name = "Scalar_Tensor"; + static constexpr const char* schema_str = "bitwise_or.Scalar_Tensor(Scalar self, Tensor other) -> Tensor"; + static at::Tensor call(const at::Scalar & self, const at::Tensor & other); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & other); +}; + +struct TORCH_API bitwise_or_Tensor { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_or"; + static constexpr const char* overload_name = "Tensor"; + static constexpr const char* schema_str = "bitwise_or.Tensor(Tensor self, Tensor other) -> Tensor"; + static at::Tensor call(const at::Tensor & self, const at::Tensor & other); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other); +}; + +struct TORCH_API bitwise_or__Scalar { + using schema = at::Tensor & (at::Tensor &, const at::Scalar &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_or_"; + static constexpr const char* overload_name = "Scalar"; + static constexpr const char* schema_str = "bitwise_or_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!)"; + static at::Tensor & call(at::Tensor & self, const at::Scalar & other); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Scalar & other); +}; + +struct TORCH_API bitwise_or__Tensor { + using schema = at::Tensor & (at::Tensor &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_or_"; + static constexpr const char* overload_name = "Tensor"; + static constexpr const char* schema_str = "bitwise_or_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!)"; + static at::Tensor & call(at::Tensor & self, const at::Tensor & other); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & other); +}; + +struct TORCH_API bitwise_or_Scalar_Tensor_out { + using schema = at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_or"; + static constexpr const char* overload_name = "Scalar_Tensor_out"; + static constexpr const char* schema_str = "bitwise_or.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Scalar & self, const at::Tensor & other, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & other, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift.h new file mode 100644 index 0000000000000000000000000000000000000000..5c8d940c874b34e7181f6ead64949c2866229e45 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift.h @@ -0,0 +1,68 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::bitwise_right_shift.Tensor(Tensor self, Tensor other) -> Tensor +inline at::Tensor bitwise_right_shift(const at::Tensor & self, const at::Tensor & other) { + return at::_ops::bitwise_right_shift_Tensor::call(self, other); +} + +// aten::bitwise_right_shift.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_right_shift_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { + return at::_ops::bitwise_right_shift_Tensor_out::call(self, other, out); +} +// aten::bitwise_right_shift.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_right_shift_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { + return at::_ops::bitwise_right_shift_Tensor_out::call(self, other, out); +} + +// aten::bitwise_right_shift.Tensor_Scalar(Tensor self, Scalar other) -> Tensor +inline at::Tensor bitwise_right_shift(const at::Tensor & self, const at::Scalar & other) { + return at::_ops::bitwise_right_shift_Tensor_Scalar::call(self, other); +} + +// aten::bitwise_right_shift.Tensor_Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_right_shift_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) { + return at::_ops::bitwise_right_shift_Tensor_Scalar_out::call(self, other, out); +} +// aten::bitwise_right_shift.Tensor_Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_right_shift_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { + return at::_ops::bitwise_right_shift_Tensor_Scalar_out::call(self, other, out); +} + +// aten::bitwise_right_shift.Scalar_Tensor(Scalar self, Tensor other) -> Tensor +inline at::Tensor bitwise_right_shift(const at::Scalar & self, const at::Tensor & other) { + return at::_ops::bitwise_right_shift_Scalar_Tensor::call(self, other); +} + +// aten::bitwise_right_shift.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_right_shift_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other) { + return at::_ops::bitwise_right_shift_Scalar_Tensor_out::call(self, other, out); +} +// aten::bitwise_right_shift.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_right_shift_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) { + return at::_ops::bitwise_right_shift_Scalar_Tensor_out::call(self, other, out); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_compositeexplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..16af18f329b0f0aee61f8992b703171dc0a8c126 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_compositeexplicitautograd_dispatch.h @@ -0,0 +1,29 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor bitwise_right_shift(const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & bitwise_right_shift_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & bitwise_right_shift_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_right_shift_(at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor bitwise_right_shift(const at::Scalar & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_right_shift_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_right_shift_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_compositeexplicitautogradnonfunctional_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..b86c0b04f9829fd18c3261d00294e062d6d16007 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_compositeexplicitautogradnonfunctional_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor bitwise_right_shift(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_right_shift_(at::Tensor & self, const at::Tensor & other); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_cpu_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..e4f494350404ea095dc8db92fd8245357faebc56 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_cpu_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor bitwise_right_shift(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_right_shift_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_right_shift_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_right_shift_(at::Tensor & self, const at::Tensor & other); + +} // namespace cpu +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_cuda_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..f14e8031a4df14ba78dc10750c241defa62fdd42 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_cuda_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor bitwise_right_shift(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_right_shift_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_right_shift_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_right_shift_(at::Tensor & self, const at::Tensor & other); + +} // namespace cuda +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_meta.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_meta.h new file mode 100644 index 0000000000000000000000000000000000000000..cabc1d6ebf79cdde67db2d0567892e328efa8862 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_meta.h @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_bitwise_right_shift_Tensor : public TensorIteratorBase { + + + void meta(const at::Tensor & self, const at::Tensor & other); +}; + +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_meta_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..7b88ef6ab663c0b9525ce6db84f95609bbcb587f --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_meta_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor bitwise_right_shift(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_right_shift_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_right_shift_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_right_shift_(at::Tensor & self, const at::Tensor & other); + +} // namespace meta +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_native.h new file mode 100644 index 0000000000000000000000000000000000000000..d580df33865f7a34ac9a1048466bd04b19fd0083 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_native.h @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_bitwise_right_shift_out : public at::meta::structured_bitwise_right_shift_Tensor { +void impl(const at::Tensor & self, const at::Tensor & other, const at::Tensor & out); +}; +TORCH_API at::Tensor bitwise_right_shift(const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & bitwise_right_shift_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_right_shift_(at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor bitwise_right_shift(const at::Scalar & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_right_shift_Scalar_Tensor_out(const at::Scalar & self, const at::Tensor & other, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..84a5708d4b7fb14920b968fcdb94f8f0267b934a --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_right_shift_ops.h @@ -0,0 +1,106 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API bitwise_right_shift_Tensor { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_right_shift"; + static constexpr const char* overload_name = "Tensor"; + static constexpr const char* schema_str = "bitwise_right_shift.Tensor(Tensor self, Tensor other) -> Tensor"; + static at::Tensor call(const at::Tensor & self, const at::Tensor & other); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other); +}; + +struct TORCH_API bitwise_right_shift__Tensor { + using schema = at::Tensor & (at::Tensor &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_right_shift_"; + static constexpr const char* overload_name = "Tensor"; + static constexpr const char* schema_str = "bitwise_right_shift_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!)"; + static at::Tensor & call(at::Tensor & self, const at::Tensor & other); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & other); +}; + +struct TORCH_API bitwise_right_shift_Tensor_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_right_shift"; + static constexpr const char* overload_name = "Tensor_out"; + static constexpr const char* schema_str = "bitwise_right_shift.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +}; + +struct TORCH_API bitwise_right_shift_Tensor_Scalar { + using schema = at::Tensor (const at::Tensor &, const at::Scalar &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_right_shift"; + static constexpr const char* overload_name = "Tensor_Scalar"; + static constexpr const char* schema_str = "bitwise_right_shift.Tensor_Scalar(Tensor self, Scalar other) -> Tensor"; + static at::Tensor call(const at::Tensor & self, const at::Scalar & other); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other); +}; + +struct TORCH_API bitwise_right_shift__Tensor_Scalar { + using schema = at::Tensor & (at::Tensor &, const at::Scalar &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_right_shift_"; + static constexpr const char* overload_name = "Tensor_Scalar"; + static constexpr const char* schema_str = "bitwise_right_shift_.Tensor_Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!)"; + static at::Tensor & call(at::Tensor & self, const at::Scalar & other); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Scalar & other); +}; + +struct TORCH_API bitwise_right_shift_Tensor_Scalar_out { + using schema = at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_right_shift"; + static constexpr const char* overload_name = "Tensor_Scalar_out"; + static constexpr const char* schema_str = "bitwise_right_shift.Tensor_Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Tensor & self, const at::Scalar & other, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other, at::Tensor & out); +}; + +struct TORCH_API bitwise_right_shift_Scalar_Tensor { + using schema = at::Tensor (const at::Scalar &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_right_shift"; + static constexpr const char* overload_name = "Scalar_Tensor"; + static constexpr const char* schema_str = "bitwise_right_shift.Scalar_Tensor(Scalar self, Tensor other) -> Tensor"; + static at::Tensor call(const at::Scalar & self, const at::Tensor & other); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & other); +}; + +struct TORCH_API bitwise_right_shift_Scalar_Tensor_out { + using schema = at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_right_shift"; + static constexpr const char* overload_name = "Scalar_Tensor_out"; + static constexpr const char* schema_str = "bitwise_right_shift.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Scalar & self, const at::Tensor & other, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & other, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor.h new file mode 100644 index 0000000000000000000000000000000000000000..a2bde4279d36920298c60eaa0ba2b6467c71adba --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor.h @@ -0,0 +1,68 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::bitwise_xor.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_xor_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { + return at::_ops::bitwise_xor_Tensor_out::call(self, other, out); +} +// aten::bitwise_xor.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_xor_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { + return at::_ops::bitwise_xor_Tensor_out::call(self, other, out); +} + +// aten::bitwise_xor.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_xor_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) { + return at::_ops::bitwise_xor_Scalar_out::call(self, other, out); +} +// aten::bitwise_xor.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_xor_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { + return at::_ops::bitwise_xor_Scalar_out::call(self, other, out); +} + +// aten::bitwise_xor.Scalar(Tensor self, Scalar other) -> Tensor +inline at::Tensor bitwise_xor(const at::Tensor & self, const at::Scalar & other) { + return at::_ops::bitwise_xor_Scalar::call(self, other); +} + +// aten::bitwise_xor.Scalar_Tensor(Scalar self, Tensor other) -> Tensor +inline at::Tensor bitwise_xor(const at::Scalar & self, const at::Tensor & other) { + return at::_ops::bitwise_xor_Scalar_Tensor::call(self, other); +} + +// aten::bitwise_xor.Tensor(Tensor self, Tensor other) -> Tensor +inline at::Tensor bitwise_xor(const at::Tensor & self, const at::Tensor & other) { + return at::_ops::bitwise_xor_Tensor::call(self, other); +} + +// aten::bitwise_xor.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_xor_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other) { + return at::_ops::bitwise_xor_Scalar_Tensor_out::call(self, other, out); +} +// aten::bitwise_xor.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bitwise_xor_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) { + return at::_ops::bitwise_xor_Scalar_Tensor_out::call(self, other, out); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_compositeexplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..9cee3e8bd17af37cafca777fc62107d2e975162a --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_compositeexplicitautograd_dispatch.h @@ -0,0 +1,29 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor bitwise_xor(const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & bitwise_xor_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & bitwise_xor_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_xor_(at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor bitwise_xor(const at::Scalar & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_xor_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_xor_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_compositeexplicitautogradnonfunctional_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..dc2b899f572ad76950d09fe9b8990e14f903c34e --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_compositeexplicitautogradnonfunctional_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor bitwise_xor(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_xor_(at::Tensor & self, const at::Tensor & other); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_cpu_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..a3b2cd3cae43c69fcc3d4abe8d2f92d09c20d9d0 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_cpu_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor bitwise_xor(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_xor_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_xor_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_xor_(at::Tensor & self, const at::Tensor & other); + +} // namespace cpu +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_cuda_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..667635e3ef5fd5980d07a491d9e20fb822e07ccc --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_cuda_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor bitwise_xor(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_xor_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_xor_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_xor_(at::Tensor & self, const at::Tensor & other); + +} // namespace cuda +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_meta.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_meta.h new file mode 100644 index 0000000000000000000000000000000000000000..cc72633f4d0a17579a1ab3a15c38fd86662941a1 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_meta.h @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_bitwise_xor_Tensor : public TensorIteratorBase { + + + void meta(const at::Tensor & self, const at::Tensor & other); +}; + +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_meta_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..889e22f940ee2963ee549750dd8ce15132532b07 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_meta_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor bitwise_xor(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_xor_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_xor_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_xor_(at::Tensor & self, const at::Tensor & other); + +} // namespace meta +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_native.h new file mode 100644 index 0000000000000000000000000000000000000000..aeb919b64d217228f549daaec2cc58ecc35af589 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_native.h @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_bitwise_xor_out : public at::meta::structured_bitwise_xor_Tensor { +void impl(const at::Tensor & self, const at::Tensor & other, const at::Tensor & out); +}; +TORCH_API at::Tensor bitwise_xor(const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & bitwise_xor_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_xor_(at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor bitwise_xor(const at::Scalar & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_xor_Scalar_Tensor_out(const at::Scalar & self, const at::Tensor & other, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..41a6ff767df2387cf6d6f34bba5b9e3985a19b66 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bitwise_xor_ops.h @@ -0,0 +1,106 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API bitwise_xor_Tensor_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_xor"; + static constexpr const char* overload_name = "Tensor_out"; + static constexpr const char* schema_str = "bitwise_xor.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +}; + +struct TORCH_API bitwise_xor_Scalar_out { + using schema = at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_xor"; + static constexpr const char* overload_name = "Scalar_out"; + static constexpr const char* schema_str = "bitwise_xor.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Tensor & self, const at::Scalar & other, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other, at::Tensor & out); +}; + +struct TORCH_API bitwise_xor_Scalar { + using schema = at::Tensor (const at::Tensor &, const at::Scalar &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_xor"; + static constexpr const char* overload_name = "Scalar"; + static constexpr const char* schema_str = "bitwise_xor.Scalar(Tensor self, Scalar other) -> Tensor"; + static at::Tensor call(const at::Tensor & self, const at::Scalar & other); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other); +}; + +struct TORCH_API bitwise_xor_Scalar_Tensor { + using schema = at::Tensor (const at::Scalar &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_xor"; + static constexpr const char* overload_name = "Scalar_Tensor"; + static constexpr const char* schema_str = "bitwise_xor.Scalar_Tensor(Scalar self, Tensor other) -> Tensor"; + static at::Tensor call(const at::Scalar & self, const at::Tensor & other); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & other); +}; + +struct TORCH_API bitwise_xor_Tensor { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_xor"; + static constexpr const char* overload_name = "Tensor"; + static constexpr const char* schema_str = "bitwise_xor.Tensor(Tensor self, Tensor other) -> Tensor"; + static at::Tensor call(const at::Tensor & self, const at::Tensor & other); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other); +}; + +struct TORCH_API bitwise_xor__Scalar { + using schema = at::Tensor & (at::Tensor &, const at::Scalar &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_xor_"; + static constexpr const char* overload_name = "Scalar"; + static constexpr const char* schema_str = "bitwise_xor_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!)"; + static at::Tensor & call(at::Tensor & self, const at::Scalar & other); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Scalar & other); +}; + +struct TORCH_API bitwise_xor__Tensor { + using schema = at::Tensor & (at::Tensor &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_xor_"; + static constexpr const char* overload_name = "Tensor"; + static constexpr const char* schema_str = "bitwise_xor_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!)"; + static at::Tensor & call(at::Tensor & self, const at::Tensor & other); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & other); +}; + +struct TORCH_API bitwise_xor_Scalar_Tensor_out { + using schema = at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bitwise_xor"; + static constexpr const char* overload_name = "Scalar_Tensor_out"; + static constexpr const char* schema_str = "bitwise_xor.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Scalar & self, const at::Tensor & other, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & other, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/blackman_window.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/blackman_window.h new file mode 100644 index 0000000000000000000000000000000000000000..988b854424b537aadf10afdab6f17d0060013a55 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/blackman_window.h @@ -0,0 +1,62 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::blackman_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor blackman_window(int64_t window_length, at::TensorOptions options={}) { + return at::_ops::blackman_window::call(window_length, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); +} +// aten::blackman_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor blackman_window(int64_t window_length, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory) { + return at::_ops::blackman_window::call(window_length, dtype, layout, device, pin_memory); +} + +// aten::blackman_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor blackman_window(int64_t window_length, bool periodic, at::TensorOptions options={}) { + return at::_ops::blackman_window_periodic::call(window_length, periodic, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); +} +// aten::blackman_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor blackman_window(int64_t window_length, bool periodic, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory) { + return at::_ops::blackman_window_periodic::call(window_length, periodic, dtype, layout, device, pin_memory); +} + +// aten::blackman_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & blackman_window_out(at::Tensor & out, int64_t window_length) { + return at::_ops::blackman_window_out::call(window_length, out); +} +// aten::blackman_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & blackman_window_outf(int64_t window_length, at::Tensor & out) { + return at::_ops::blackman_window_out::call(window_length, out); +} + +// aten::blackman_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & blackman_window_out(at::Tensor & out, int64_t window_length, bool periodic) { + return at::_ops::blackman_window_periodic_out::call(window_length, periodic, out); +} +// aten::blackman_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & blackman_window_outf(int64_t window_length, bool periodic, at::Tensor & out) { + return at::_ops::blackman_window_periodic_out::call(window_length, periodic, out); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/blackman_window_compositeexplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/blackman_window_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..173bcf6a01b6576d12924771fe248d75f0d3b105 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/blackman_window_compositeexplicitautograd_dispatch.h @@ -0,0 +1,30 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor blackman_window(int64_t window_length, at::TensorOptions options={}); +TORCH_API at::Tensor blackman_window(int64_t window_length, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory); +TORCH_API at::Tensor & blackman_window_out(at::Tensor & out, int64_t window_length); +TORCH_API at::Tensor & blackman_window_outf(int64_t window_length, at::Tensor & out); +TORCH_API at::Tensor blackman_window(int64_t window_length, bool periodic, at::TensorOptions options={}); +TORCH_API at::Tensor blackman_window(int64_t window_length, bool periodic, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory); +TORCH_API at::Tensor & blackman_window_out(at::Tensor & out, int64_t window_length, bool periodic); +TORCH_API at::Tensor & blackman_window_outf(int64_t window_length, bool periodic, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/blackman_window_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/blackman_window_native.h new file mode 100644 index 0000000000000000000000000000000000000000..d4ad0fa31d7c4af251daccd989728d7254abb4d6 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/blackman_window_native.h @@ -0,0 +1,24 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor blackman_window(int64_t window_length, ::std::optional dtype={}, ::std::optional layout={}, ::std::optional device={}, ::std::optional pin_memory={}); +TORCH_API at::Tensor & blackman_window_out(int64_t window_length, at::Tensor & out); +TORCH_API at::Tensor blackman_window(int64_t window_length, bool periodic, ::std::optional dtype={}, ::std::optional layout={}, ::std::optional device={}, ::std::optional pin_memory={}); +TORCH_API at::Tensor & blackman_window_periodic_out(int64_t window_length, bool periodic, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/blackman_window_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/blackman_window_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..7b15434d487ef9c8c7f12c2bf54cdc19bea48bc0 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/blackman_window_ops.h @@ -0,0 +1,62 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API blackman_window { + using schema = at::Tensor (int64_t, ::std::optional, ::std::optional, ::std::optional, ::std::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::blackman_window"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "blackman_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor"; + static at::Tensor call(int64_t window_length, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, int64_t window_length, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory); +}; + +struct TORCH_API blackman_window_periodic { + using schema = at::Tensor (int64_t, bool, ::std::optional, ::std::optional, ::std::optional, ::std::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::blackman_window"; + static constexpr const char* overload_name = "periodic"; + static constexpr const char* schema_str = "blackman_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor"; + static at::Tensor call(int64_t window_length, bool periodic, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, int64_t window_length, bool periodic, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory); +}; + +struct TORCH_API blackman_window_out { + using schema = at::Tensor & (int64_t, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::blackman_window"; + static constexpr const char* overload_name = "out"; + static constexpr const char* schema_str = "blackman_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(int64_t window_length, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, int64_t window_length, at::Tensor & out); +}; + +struct TORCH_API blackman_window_periodic_out { + using schema = at::Tensor & (int64_t, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::blackman_window"; + static constexpr const char* overload_name = "periodic_out"; + static constexpr const char* schema_str = "blackman_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(int64_t window_length, bool periodic, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, int64_t window_length, bool periodic, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/block_diag.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/block_diag.h new file mode 100644 index 0000000000000000000000000000000000000000..677c2662cb8b16305ea624d3049afc0947286ac8 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/block_diag.h @@ -0,0 +1,40 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::block_diag(Tensor[] tensors) -> Tensor +inline at::Tensor block_diag(at::TensorList tensors) { + return at::_ops::block_diag::call(tensors); +} + +// aten::block_diag.out(Tensor[] tensors, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & block_diag_out(at::Tensor & out, at::TensorList tensors) { + return at::_ops::block_diag_out::call(tensors, out); +} +// aten::block_diag.out(Tensor[] tensors, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & block_diag_outf(at::TensorList tensors, at::Tensor & out) { + return at::_ops::block_diag_out::call(tensors, out); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/block_diag_compositeexplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/block_diag_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..e2733cb5d3ca2a8fbbe3f6f88a30261e78a11a0a --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/block_diag_compositeexplicitautograd_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor block_diag(at::TensorList tensors); +TORCH_API at::Tensor & block_diag_out(at::Tensor & out, at::TensorList tensors); +TORCH_API at::Tensor & block_diag_outf(at::TensorList tensors, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/block_diag_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/block_diag_native.h new file mode 100644 index 0000000000000000000000000000000000000000..b1b76be9646bf755eb896eb79f8efde2ed3a665c --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/block_diag_native.h @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor block_diag(at::TensorList tensors); +TORCH_API at::Tensor & block_diag_out(at::TensorList tensors, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/block_diag_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/block_diag_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..0e0083d39d0b5977554d96c7ff3f4ef4705e9564 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/block_diag_ops.h @@ -0,0 +1,40 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API block_diag { + using schema = at::Tensor (at::TensorList); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::block_diag"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "block_diag(Tensor[] tensors) -> Tensor"; + static at::Tensor call(at::TensorList tensors); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList tensors); +}; + +struct TORCH_API block_diag_out { + using schema = at::Tensor & (at::TensorList, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::block_diag"; + static constexpr const char* overload_name = "out"; + static constexpr const char* schema_str = "block_diag.out(Tensor[] tensors, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(at::TensorList tensors, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList tensors, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm.h new file mode 100644 index 0000000000000000000000000000000000000000..c8fa6b87c7f89edd5b8298b1049335bdd981f6d4 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm.h @@ -0,0 +1,40 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::bmm(Tensor self, Tensor mat2) -> Tensor +inline at::Tensor bmm(const at::Tensor & self, const at::Tensor & mat2) { + return at::_ops::bmm::call(self, mat2); +} + +// aten::bmm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bmm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat2) { + return at::_ops::bmm_out::call(self, mat2, out); +} +// aten::bmm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bmm_outf(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out) { + return at::_ops::bmm_out::call(self, mat2, out); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_compositeexplicitautogradnonfunctional_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..81ef8f49f347021549da10b30576e58c7b3d67e3 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_compositeexplicitautogradnonfunctional_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor bmm(const at::Tensor & self, const at::Tensor & mat2); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_cpu_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..73dc06fa7266e150a023e6b3730f4e004eb0b551 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_cpu_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor bmm(const at::Tensor & self, const at::Tensor & mat2); +TORCH_API at::Tensor & bmm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat2); +TORCH_API at::Tensor & bmm_outf(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_cuda_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..24f873e339c639ea39f9091d4431e8871ec1ca47 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_cuda_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor bmm(const at::Tensor & self, const at::Tensor & mat2); +TORCH_API at::Tensor & bmm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat2); +TORCH_API at::Tensor & bmm_outf(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out); + +} // namespace cuda +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_meta.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_meta.h new file mode 100644 index 0000000000000000000000000000000000000000..84f5278c3f9de627bb728bd0af53324b2c239ebb --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_meta.h @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_bmm : public at::impl::MetaBase { + + + void meta(const at::Tensor & self, const at::Tensor & mat2); +}; + +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_meta_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..3abf2e8d9d832f19026e66aa85d8a2d7de40c8d3 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_meta_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor bmm(const at::Tensor & self, const at::Tensor & mat2); +TORCH_API at::Tensor & bmm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat2); +TORCH_API at::Tensor & bmm_outf(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out); + +} // namespace meta +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_native.h new file mode 100644 index 0000000000000000000000000000000000000000..1d466a83338e608de6cff591701797c847084249 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_native.h @@ -0,0 +1,33 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_bmm_out_cpu : public at::meta::structured_bmm { +void impl(const at::Tensor & self, const at::Tensor & mat2, const at::Tensor & out); +}; +struct TORCH_API structured_bmm_out_cuda : public at::meta::structured_bmm { +void impl(const at::Tensor & self, const at::Tensor & mat2, const at::Tensor & out); +}; +TORCH_API at::Tensor bmm_nested(const at::Tensor & self, const at::Tensor & mat2); +TORCH_API at::Tensor bmm_nested_cuda(const at::Tensor & self, const at::Tensor & mat2); +TORCH_API at::Tensor bmm_sparse_cpu(const at::Tensor & self, const at::Tensor & mat2); +TORCH_API at::Tensor & bmm_out_sparse_cpu(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out); +TORCH_API at::Tensor bmm_sparse_cuda(const at::Tensor & self, const at::Tensor & mat2); +TORCH_API at::Tensor & bmm_out_sparse_cuda(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out); +TORCH_API at::Tensor & bmm_out_sparse_csr_cuda(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..858f093339c45d4fd45cb28398c06140d5bc817e --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bmm_ops.h @@ -0,0 +1,40 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API bmm { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bmm"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "bmm(Tensor self, Tensor mat2) -> Tensor"; + static at::Tensor call(const at::Tensor & self, const at::Tensor & mat2); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & mat2); +}; + +struct TORCH_API bmm_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bmm"; + static constexpr const char* overload_name = "out"; + static constexpr const char* schema_str = "bmm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_tensors.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_tensors.h new file mode 100644 index 0000000000000000000000000000000000000000..8cf00b6d6004505fcd728ab82c68aa42df1e6221 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_tensors.h @@ -0,0 +1,31 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::broadcast_tensors(Tensor[] tensors) -> Tensor[] +inline ::std::vector broadcast_tensors(at::TensorList tensors) { + return at::_ops::broadcast_tensors::call(tensors); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_tensors_compositeimplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_tensors_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..0b1cef3bfb94db8d0cf24c245b3f99348a968e89 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_tensors_compositeimplicitautograd_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API ::std::vector broadcast_tensors(at::TensorList tensors); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_tensors_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_tensors_native.h new file mode 100644 index 0000000000000000000000000000000000000000..4e203467a5b22b477a5bb84b602082dd55597d28 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_tensors_native.h @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API ::std::vector broadcast_tensors(at::TensorList tensors); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_tensors_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_tensors_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..8a407251763c81ac83914a5228629238e2b45162 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_tensors_ops.h @@ -0,0 +1,29 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API broadcast_tensors { + using schema = ::std::vector (at::TensorList); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::broadcast_tensors"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "broadcast_tensors(Tensor[] tensors) -> Tensor[]"; + static ::std::vector call(at::TensorList tensors); + static ::std::vector redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList tensors); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_to.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_to.h new file mode 100644 index 0000000000000000000000000000000000000000..c6d35793e115497c4b2321e3b1e474438cdf805b --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_to.h @@ -0,0 +1,48 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::broadcast_to(Tensor(a) self, SymInt[] size) -> Tensor(a) +inline at::Tensor broadcast_to(const at::Tensor & self, at::IntArrayRef size) { + return at::_ops::broadcast_to::call(self, c10::fromIntArrayRefSlow(size)); +} +namespace symint { + template >> + at::Tensor broadcast_to(const at::Tensor & self, at::IntArrayRef size) { + return at::_ops::broadcast_to::call(self, c10::fromIntArrayRefSlow(size)); + } +} + +// aten::broadcast_to(Tensor(a) self, SymInt[] size) -> Tensor(a) +inline at::Tensor broadcast_to_symint(const at::Tensor & self, c10::SymIntArrayRef size) { + return at::_ops::broadcast_to::call(self, size); +} +namespace symint { + template >> + at::Tensor broadcast_to(const at::Tensor & self, c10::SymIntArrayRef size) { + return at::_ops::broadcast_to::call(self, size); + } +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_to_compositeimplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_to_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..ccd2d32256c73f30139e4e62b72e8c604c4d61b1 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_to_compositeimplicitautograd_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor broadcast_to(const at::Tensor & self, at::IntArrayRef size); +TORCH_API at::Tensor broadcast_to_symint(const at::Tensor & self, c10::SymIntArrayRef size); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_to_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_to_native.h new file mode 100644 index 0000000000000000000000000000000000000000..271ebecdf91de0b0342f9d9ec118570579ded5d4 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_to_native.h @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor broadcast_to_symint(const at::Tensor & self, c10::SymIntArrayRef size); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_to_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_to_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..2c82a6c0313af0d527bfb5178e5103e3c8adc73a --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/broadcast_to_ops.h @@ -0,0 +1,29 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API broadcast_to { + using schema = at::Tensor (const at::Tensor &, c10::SymIntArrayRef); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::broadcast_to"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "broadcast_to(Tensor(a) self, SymInt[] size) -> Tensor(a)"; + static at::Tensor call(const at::Tensor & self, c10::SymIntArrayRef size); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::SymIntArrayRef size); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize.h new file mode 100644 index 0000000000000000000000000000000000000000..cee978c6ecb83999e4d845bc46eff3cec93989d4 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize.h @@ -0,0 +1,54 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::bucketize.Tensor(Tensor self, Tensor boundaries, *, bool out_int32=False, bool right=False) -> Tensor +inline at::Tensor bucketize(const at::Tensor & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false) { + return at::_ops::bucketize_Tensor::call(self, boundaries, out_int32, right); +} + +// aten::bucketize.Tensor_out(Tensor self, Tensor boundaries, *, bool out_int32=False, bool right=False, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bucketize_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false) { + return at::_ops::bucketize_Tensor_out::call(self, boundaries, out_int32, right, out); +} +// aten::bucketize.Tensor_out(Tensor self, Tensor boundaries, *, bool out_int32=False, bool right=False, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bucketize_outf(const at::Tensor & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out) { + return at::_ops::bucketize_Tensor_out::call(self, boundaries, out_int32, right, out); +} + +// aten::bucketize.Scalar(Scalar self, Tensor boundaries, *, bool out_int32=False, bool right=False) -> Tensor +inline at::Tensor bucketize(const at::Scalar & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false) { + return at::_ops::bucketize_Scalar::call(self, boundaries, out_int32, right); +} + +// aten::bucketize.Scalar_out(Scalar self, Tensor boundaries, *, bool out_int32=False, bool right=False, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bucketize_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false) { + return at::_ops::bucketize_Scalar_out::call(self, boundaries, out_int32, right, out); +} +// aten::bucketize.Scalar_out(Scalar self, Tensor boundaries, *, bool out_int32=False, bool right=False, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & bucketize_outf(const at::Scalar & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out) { + return at::_ops::bucketize_Scalar_out::call(self, boundaries, out_int32, right, out); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_compositeexplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..5b64370c72c83c43c67642000cf088ebfb0de39c --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_compositeexplicitautograd_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor & bucketize_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false); +TORCH_API at::Tensor & bucketize_outf(const at::Scalar & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_cpu_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..cf70f00000d8c3c874ec9e525a5fb32c38d494f3 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_cpu_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor bucketize(const at::Tensor & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false); +TORCH_API at::Tensor & bucketize_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false); +TORCH_API at::Tensor & bucketize_outf(const at::Tensor & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out); +TORCH_API at::Tensor bucketize(const at::Scalar & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false); + +} // namespace cpu +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_cuda_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..42e164390f65dd1d129c0abca008bd525456f2f7 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_cuda_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor bucketize(const at::Tensor & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false); +TORCH_API at::Tensor & bucketize_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false); +TORCH_API at::Tensor & bucketize_outf(const at::Tensor & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out); +TORCH_API at::Tensor bucketize(const at::Scalar & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false); + +} // namespace cuda +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_native.h new file mode 100644 index 0000000000000000000000000000000000000000..7d86b5a3f240721da103c6c20c4d59a87b3dc8e6 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_native.h @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor bucketize_cpu(const at::Tensor & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false); +TORCH_API at::Tensor & bucketize_out_cpu(const at::Tensor & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out); +TORCH_API at::Tensor bucketize_cuda(const at::Tensor & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false); +TORCH_API at::Tensor & bucketize_out_cuda(const at::Tensor & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out); +TORCH_API at::Tensor & bucketize_Scalar_out(const at::Scalar & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out); +TORCH_API at::Tensor bucketize_cpu(const at::Scalar & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false); +TORCH_API at::Tensor bucketize_cuda(const at::Scalar & self, const at::Tensor & boundaries, bool out_int32=false, bool right=false); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..69b23456ed1dfa3203751a220e9d9fc0b128bb77 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bucketize_ops.h @@ -0,0 +1,62 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API bucketize_Tensor { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, bool, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bucketize"; + static constexpr const char* overload_name = "Tensor"; + static constexpr const char* schema_str = "bucketize.Tensor(Tensor self, Tensor boundaries, *, bool out_int32=False, bool right=False) -> Tensor"; + static at::Tensor call(const at::Tensor & self, const at::Tensor & boundaries, bool out_int32, bool right); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & boundaries, bool out_int32, bool right); +}; + +struct TORCH_API bucketize_Tensor_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, bool, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bucketize"; + static constexpr const char* overload_name = "Tensor_out"; + static constexpr const char* schema_str = "bucketize.Tensor_out(Tensor self, Tensor boundaries, *, bool out_int32=False, bool right=False, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Tensor & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out); +}; + +struct TORCH_API bucketize_Scalar { + using schema = at::Tensor (const at::Scalar &, const at::Tensor &, bool, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bucketize"; + static constexpr const char* overload_name = "Scalar"; + static constexpr const char* schema_str = "bucketize.Scalar(Scalar self, Tensor boundaries, *, bool out_int32=False, bool right=False) -> Tensor"; + static at::Tensor call(const at::Scalar & self, const at::Tensor & boundaries, bool out_int32, bool right); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & boundaries, bool out_int32, bool right); +}; + +struct TORCH_API bucketize_Scalar_out { + using schema = at::Tensor & (const at::Scalar &, const at::Tensor &, bool, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::bucketize"; + static constexpr const char* overload_name = "Scalar_out"; + static constexpr const char* schema_str = "bucketize.Scalar_out(Scalar self, Tensor boundaries, *, bool out_int32=False, bool right=False, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Scalar & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/can_cast.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/can_cast.h new file mode 100644 index 0000000000000000000000000000000000000000..5e83ca80fc9938fe87d48ae0c98a97211a5de468 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/can_cast.h @@ -0,0 +1,31 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::can_cast(ScalarType from_, ScalarType to) -> bool +inline bool can_cast(at::ScalarType from_, at::ScalarType to) { + return at::_ops::can_cast::call(from_, to); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/can_cast_compositeimplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/can_cast_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..a6c34a7e0dc998f75b8fc0ac67e5a13f6b9a67c8 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/can_cast_compositeimplicitautograd_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API bool can_cast(at::ScalarType from_, at::ScalarType to); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/can_cast_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/can_cast_native.h new file mode 100644 index 0000000000000000000000000000000000000000..1eb114eb3c0f4a2c408e6c13dd480e2fc7a4e66e --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/can_cast_native.h @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API bool can_cast(at::ScalarType from_, at::ScalarType to); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/can_cast_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/can_cast_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..74300dd8970ee798f030c91f4d2778e0d607cec3 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/can_cast_ops.h @@ -0,0 +1,29 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API can_cast { + using schema = bool (at::ScalarType, at::ScalarType); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::can_cast"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "can_cast(ScalarType from_, ScalarType to) -> bool"; + static bool call(at::ScalarType from_, at::ScalarType to); + static bool redispatch(c10::DispatchKeySet dispatchKeySet, at::ScalarType from_, at::ScalarType to); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cartesian_prod.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cartesian_prod.h new file mode 100644 index 0000000000000000000000000000000000000000..0fdd5d704701c99a0165189d910a936dd7b9b2bf --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cartesian_prod.h @@ -0,0 +1,31 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::cartesian_prod(Tensor[] tensors) -> Tensor +inline at::Tensor cartesian_prod(at::TensorList tensors) { + return at::_ops::cartesian_prod::call(tensors); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cartesian_prod_compositeimplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cartesian_prod_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..3a56ce711a201163c5ab3d643416c4e6008915b2 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cartesian_prod_compositeimplicitautograd_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor cartesian_prod(at::TensorList tensors); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cartesian_prod_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cartesian_prod_native.h new file mode 100644 index 0000000000000000000000000000000000000000..25cf03519bd16610a5cd8656b85cbe32859a7a7c --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cartesian_prod_native.h @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor cartesian_prod(at::TensorList tensors); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cartesian_prod_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cartesian_prod_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..67dc379542c3c77b470947a068bdc7eddfc5759b --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cartesian_prod_ops.h @@ -0,0 +1,29 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API cartesian_prod { + using schema = at::Tensor (at::TensorList); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::cartesian_prod"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "cartesian_prod(Tensor[] tensors) -> Tensor"; + static at::Tensor call(at::TensorList tensors); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList tensors); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat.h new file mode 100644 index 0000000000000000000000000000000000000000..aa719374742388cfac65c803e7cb9c83b2b210e5 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat.h @@ -0,0 +1,54 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::cat(Tensor[] tensors, int dim=0) -> Tensor +inline at::Tensor cat(const at::ITensorListRef & tensors, int64_t dim=0) { + return at::_ops::cat::call(tensors, dim); +} + +// aten::cat.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & cat_out(at::Tensor & out, const at::ITensorListRef & tensors, int64_t dim=0) { + return at::_ops::cat_out::call(tensors, dim, out); +} +// aten::cat.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & cat_outf(const at::ITensorListRef & tensors, int64_t dim, at::Tensor & out) { + return at::_ops::cat_out::call(tensors, dim, out); +} + +// aten::cat.names(Tensor[] tensors, Dimname dim) -> Tensor +inline at::Tensor cat(at::TensorList tensors, at::Dimname dim) { + return at::_ops::cat_names::call(tensors, dim); +} + +// aten::cat.names_out(Tensor[] tensors, Dimname dim, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & cat_out(at::Tensor & out, at::TensorList tensors, at::Dimname dim) { + return at::_ops::cat_names_out::call(tensors, dim, out); +} +// aten::cat.names_out(Tensor[] tensors, Dimname dim, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & cat_outf(at::TensorList tensors, at::Dimname dim, at::Tensor & out) { + return at::_ops::cat_names_out::call(tensors, dim, out); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_compositeexplicitautogradnonfunctional_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..e504a5eaf81ddf258dd7682f86be0f21731d5c2e --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_compositeexplicitautogradnonfunctional_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor cat(const at::ITensorListRef & tensors, int64_t dim=0); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_compositeimplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..3427483dc742ceb26cf35ae0c68792a51bcf6a7b --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_compositeimplicitautograd_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor cat(at::TensorList tensors, at::Dimname dim); +TORCH_API at::Tensor & cat_out(at::Tensor & out, at::TensorList tensors, at::Dimname dim); +TORCH_API at::Tensor & cat_outf(at::TensorList tensors, at::Dimname dim, at::Tensor & out); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_cpu_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..63b67a9c371ec090619e4ab8970d924a784b140e --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_cpu_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor cat(const at::ITensorListRef & tensors, int64_t dim=0); +TORCH_API at::Tensor & cat_out(at::Tensor & out, const at::ITensorListRef & tensors, int64_t dim=0); +TORCH_API at::Tensor & cat_outf(const at::ITensorListRef & tensors, int64_t dim, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_cuda_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..d92ace2d563ab99964d19742f8caa3593c6abbaa --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_cuda_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor cat(const at::ITensorListRef & tensors, int64_t dim=0); +TORCH_API at::Tensor & cat_out(at::Tensor & out, const at::ITensorListRef & tensors, int64_t dim=0); +TORCH_API at::Tensor & cat_outf(const at::ITensorListRef & tensors, int64_t dim, at::Tensor & out); + +} // namespace cuda +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_meta.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_meta.h new file mode 100644 index 0000000000000000000000000000000000000000..8b1b4e985f364fda56393bf234c87a524e12864a --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_meta.h @@ -0,0 +1,114 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_cat : public at::impl::MetaBase { + + template + struct TORCH_API precompute_out { + + precompute_out set_dim(int64_t value) { + static_assert(DIM == false, "dim already set"); + precompute_out ret; +ret.dim = value; +ret.valid = this->valid; +ret.all_contiguous = this->all_contiguous; +ret.all_same_dtype = this->all_same_dtype; +ret.all_same_sizes_and_stride = this->all_same_sizes_and_stride; +ret.memory_format = this->memory_format; +return ret; + } + + + precompute_out set_valid(int64_t value) { + static_assert(VALID == false, "valid already set"); + precompute_out ret; +ret.dim = this->dim; +ret.valid = value; +ret.all_contiguous = this->all_contiguous; +ret.all_same_dtype = this->all_same_dtype; +ret.all_same_sizes_and_stride = this->all_same_sizes_and_stride; +ret.memory_format = this->memory_format; +return ret; + } + + + precompute_out set_all_contiguous(bool value) { + static_assert(ALL_CONTIGUOUS == false, "all_contiguous already set"); + precompute_out ret; +ret.dim = this->dim; +ret.valid = this->valid; +ret.all_contiguous = value; +ret.all_same_dtype = this->all_same_dtype; +ret.all_same_sizes_and_stride = this->all_same_sizes_and_stride; +ret.memory_format = this->memory_format; +return ret; + } + + + precompute_out set_all_same_dtype(bool value) { + static_assert(ALL_SAME_DTYPE == false, "all_same_dtype already set"); + precompute_out ret; +ret.dim = this->dim; +ret.valid = this->valid; +ret.all_contiguous = this->all_contiguous; +ret.all_same_dtype = value; +ret.all_same_sizes_and_stride = this->all_same_sizes_and_stride; +ret.memory_format = this->memory_format; +return ret; + } + + + precompute_out set_all_same_sizes_and_stride(bool value) { + static_assert(ALL_SAME_SIZES_AND_STRIDE == false, "all_same_sizes_and_stride already set"); + precompute_out ret; +ret.dim = this->dim; +ret.valid = this->valid; +ret.all_contiguous = this->all_contiguous; +ret.all_same_dtype = this->all_same_dtype; +ret.all_same_sizes_and_stride = value; +ret.memory_format = this->memory_format; +return ret; + } + + + precompute_out set_memory_format(at::MemoryFormat value) { + static_assert(MEMORY_FORMAT == false, "memory_format already set"); + precompute_out ret; +ret.dim = this->dim; +ret.valid = this->valid; +ret.all_contiguous = this->all_contiguous; +ret.all_same_dtype = this->all_same_dtype; +ret.all_same_sizes_and_stride = this->all_same_sizes_and_stride; +ret.memory_format = value; +return ret; + } + + int64_t dim; +int64_t valid; +bool all_contiguous; +bool all_same_dtype; +bool all_same_sizes_and_stride; +at::MemoryFormat memory_format; + }; + using meta_return_ty = precompute_out ; + meta_return_ty meta(const at::ITensorListRef & tensors, int64_t dim); +}; + +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_meta_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..7c094d7f83bd88fb770e504923190a5639687223 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_meta_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor cat(const at::ITensorListRef & tensors, int64_t dim=0); +TORCH_API at::Tensor & cat_out(at::Tensor & out, const at::ITensorListRef & tensors, int64_t dim=0); +TORCH_API at::Tensor & cat_outf(const at::ITensorListRef & tensors, int64_t dim, at::Tensor & out); + +} // namespace meta +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_native.h new file mode 100644 index 0000000000000000000000000000000000000000..36f6c7f8c89009bb4e201b045263d8ebde3776fb --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_native.h @@ -0,0 +1,32 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_cat_out_cpu : public at::meta::structured_cat { +void impl(const at::ITensorListRef & tensors, int64_t dim, int64_t valid, bool all_contiguous, bool all_same_dtype, bool all_same_sizes_and_stride, at::MemoryFormat memory_format, const at::Tensor & out); +}; +struct TORCH_API structured_cat_out_cuda : public at::meta::structured_cat { +void impl(const at::ITensorListRef & tensors, int64_t dim, int64_t valid, bool all_contiguous, bool all_same_dtype, bool all_same_sizes_and_stride, at::MemoryFormat memory_format, const at::Tensor & out); +}; +TORCH_API at::Tensor cat_nested(const at::ITensorListRef & tensors, int64_t dim=0); +TORCH_API at::Tensor cat_sparse(const at::ITensorListRef & tensors, int64_t dim=0); +TORCH_API at::Tensor cat_quantized_cpu(const at::ITensorListRef & tensors, int64_t dim=0); +TORCH_API at::Tensor & cat_out_quantized_cpu(const at::ITensorListRef & tensors, int64_t dim, at::Tensor & out); +TORCH_API at::Tensor cat(at::TensorList tensors, at::Dimname dim); +TORCH_API at::Tensor & cat_out(at::TensorList tensors, at::Dimname dim, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..8a244e0d2c3cadd9a9ae972637ee761917c60492 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cat_ops.h @@ -0,0 +1,62 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API cat { + using schema = at::Tensor (const at::ITensorListRef &, int64_t); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::cat"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "cat(Tensor[] tensors, int dim=0) -> Tensor"; + static at::Tensor call(const at::ITensorListRef & tensors, int64_t dim); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::ITensorListRef & tensors, int64_t dim); +}; + +struct TORCH_API cat_out { + using schema = at::Tensor & (const at::ITensorListRef &, int64_t, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::cat"; + static constexpr const char* overload_name = "out"; + static constexpr const char* schema_str = "cat.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::ITensorListRef & tensors, int64_t dim, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::ITensorListRef & tensors, int64_t dim, at::Tensor & out); +}; + +struct TORCH_API cat_names { + using schema = at::Tensor (at::TensorList, at::Dimname); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::cat"; + static constexpr const char* overload_name = "names"; + static constexpr const char* schema_str = "cat.names(Tensor[] tensors, Dimname dim) -> Tensor"; + static at::Tensor call(at::TensorList tensors, at::Dimname dim); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList tensors, at::Dimname dim); +}; + +struct TORCH_API cat_names_out { + using schema = at::Tensor & (at::TensorList, at::Dimname, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::cat"; + static constexpr const char* overload_name = "names_out"; + static constexpr const char* schema_str = "cat.names_out(Tensor[] tensors, Dimname dim, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(at::TensorList tensors, at::Dimname dim, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList tensors, at::Dimname dim, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy.h new file mode 100644 index 0000000000000000000000000000000000000000..4ddd9f5774d6d0706f10978049ab342b5aa24e1d --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy.h @@ -0,0 +1,40 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::cauchy.out(Tensor self, float median=0, float sigma=1, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & cauchy_out(at::Tensor & out, const at::Tensor & self, double median=0, double sigma=1, ::std::optional generator=::std::nullopt) { + return at::_ops::cauchy_out::call(self, median, sigma, generator, out); +} +// aten::cauchy.out(Tensor self, float median=0, float sigma=1, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & cauchy_outf(const at::Tensor & self, double median, double sigma, ::std::optional generator, at::Tensor & out) { + return at::_ops::cauchy_out::call(self, median, sigma, generator, out); +} + +// aten::cauchy(Tensor self, float median=0, float sigma=1, *, Generator? generator=None) -> Tensor +inline at::Tensor cauchy(const at::Tensor & self, double median=0, double sigma=1, ::std::optional generator=::std::nullopt) { + return at::_ops::cauchy::call(self, median, sigma, generator); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_compositeexplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..6391439f4b4568edcdc8164a2d5e02e303c4c70b --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_compositeexplicitautograd_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor cauchy(const at::Tensor & self, double median=0, double sigma=1, ::std::optional generator=::std::nullopt); +TORCH_API at::Tensor & cauchy_out(at::Tensor & out, const at::Tensor & self, double median=0, double sigma=1, ::std::optional generator=::std::nullopt); +TORCH_API at::Tensor & cauchy_outf(const at::Tensor & self, double median, double sigma, ::std::optional generator, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_cpu_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..46d9ba43b3435eea9fa0b7cfcc80227bfa5a7636 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_cpu_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor & cauchy_(at::Tensor & self, double median=0, double sigma=1, ::std::optional generator=::std::nullopt); + +} // namespace cpu +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_cuda_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..354ff7baf1983136db9dcd71f03d90914b8e8519 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_cuda_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor & cauchy_(at::Tensor & self, double median=0, double sigma=1, ::std::optional generator=::std::nullopt); + +} // namespace cuda +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_meta_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..d4ab169aa745119dc49edc8b220ba7ace70803a2 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_meta_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor & cauchy_(at::Tensor & self, double median=0, double sigma=1, ::std::optional generator=::std::nullopt); + +} // namespace meta +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_native.h new file mode 100644 index 0000000000000000000000000000000000000000..0eafb6d551fb25bcb814acf1e021f242e00490bf --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_native.h @@ -0,0 +1,23 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor cauchy(const at::Tensor & self, double median=0, double sigma=1, ::std::optional generator=::std::nullopt); +TORCH_API at::Tensor & cauchy_out(const at::Tensor & self, double median, double sigma, ::std::optional generator, at::Tensor & out); +TORCH_API at::Tensor & cauchy_(at::Tensor & self, double median=0, double sigma=1, ::std::optional generator=::std::nullopt); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..3ff9fe49f74662826dbe801ab306c96cccb57c0a --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cauchy_ops.h @@ -0,0 +1,51 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API cauchy_ { + using schema = at::Tensor & (at::Tensor &, double, double, ::std::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::cauchy_"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "cauchy_(Tensor(a!) self, float median=0, float sigma=1, *, Generator? generator=None) -> Tensor(a!)"; + static at::Tensor & call(at::Tensor & self, double median, double sigma, ::std::optional generator); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, double median, double sigma, ::std::optional generator); +}; + +struct TORCH_API cauchy_out { + using schema = at::Tensor & (const at::Tensor &, double, double, ::std::optional, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::cauchy"; + static constexpr const char* overload_name = "out"; + static constexpr const char* schema_str = "cauchy.out(Tensor self, float median=0, float sigma=1, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Tensor & self, double median, double sigma, ::std::optional generator, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, double median, double sigma, ::std::optional generator, at::Tensor & out); +}; + +struct TORCH_API cauchy { + using schema = at::Tensor (const at::Tensor &, double, double, ::std::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::cauchy"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "cauchy(Tensor self, float median=0, float sigma=1, *, Generator? generator=None) -> Tensor"; + static at::Tensor call(const at::Tensor & self, double median, double sigma, ::std::optional generator); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, double median, double sigma, ::std::optional generator); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices.h new file mode 100644 index 0000000000000000000000000000000000000000..b2bcb760c4be6b3db57b435bf4ea258bee624b02 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices.h @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_compositeexplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..6a4d9e51cf96f4d8ea4e0d0a68e5bc4135485dbc --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_compositeexplicitautograd_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor ccol_indices(const at::Tensor & self); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy.h new file mode 100644 index 0000000000000000000000000000000000000000..ae36c4ca9d88a2cbd0ddf87e9ba1a05dd02e0750 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy.h @@ -0,0 +1,40 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::ccol_indices_copy(Tensor self) -> Tensor +inline at::Tensor ccol_indices_copy(const at::Tensor & self) { + return at::_ops::ccol_indices_copy::call(self); +} + +// aten::ccol_indices_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & ccol_indices_copy_out(at::Tensor & out, const at::Tensor & self) { + return at::_ops::ccol_indices_copy_out::call(self, out); +} +// aten::ccol_indices_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & ccol_indices_copy_outf(const at::Tensor & self, at::Tensor & out) { + return at::_ops::ccol_indices_copy_out::call(self, out); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy_compositeexplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..639cbb5e134beb0826719fec7932496c7d5af524 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy_compositeexplicitautograd_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor & ccol_indices_copy_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & ccol_indices_copy_outf(const at::Tensor & self, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy_compositeexplicitautogradnonfunctional_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..3748636504f01196de1d234388f72fe917fd2d2c --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy_compositeexplicitautogradnonfunctional_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor ccol_indices_copy(const at::Tensor & self); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy_native.h new file mode 100644 index 0000000000000000000000000000000000000000..e3a28ac29771b2911d291cb10bde7454c7b7a50d --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy_native.h @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor & ccol_indices_copy_out(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor ccol_indices_copy(const at::Tensor & self); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..20898084089fb806fefb6faea644e80414432fc7 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_copy_ops.h @@ -0,0 +1,40 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API ccol_indices_copy { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::ccol_indices_copy"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "ccol_indices_copy(Tensor self) -> Tensor"; + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +struct TORCH_API ccol_indices_copy_out { + using schema = at::Tensor & (const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::ccol_indices_copy"; + static constexpr const char* overload_name = "out"; + static constexpr const char* schema_str = "ccol_indices_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)"; + static at::Tensor & call(const at::Tensor & self, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_native.h new file mode 100644 index 0000000000000000000000000000000000000000..9488be886889b817bcb942abd86f758553b0eba8 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_native.h @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor ccol_indices_default(const at::Tensor & self); +TORCH_API at::Tensor ccol_indices_sparse_csr(const at::Tensor & self); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..795789b47d68e81c8b3b23fbfb803ff37078a021 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ccol_indices_ops.h @@ -0,0 +1,29 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API ccol_indices { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::ccol_indices"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "ccol_indices(Tensor(a) self) -> Tensor(a)"; + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cdist.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cdist.h new file mode 100644 index 0000000000000000000000000000000000000000..eb844bd70baad1247653aac014efc69f28132c2c --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cdist.h @@ -0,0 +1,31 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::cdist(Tensor x1, Tensor x2, float p=2, int? compute_mode=None) -> Tensor +inline at::Tensor cdist(const at::Tensor & x1, const at::Tensor & x2, double p=2, ::std::optional compute_mode=::std::nullopt) { + return at::_ops::cdist::call(x1, x2, p, compute_mode); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cdist_compositeimplicitautograd_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cdist_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..7095c24ec524eedec8d6347a353c0a160c64bba8 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cdist_compositeimplicitautograd_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor cdist(const at::Tensor & x1, const at::Tensor & x2, double p=2, ::std::optional compute_mode=::std::nullopt); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cdist_native.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cdist_native.h new file mode 100644 index 0000000000000000000000000000000000000000..eb7f4ecb6e3345adec8545468bf8fc75683c0996 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cdist_native.h @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor cdist(const at::Tensor & x1, const at::Tensor & x2, double p=2, ::std::optional compute_mode=::std::nullopt); +} // namespace native +} // namespace at diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cdist_ops.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cdist_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..179dd0937de18e1b5f0c0cbe5923a1b63a96dc82 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/cdist_ops.h @@ -0,0 +1,29 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API cdist { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, double, ::std::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + static constexpr const char* name = "aten::cdist"; + static constexpr const char* overload_name = ""; + static constexpr const char* schema_str = "cdist(Tensor x1, Tensor x2, float p=2, int? compute_mode=None) -> Tensor"; + static at::Tensor call(const at::Tensor & x1, const at::Tensor & x2, double p, ::std::optional compute_mode); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & x1, const at::Tensor & x2, double p, ::std::optional compute_mode); +}; + +}} // namespace at::_ops diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ceil.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ceil.h new file mode 100644 index 0000000000000000000000000000000000000000..7bff19c9e61eaaacc978229c530da3b35e74ed9a --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ceil.h @@ -0,0 +1,45 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::ceil(Tensor self) -> Tensor +inline at::Tensor ceil(const at::Tensor & self) { + return at::_ops::ceil::call(self); +} + +// aten::ceil_(Tensor(a!) self) -> Tensor(a!) +inline at::Tensor & ceil_(at::Tensor & self) { + return at::_ops::ceil_::call(self); +} + +// aten::ceil.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & ceil_out(at::Tensor & out, const at::Tensor & self) { + return at::_ops::ceil_out::call(self, out); +} +// aten::ceil.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & ceil_outf(const at::Tensor & self, at::Tensor & out) { + return at::_ops::ceil_out::call(self, out); +} + +} diff --git a/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ceil_compositeexplicitautogradnonfunctional_dispatch.h b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ceil_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..70118b3386a5835f1a41d038c8d603871d5b64c6 --- /dev/null +++ b/tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/ceil_compositeexplicitautogradnonfunctional_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor ceil(const at::Tensor & self); +TORCH_API at::Tensor & ceil_(at::Tensor & self); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at