diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_ANDROID_NDK.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_ANDROID_NDK.rst new file mode 100644 index 0000000000000000000000000000000000000000..72ac99e2acc257f7ac642ec25e66b576a79f9082 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_ANDROID_NDK.rst @@ -0,0 +1,9 @@ +CMAKE_ANDROID_NDK +----------------- + +.. versionadded:: 3.7 + +When :ref:`Cross Compiling for Android with the NDK`, this variable holds +the absolute path to the root directory of the NDK. The directory must +contain a ``platforms`` subdirectory holding the ``android-`` +directories. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_AUTOMOC.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_AUTOMOC.rst new file mode 100644 index 0000000000000000000000000000000000000000..02e5eb57aae0affda68bd72b47fd6a5380c0016c --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_AUTOMOC.rst @@ -0,0 +1,7 @@ +CMAKE_AUTOMOC +------------- + +Whether to handle ``moc`` automatically for Qt targets. + +This variable is used to initialize the :prop_tgt:`AUTOMOC` property on all the +targets. See that target property for additional information. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_AUTOMOC_COMPILER_PREDEFINES.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_AUTOMOC_COMPILER_PREDEFINES.rst new file mode 100644 index 0000000000000000000000000000000000000000..f1b03a0f5af632c28e5b93599bed6782246deee0 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_AUTOMOC_COMPILER_PREDEFINES.rst @@ -0,0 +1,10 @@ +CMAKE_AUTOMOC_COMPILER_PREDEFINES +--------------------------------- + +.. versionadded:: 3.10 + +This variable is used to initialize the :prop_tgt:`AUTOMOC_COMPILER_PREDEFINES` +property on all the targets. See that target property for additional +information. + +By default it is ON. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_CACHE_MINOR_VERSION.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_CACHE_MINOR_VERSION.rst new file mode 100644 index 0000000000000000000000000000000000000000..5d174a3c911390eccb5dd670fdb3c4d065eaa438 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_CACHE_MINOR_VERSION.rst @@ -0,0 +1,8 @@ +CMAKE_CACHE_MINOR_VERSION +------------------------- + +Minor version of CMake used to create the ``CMakeCache.txt`` file + +This stores the minor version of CMake used to write a CMake cache +file. It is only different when a different version of CMake is run +on a previously created cache file. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_COMPILE_WARNING_AS_ERROR.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_COMPILE_WARNING_AS_ERROR.rst new file mode 100644 index 0000000000000000000000000000000000000000..56dc6a60cdd69f37d6da48cf1ce293b6b58bb1a8 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_COMPILE_WARNING_AS_ERROR.rst @@ -0,0 +1,9 @@ +CMAKE_COMPILE_WARNING_AS_ERROR +------------------------------ + +.. versionadded:: 3.24 + +Specify whether to treat warnings on compile as errors. + +This variable is used to initialize the +:prop_tgt:`COMPILE_WARNING_AS_ERROR` property on all the targets. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_CXX_EXTENSIONS.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_CXX_EXTENSIONS.rst new file mode 100644 index 0000000000000000000000000000000000000000..017f503aec2bc650e82159bc59cc18cc85ad704c --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_CXX_EXTENSIONS.rst @@ -0,0 +1,10 @@ +CMAKE_CXX_EXTENSIONS +-------------------- + +.. versionadded:: 3.1 + +Default value for :prop_tgt:`CXX_EXTENSIONS` target property if set when a +target is created. + +See the :manual:`cmake-compile-features(7)` manual for information on +compile features and a list of supported compilers. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_ENABLE_EXPORTS.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_ENABLE_EXPORTS.rst new file mode 100644 index 0000000000000000000000000000000000000000..da233429ec099b97fa4ceb15c420f6458f348269 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_ENABLE_EXPORTS.rst @@ -0,0 +1,15 @@ +CMAKE_ENABLE_EXPORTS +-------------------- + +.. versionadded:: 3.4 + +Specify whether executables export symbols for loadable modules. + +This variable is used to initialize the :prop_tgt:`ENABLE_EXPORTS` target +property for executable targets when they are created by calls to the +:command:`add_executable` command. See the property documentation for details. + +This variable has been superseded by the +:variable:`CMAKE_EXECUTABLE_ENABLE_EXPORTS` variable. It is provided for +backward compatibility with older CMake code, but should not be used in new +projects. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_EXPORT_BUILD_DATABASE.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_EXPORT_BUILD_DATABASE.rst new file mode 100644 index 0000000000000000000000000000000000000000..94d98423e2a8863a0b42d10966cf926cf503b8ec --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_EXPORT_BUILD_DATABASE.rst @@ -0,0 +1,86 @@ +CMAKE_EXPORT_BUILD_DATABASE +--------------------------- + +.. versionadded:: 3.31 + +.. note :: + + This variable is meaningful only when experimental support for build + databases has been enabled by the + ``CMAKE_EXPERIMENTAL_EXPORT_BUILD_DATABASE`` gate. + +Enable/Disable output of module compile commands during the build. + +If enabled, generates a ``build_database.json`` file containing the +information necessary to compile a target's C++ module sources with any +tooling. The format of the JSON file looks like: + +.. code-block:: javascript + + { + "version": 1, + "revision": 0, + "sets": [ + { + "family-name" : "export_build_database", + "name" : "export_build_database@Debug", + "translation-units" : [ + { + "arguments": [ + "/path/to/compiler", + "...", + ], + "baseline-arguments" : + [ + "...", + ], + "local-arguments" : + [ + "...", + ], + "object": "CMakeFiles/target.dir/source.cxx.o", + "private": true, + "provides": { + "importable": "path/to/bmi" + }, + "requires" : [], + "source": "path/to/source.cxx", + "work-directory": "/path/to/working/directory" + } + ], + "visible-sets" : [] + } + ] + } + +This is initialized by the :envvar:`CMAKE_EXPORT_BUILD_DATABASE` environment +variable, and initializes the :prop_tgt:`EXPORT_BUILD_DATABASE` target +property for all targets. + +.. note:: + This option is implemented only by the :ref:`Ninja Generators`. It is + ignored on other generators. + +When supported and enabled, numerous targets are created in order to make it +possible to build a file containing just the commands that are needed for the +tool in question. + +``cmake_build_database-`` + Writes ``build_database_.json``. Writes a build database for the + entire build for the given configuration and all languages. Not available if + the configuration name is the empty string. + +``cmake_build_database--`` + Writes ``build_database__.json``. Writes build database for + the entire build for the given configuration and language. Not available if + the configuration name is the empty string. + +``cmake_build_database-`` + Writes ``build_database_.json``. Writes build database for the entire + build for the given language and all configurations. In a multi-config + generator, other build configuration database may be assumed to exist. + +``cmake_build_database`` + Writes to ``build_database.json``. Writes build database for all languages + and configurations. In a multi-config generator, other build configuration + database may be assumed to exist. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_EXPORT_FIND_PACKAGE_NAME.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_EXPORT_FIND_PACKAGE_NAME.rst new file mode 100644 index 0000000000000000000000000000000000000000..dbab5792e8b818516d5b53b7749943c8f33db5a7 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_EXPORT_FIND_PACKAGE_NAME.rst @@ -0,0 +1,8 @@ +CMAKE_EXPORT_FIND_PACKAGE_NAME +------------------------------ + +.. note:: + + Experimental. Gated by ``CMAKE_EXPERIMENTAL_EXPORT_PACKAGE_DEPENDENCIES``. + +Initializes the value of :prop_tgt:`EXPORT_FIND_PACKAGE_NAME`. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY.rst new file mode 100644 index 0000000000000000000000000000000000000000..5392ad1980f663d9c7810b396a2f5f1e1599439b --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY.rst @@ -0,0 +1,26 @@ +CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY +-------------------------------------- + +.. versionadded:: 3.1 + +.. deprecated:: 3.16 + + Use the :variable:`CMAKE_FIND_USE_PACKAGE_REGISTRY` variable instead. + +By default this variable is not set. If neither +:variable:`CMAKE_FIND_USE_PACKAGE_REGISTRY` nor +``CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY`` is set, then +:command:`find_package()` will use the :ref:`User Package Registry` +unless the ``NO_CMAKE_PACKAGE_REGISTRY`` option is provided. + +``CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY`` is ignored if +:variable:`CMAKE_FIND_USE_PACKAGE_REGISTRY` is set. + +In some cases, for example to locate only system wide installations, it +is not desirable to use the :ref:`User Package Registry` when searching +for packages. If the ``CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY`` +variable is ``TRUE``, all the :command:`find_package` commands will skip +the :ref:`User Package Registry` as if they were called with the +``NO_CMAKE_PACKAGE_REGISTRY`` argument. + +See also :ref:`Disabling the Package Registry`. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_Fortran_MODDIR_DEFAULT.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_Fortran_MODDIR_DEFAULT.rst new file mode 100644 index 0000000000000000000000000000000000000000..5aeab075744c06b7caf61a0b4461ff4c693b97f9 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_Fortran_MODDIR_DEFAULT.rst @@ -0,0 +1,8 @@ +CMAKE_Fortran_MODDIR_DEFAULT +---------------------------- + +Fortran default module output directory. + +Most Fortran compilers write ``.mod`` files to the current working +directory. For those that do not, this is set to ``.`` and used when +the :prop_tgt:`Fortran_MODULE_DIRECTORY` target property is not set. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_GENERATOR_PLATFORM.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_GENERATOR_PLATFORM.rst new file mode 100644 index 0000000000000000000000000000000000000000..22bf655eb9a20919fdb21e4a37a9564c0ecc06cd --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_GENERATOR_PLATFORM.rst @@ -0,0 +1,75 @@ +CMAKE_GENERATOR_PLATFORM +------------------------ + +.. versionadded:: 3.1 + +Generator-specific target platform specification provided by user. + +Some CMake generators support a target platform name to be given +to the native build system to choose a compiler toolchain. +If the user specifies a platform name (e.g. via the :option:`cmake -A` +option or via the :envvar:`CMAKE_GENERATOR_PLATFORM` environment variable) +the value will be available in this variable. + +The value of this variable should never be modified by project code. +A toolchain file specified by the :variable:`CMAKE_TOOLCHAIN_FILE` +variable may initialize ``CMAKE_GENERATOR_PLATFORM``. Once a given +build tree has been initialized with a particular value for this +variable, changing the value has undefined behavior. + +Platform specification is supported only on specific generators: + +* For :ref:`Visual Studio Generators` with VS 2005 and above this + specifies the target architecture. + +* For :generator:`Green Hills MULTI` this specifies the target architecture. + +See native build system documentation for allowed platform names. + +.. _`Visual Studio Platform Selection`: + +Visual Studio Platform Selection +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The :ref:`Visual Studio Generators` support platform specification +using one of these forms: + +* ``platform`` +* ``platform[,key=value]*`` +* ``key=value[,key=value]*`` + +The ``platform`` specifies the target platform (VS target architecture), +such as ``x64``, ``ARM64``, or ``Win32``. The selected platform +name is provided in the :variable:`CMAKE_VS_PLATFORM_NAME` variable. + +The ``key=value`` pairs form a comma-separated list of options to +specify generator-specific details of the platform selection. +Supported pairs are: + +``version=`` + .. versionadded:: 3.27 + + Specify the Windows SDK version to use. This is supported by VS 2015 and + above when targeting Windows or Windows Store. CMake will set the + :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION` variable to the + selected SDK version. + + The ```` may be one of: + + ``10.0`` + Specify that any 10.0 SDK version may be used, and let Visual Studio + pick one. This is supported by VS 2019 and above. + + ``10.0..`` + Specify the exact 4-component SDK version, e.g., ``10.0.19041.0``. + The specified version of the SDK must be installed. It may not exceed + the value of :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION_MAXIMUM`, + if that variable is set. + + ``8.1`` + Specify the 8.1 SDK version. This is always supported by VS 2015. + On VS 2017 and above the 8.1 SDK must be installed. + + If the ``version`` field is not specified, CMake selects a version as + described in the :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION` + variable documentation. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_ARCHIVE_APPEND.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_ARCHIVE_APPEND.rst new file mode 100644 index 0000000000000000000000000000000000000000..ab4ad7164b76c7a64639e1a949db0d25387e567e --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_ARCHIVE_APPEND.rst @@ -0,0 +1,10 @@ +CMAKE__ARCHIVE_APPEND +--------------------------- + +Rule variable to append to a static archive. + +This is a rule variable that tells CMake how to append to a static +archive. It is used in place of :variable:`CMAKE__CREATE_STATIC_LIBRARY` +on some platforms in order to support large object counts. See also +:variable:`CMAKE__ARCHIVE_CREATE` and +:variable:`CMAKE__ARCHIVE_FINISH`. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_COMPILER_LAUNCHER.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_COMPILER_LAUNCHER.rst new file mode 100644 index 0000000000000000000000000000000000000000..f16e594469ececb72808653b302a81b1202e5015 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_COMPILER_LAUNCHER.rst @@ -0,0 +1,12 @@ +CMAKE__COMPILER_LAUNCHER +------------------------------ + +.. versionadded:: 3.4 + +Default value for :prop_tgt:`_COMPILER_LAUNCHER` target property. +This variable is used to initialize the property on each target as it is +created. This is done only when ```` is ``C``, ``CXX``, ``Fortran``, +``HIP``, ``ISPC``, ``OBJC``, ``OBJCXX``, or ``CUDA``. + +This variable is initialized to the :envvar:`CMAKE__COMPILER_LAUNCHER` +environment variable if it is set. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_COMPILER_LINKER.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_COMPILER_LINKER.rst new file mode 100644 index 0000000000000000000000000000000000000000..c0ae1cda1848ba4858d90ebcd76126c64fa0d214 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_COMPILER_LINKER.rst @@ -0,0 +1,15 @@ +CMAKE__COMPILER_LINKER +---------------------------- + +.. versionadded:: 3.29 + +The full path to the linker for ``LANG``. + +This is the command that will be used as the ```` linker. + +This variable is not guaranteed to be defined for all linkers or languages. + +.. note:: + This variable is read-only. It must not be set by the user. To select a + specific linker, use the :variable:`CMAKE_LINKER_TYPE` variable or the + :prop_tgt:`LINKER_TYPE` target property. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_COMPILER_RANLIB.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_COMPILER_RANLIB.rst new file mode 100644 index 0000000000000000000000000000000000000000..1d10b557f721c94d431afdb4b659e3d878f0bf12 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_COMPILER_RANLIB.rst @@ -0,0 +1,9 @@ +CMAKE__COMPILER_RANLIB +---------------------------- + +.. versionadded:: 3.9 + +A wrapper around ``ranlib`` adding the appropriate ``--plugin`` option for the +compiler. + +See also :variable:`CMAKE_RANLIB`. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_CPPCHECK.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_CPPCHECK.rst new file mode 100644 index 0000000000000000000000000000000000000000..5ae5fafb50b97f6d5e5f6f9f544a1703cc8786a1 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_CPPCHECK.rst @@ -0,0 +1,8 @@ +CMAKE__CPPCHECK +--------------------- + +.. versionadded:: 3.10 + +Default value for :prop_tgt:`_CPPCHECK` target property. This variable +is used to initialize the property on each target as it is created. This +is done only when ```` is ``C`` or ``CXX``. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_CPPLINT.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_CPPLINT.rst new file mode 100644 index 0000000000000000000000000000000000000000..ab7b0fcb0658f2cad46f831f52e9a78e8a538946 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_CPPLINT.rst @@ -0,0 +1,8 @@ +CMAKE__CPPLINT +-------------------- + +.. versionadded:: 3.8 + +Default value for :prop_tgt:`_CPPLINT` target property. This variable +is used to initialize the property on each target as it is created. This +is done only when ```` is ``C`` or ``CXX``. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_CREATE_SHARED_LIBRARY.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_CREATE_SHARED_LIBRARY.rst new file mode 100644 index 0000000000000000000000000000000000000000..16fcc03447142809f504a3db10f447612c4bd882 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_CREATE_SHARED_LIBRARY.rst @@ -0,0 +1,8 @@ +CMAKE__CREATE_SHARED_LIBRARY +---------------------------------- + +Rule variable to create a shared library. + +This is a rule variable that tells CMake how to create a shared +library for the language ````. This rule variable is a ``;`` delimited +list of commands to run to perform the linking step. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_EXTENSIONS.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_EXTENSIONS.rst new file mode 100644 index 0000000000000000000000000000000000000000..3a32002f612583a23216cc87c41c007aed57b8c5 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_EXTENSIONS.rst @@ -0,0 +1,20 @@ +CMAKE__EXTENSIONS +----------------------- + +The variations are: + +* :variable:`CMAKE_C_EXTENSIONS` +* :variable:`CMAKE_CXX_EXTENSIONS` +* :variable:`CMAKE_CUDA_EXTENSIONS` +* :variable:`CMAKE_HIP_EXTENSIONS` +* :variable:`CMAKE_OBJC_EXTENSIONS` +* :variable:`CMAKE_OBJCXX_EXTENSIONS` + +Default values for :prop_tgt:`_EXTENSIONS` target properties if set when +a target is created. For the compiler's default setting see +:variable:`CMAKE__EXTENSIONS_DEFAULT`. + +For supported CMake versions see the respective pages. + +See the :manual:`cmake-compile-features(7)` manual for information on +compile features and a list of supported compilers. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_FLAGS_INIT.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_FLAGS_INIT.rst new file mode 100644 index 0000000000000000000000000000000000000000..ca13a29a059558503328d01aa73a5431f0add764 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_LANG_FLAGS_INIT.rst @@ -0,0 +1,19 @@ +CMAKE__FLAGS_INIT +----------------------- + +.. versionadded:: 3.7 + +Value used to initialize the :variable:`CMAKE__FLAGS` cache entry +the first time a build tree is configured for language ````. +This variable is meant to be set by a :variable:`toolchain file +`. CMake may prepend or append content to +the value based on the environment and target platform. For example, +the contents of a ``xxxFLAGS`` environment variable will be prepended, +where ``xxx`` will be language-specific but not necessarily the same as +```` (e.g. :envvar:`CXXFLAGS` for ``CXX``, :envvar:`FFLAGS` for +``Fortran``, and so on). +This value is a command-line string fragment. Therefore, multiple options +should be separated by spaces, and options with spaces should be quoted. + +See also the configuration-specific +:variable:`CMAKE__FLAGS__INIT` variable. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_MACOSX_BUNDLE.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_MACOSX_BUNDLE.rst new file mode 100644 index 0000000000000000000000000000000000000000..483c5b395f052d53722c8f619c82d4f1c93dcf89 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_MACOSX_BUNDLE.rst @@ -0,0 +1,10 @@ +CMAKE_MACOSX_BUNDLE +------------------- + +Default value for :prop_tgt:`MACOSX_BUNDLE` of targets. + +This variable is used to initialize the :prop_tgt:`MACOSX_BUNDLE` property on +all the targets. See that target property for additional information. + +This variable is set to ``ON`` by default if :variable:`CMAKE_SYSTEM_NAME` +equals to :ref:`iOS, tvOS, visionOS or watchOS `. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_Swift_LANGUAGE_VERSION.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_Swift_LANGUAGE_VERSION.rst new file mode 100644 index 0000000000000000000000000000000000000000..fce6fa726c206d598165e1c498b545886c01eca7 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_Swift_LANGUAGE_VERSION.rst @@ -0,0 +1,11 @@ +CMAKE_Swift_LANGUAGE_VERSION +---------------------------- + +.. versionadded:: 3.7 + +Set to the Swift language version number. If not set, the oldest legacy +version known to be available in the host Xcode version is assumed: + +* Swift ``4.0`` for Xcode 10.2 and above. +* Swift ``3.0`` for Xcode 8.3 and above. +* Swift ``2.3`` for Xcode 8.2 and below. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_VS_PLATFORM_TOOLSET_FORTRAN.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_VS_PLATFORM_TOOLSET_FORTRAN.rst new file mode 100644 index 0000000000000000000000000000000000000000..c7e414835f7a2700d20b7304677973b03ee2c89f --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_VS_PLATFORM_TOOLSET_FORTRAN.rst @@ -0,0 +1,12 @@ +CMAKE_VS_PLATFORM_TOOLSET_FORTRAN +--------------------------------- + +.. versionadded:: 3.29 + +Fortran compiler to be used by Visual Studio projects. + +:ref:`Visual Studio Generators` support selecting among Fortran compilers +that have the required Visual Studio Integration feature installed. The +compiler may be specified by a field in :variable:`CMAKE_GENERATOR_TOOLSET` of +the form ``fortran=...``. CMake provides the selected Fortran compiler in this +variable. The value may be empty if the field was not specified. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION.rst new file mode 100644 index 0000000000000000000000000000000000000000..2c14d3900d20d5af4e868d81a8dedc1213dff0f0 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION.rst @@ -0,0 +1,40 @@ +CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION +---------------------------------------- + +.. versionadded:: 3.4 + +Visual Studio Windows Target Platform Version. + +When targeting Windows 10 and above, :ref:`Visual Studio Generators` for +VS 2015 and above support specification of a Windows SDK version: + +* If :variable:`CMAKE_GENERATOR_PLATFORM` specifies a ``version=`` field, + as documented by :ref:`Visual Studio Platform Selection`, that SDK + version is selected. + +* Otherwise, if the ``WindowsSDKVersion`` environment variable + is set to an available SDK version, that version is selected. + This is intended for use in environments established by ``vcvarsall.bat`` + or similar scripts. + + .. versionadded:: 3.27 + This is enabled by policy :policy:`CMP0149`. + +* Otherwise, if :variable:`CMAKE_SYSTEM_VERSION` is set to an available + SDK version, that version is selected. + + .. versionchanged:: 3.27 + This is disabled by policy :policy:`CMP0149`. + +* Otherwise, CMake uses the latest Windows SDK version available. + +The chosen Windows target version number is provided +in ``CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION``. If no Windows 10 SDK +is available this value will be empty. + +One may set a ``CMAKE_WINDOWS_KITS_10_DIR`` *environment variable* +to an absolute path to tell CMake to look for Windows 10 SDKs in +a custom location. The specified directory is expected to contain +``Include/10.0.*`` directories. + +See also :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION_MAXIMUM`. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_XCODE_PLATFORM_TOOLSET.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_XCODE_PLATFORM_TOOLSET.rst new file mode 100644 index 0000000000000000000000000000000000000000..6d72d14141a28139f515d5f6fe89e0d6d84036f0 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CMAKE_XCODE_PLATFORM_TOOLSET.rst @@ -0,0 +1,9 @@ +CMAKE_XCODE_PLATFORM_TOOLSET +---------------------------- + +Xcode compiler selection. + +:generator:`Xcode` supports selection of a compiler from one of the installed +toolsets. CMake provides the name of the chosen toolset in this +variable, if any is explicitly selected (e.g. via the :option:`cmake -T` +option). diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CTEST_MEMORYCHECK_TYPE.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CTEST_MEMORYCHECK_TYPE.rst new file mode 100644 index 0000000000000000000000000000000000000000..80353a413db342223320096dad35b6e1a3653771 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CTEST_MEMORYCHECK_TYPE.rst @@ -0,0 +1,10 @@ +CTEST_MEMORYCHECK_TYPE +---------------------- + +.. versionadded:: 3.1 + +Specify the CTest ``MemoryCheckType`` setting +in a :manual:`ctest(1)` dashboard client script. +Valid values are ``Valgrind``, ``Purify``, ``BoundsChecker``, ``DrMemory``, +``CudaSanitizer``, ``ThreadSanitizer``, ``AddressSanitizer``, ``LeakSanitizer``, +``MemorySanitizer`` and ``UndefinedBehaviorSanitizer``. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CTEST_SOURCE_DIRECTORY.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CTEST_SOURCE_DIRECTORY.rst new file mode 100644 index 0000000000000000000000000000000000000000..4c6ac547ad1dc942ab0dea7fbe81e41fca654722 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CTEST_SOURCE_DIRECTORY.rst @@ -0,0 +1,7 @@ +CTEST_SOURCE_DIRECTORY +---------------------- + +.. versionadded:: 3.1 + +Specify the CTest ``SourceDirectory`` setting +in a :manual:`ctest(1)` dashboard client script. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CTEST_SUBMIT_URL.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CTEST_SUBMIT_URL.rst new file mode 100644 index 0000000000000000000000000000000000000000..b6e7f68b6cb9041c554e370eabcd341155532edb --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CTEST_SUBMIT_URL.rst @@ -0,0 +1,7 @@ +CTEST_SUBMIT_URL +---------------- + +.. versionadded:: 3.14 + +Specify the CTest ``SubmitURL`` setting +in a :manual:`ctest(1)` dashboard client script. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CTEST_SVN_UPDATE_OPTIONS.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CTEST_SVN_UPDATE_OPTIONS.rst new file mode 100644 index 0000000000000000000000000000000000000000..24e0bbf5cd7298e8bdee73bf54d02c9ed947013d --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/CTEST_SVN_UPDATE_OPTIONS.rst @@ -0,0 +1,7 @@ +CTEST_SVN_UPDATE_OPTIONS +------------------------ + +.. versionadded:: 3.1 + +Specify the CTest ``SVNUpdateOptions`` setting +in a :manual:`ctest(1)` dashboard client script. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/PROJECT-NAME_VERSION.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/PROJECT-NAME_VERSION.rst new file mode 100644 index 0000000000000000000000000000000000000000..0f6ed514b583e56686559994a1a224518a64ff70 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/PROJECT-NAME_VERSION.rst @@ -0,0 +1,11 @@ +_VERSION +---------------------- + +Value given to the ``VERSION`` option of the most recent call to the +:command:`project` command with project name ````, if any. + +See also the component-wise version variables +:variable:`_VERSION_MAJOR`, +:variable:`_VERSION_MINOR`, +:variable:`_VERSION_PATCH`, and +:variable:`_VERSION_TWEAK`. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/PROJECT-NAME_VERSION_MINOR.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/PROJECT-NAME_VERSION_MINOR.rst new file mode 100644 index 0000000000000000000000000000000000000000..fa2cdab58069f127ed440b1896f1a2171c6494b3 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/PROJECT-NAME_VERSION_MINOR.rst @@ -0,0 +1,5 @@ +_VERSION_MINOR +---------------------------- + +Second version number component of the :variable:`_VERSION` +variable as set by the :command:`project` command. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/XCODE_VERSION.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/XCODE_VERSION.rst new file mode 100644 index 0000000000000000000000000000000000000000..9caf19a41a21242c9832ff51a5295ab2ca8d12f7 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/variable/XCODE_VERSION.rst @@ -0,0 +1,7 @@ +XCODE_VERSION +------------- + +Version of Xcode (:generator:`Xcode` generator only). + +Under the :generator:`Xcode` generator, this is the version of Xcode +as specified in ``Xcode.app/Contents/version.plist`` (such as ``3.1.2``). diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_cudnn_init_dropout_state.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_cudnn_init_dropout_state.h new file mode 100644 index 0000000000000000000000000000000000000000..915c8834d82b03085679aaed7f229f2563ecd317 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_cudnn_init_dropout_state.h @@ -0,0 +1,43 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_cudnn_init_dropout_state(float dropout, bool train, int dropout_seed, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor +inline at::Tensor _cudnn_init_dropout_state(double dropout, bool train, int64_t dropout_seed, at::TensorOptions options) { + return at::_ops::_cudnn_init_dropout_state::call(dropout, train, dropout_seed, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); +} +// aten::_cudnn_init_dropout_state(float dropout, bool train, int dropout_seed, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor +inline at::Tensor _cudnn_init_dropout_state(double dropout, bool train, int64_t dropout_seed, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) { + return at::_ops::_cudnn_init_dropout_state::call(dropout, train, dropout_seed, dtype, layout, device, pin_memory); +} + +// aten::_cudnn_init_dropout_state.out(float dropout, bool train, int dropout_seed, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _cudnn_init_dropout_state_out(at::Tensor & out, double dropout, bool train, int64_t dropout_seed) { + return at::_ops::_cudnn_init_dropout_state_out::call(dropout, train, dropout_seed, out); +} +// aten::_cudnn_init_dropout_state.out(float dropout, bool train, int dropout_seed, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _cudnn_init_dropout_state_outf(double dropout, bool train, int64_t dropout_seed, at::Tensor & out) { + return at::_ops::_cudnn_init_dropout_state_out::call(dropout, train, dropout_seed, out); +} + +} diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_cudnn_rnn.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_cudnn_rnn.h new file mode 100644 index 0000000000000000000000000000000000000000..076ee0eb3d5a2b6cdf9c8154093c4fe46e4c9990 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_cudnn_rnn.h @@ -0,0 +1,91 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_cudnn_rnn(Tensor input, Tensor[] weight, int weight_stride0, Tensor? weight_buf, Tensor hx, Tensor? cx, int mode, SymInt hidden_size, SymInt proj_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, SymInt[] batch_sizes, Tensor? dropout_state) -> (Tensor, Tensor, Tensor, Tensor, Tensor) +inline ::std::tuple _cudnn_rnn(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const c10::optional & weight_buf, const at::Tensor & hx, const c10::optional & cx, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const c10::optional & dropout_state) { + return at::_ops::_cudnn_rnn::call(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, c10::fromIntArrayRefSlow(batch_sizes), dropout_state); +} +namespace symint { + template ::value>> + ::std::tuple _cudnn_rnn(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const c10::optional & weight_buf, const at::Tensor & hx, const c10::optional & cx, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const c10::optional & dropout_state) { + return at::_ops::_cudnn_rnn::call(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, c10::fromIntArrayRefSlow(batch_sizes), dropout_state); + } +} + +// aten::_cudnn_rnn(Tensor input, Tensor[] weight, int weight_stride0, Tensor? weight_buf, Tensor hx, Tensor? cx, int mode, SymInt hidden_size, SymInt proj_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, SymInt[] batch_sizes, Tensor? dropout_state) -> (Tensor, Tensor, Tensor, Tensor, Tensor) +inline ::std::tuple _cudnn_rnn_symint(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const c10::optional & weight_buf, const at::Tensor & hx, const c10::optional & cx, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, c10::SymIntArrayRef batch_sizes, const c10::optional & dropout_state) { + return at::_ops::_cudnn_rnn::call(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state); +} +namespace symint { + template ::value>> + ::std::tuple _cudnn_rnn(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const c10::optional & weight_buf, const at::Tensor & hx, const c10::optional & cx, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, c10::SymIntArrayRef batch_sizes, const c10::optional & dropout_state) { + return at::_ops::_cudnn_rnn::call(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state); + } +} + +// aten::_cudnn_rnn.out(Tensor input, Tensor[] weight, int weight_stride0, Tensor? weight_buf, Tensor hx, Tensor? cx, int mode, SymInt hidden_size, SymInt proj_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, SymInt[] batch_sizes, Tensor? dropout_state, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3, Tensor(e!) out4) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!), Tensor(e!)) +inline ::std::tuple _cudnn_rnn_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const c10::optional & weight_buf, const at::Tensor & hx, const c10::optional & cx, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const c10::optional & dropout_state) { + return at::_ops::_cudnn_rnn_out::call(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, c10::fromIntArrayRefSlow(batch_sizes), dropout_state, out0, out1, out2, out3, out4); +} +namespace symint { + template ::value>> + ::std::tuple _cudnn_rnn_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const c10::optional & weight_buf, const at::Tensor & hx, const c10::optional & cx, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const c10::optional & dropout_state) { + return at::_ops::_cudnn_rnn_out::call(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, c10::fromIntArrayRefSlow(batch_sizes), dropout_state, out0, out1, out2, out3, out4); + } +} + +// aten::_cudnn_rnn.out(Tensor input, Tensor[] weight, int weight_stride0, Tensor? weight_buf, Tensor hx, Tensor? cx, int mode, SymInt hidden_size, SymInt proj_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, SymInt[] batch_sizes, Tensor? dropout_state, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3, Tensor(e!) out4) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!), Tensor(e!)) +inline ::std::tuple _cudnn_rnn_outf(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const c10::optional & weight_buf, const at::Tensor & hx, const c10::optional & cx, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const c10::optional & dropout_state, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4) { + return at::_ops::_cudnn_rnn_out::call(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, c10::fromIntArrayRefSlow(batch_sizes), dropout_state, out0, out1, out2, out3, out4); +} +namespace symint { + template ::value>> + ::std::tuple _cudnn_rnn_outf(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const c10::optional & weight_buf, const at::Tensor & hx, const c10::optional & cx, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const c10::optional & dropout_state, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4) { + return at::_ops::_cudnn_rnn_out::call(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, c10::fromIntArrayRefSlow(batch_sizes), dropout_state, out0, out1, out2, out3, out4); + } +} + +// aten::_cudnn_rnn.out(Tensor input, Tensor[] weight, int weight_stride0, Tensor? weight_buf, Tensor hx, Tensor? cx, int mode, SymInt hidden_size, SymInt proj_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, SymInt[] batch_sizes, Tensor? dropout_state, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3, Tensor(e!) out4) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!), Tensor(e!)) +inline ::std::tuple _cudnn_rnn_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const c10::optional & weight_buf, const at::Tensor & hx, const c10::optional & cx, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, c10::SymIntArrayRef batch_sizes, const c10::optional & dropout_state) { + return at::_ops::_cudnn_rnn_out::call(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, out0, out1, out2, out3, out4); +} +namespace symint { + template ::value>> + ::std::tuple _cudnn_rnn_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const c10::optional & weight_buf, const at::Tensor & hx, const c10::optional & cx, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, c10::SymIntArrayRef batch_sizes, const c10::optional & dropout_state) { + return at::_ops::_cudnn_rnn_out::call(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, out0, out1, out2, out3, out4); + } +} + +// aten::_cudnn_rnn.out(Tensor input, Tensor[] weight, int weight_stride0, Tensor? weight_buf, Tensor hx, Tensor? cx, int mode, SymInt hidden_size, SymInt proj_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, SymInt[] batch_sizes, Tensor? dropout_state, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3, Tensor(e!) out4) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!), Tensor(e!)) +inline ::std::tuple _cudnn_rnn_symint_outf(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const c10::optional & weight_buf, const at::Tensor & hx, const c10::optional & cx, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, c10::SymIntArrayRef batch_sizes, const c10::optional & dropout_state, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4) { + return at::_ops::_cudnn_rnn_out::call(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, out0, out1, out2, out3, out4); +} +namespace symint { + template ::value>> + ::std::tuple _cudnn_rnn_outf(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const c10::optional & weight_buf, const at::Tensor & hx, const c10::optional & cx, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, c10::SymIntArrayRef batch_sizes, const c10::optional & dropout_state, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4) { + return at::_ops::_cudnn_rnn_out::call(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, out0, out1, out2, out3, out4); + } +} + +} diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_asin.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_asin.h new file mode 100644 index 0000000000000000000000000000000000000000..3b4a0adb20a0fa3a5daa757cc3d84df97ae95653 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_asin.h @@ -0,0 +1,44 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_foreach_asin(Tensor[] self) -> Tensor[] +inline ::std::vector _foreach_asin(at::TensorList self) { + return at::_ops::_foreach_asin::call(self); +} + +// aten::_foreach_asin_(Tensor(a!)[] self) -> () +inline void _foreach_asin_(at::TensorList self) { + return at::_ops::_foreach_asin_::call(self); +} + +// aten::_foreach_asin.out(Tensor[] self, *, Tensor(a!)[] out) -> () +inline void _foreach_asin_out(at::TensorList out, at::TensorList self) { + return at::_ops::_foreach_asin_out::call(self, out); +} +// aten::_foreach_asin.out(Tensor[] self, *, Tensor(a!)[] out) -> () +inline void _foreach_asin_outf(at::TensorList self, at::TensorList out) { + return at::_ops::_foreach_asin_out::call(self, out); +} + +} diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_erfc.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_erfc.h new file mode 100644 index 0000000000000000000000000000000000000000..9e95a2cc999c32bcb75e14d9b0da21285993944e --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_erfc.h @@ -0,0 +1,44 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_foreach_erfc(Tensor[] self) -> Tensor[] +inline ::std::vector _foreach_erfc(at::TensorList self) { + return at::_ops::_foreach_erfc::call(self); +} + +// aten::_foreach_erfc_(Tensor(a!)[] self) -> () +inline void _foreach_erfc_(at::TensorList self) { + return at::_ops::_foreach_erfc_::call(self); +} + +// aten::_foreach_erfc.out(Tensor[] self, *, Tensor(a!)[] out) -> () +inline void _foreach_erfc_out(at::TensorList out, at::TensorList self) { + return at::_ops::_foreach_erfc_out::call(self, out); +} +// aten::_foreach_erfc.out(Tensor[] self, *, Tensor(a!)[] out) -> () +inline void _foreach_erfc_outf(at::TensorList self, at::TensorList out) { + return at::_ops::_foreach_erfc_out::call(self, out); +} + +} diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_fw_primal_copy_compositeexplicitautogradnonfunctional_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_fw_primal_copy_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..837cbdb157ace79160d6103c1730e8fffb7dbaa7 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_fw_primal_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 _fw_primal_copy(const at::Tensor & self, int64_t level); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_nested_from_padded_and_nested_example_compositeexplicitautograd_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_nested_from_padded_and_nested_example_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..0510927a120e8a6353faf3fa05542c42510e6893 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_nested_from_padded_and_nested_example_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 & _nested_from_padded_and_nested_example_out(at::Tensor & out, const at::Tensor & padded, const at::Tensor & nt_example); +TORCH_API at::Tensor & _nested_from_padded_and_nested_example_outf(const at::Tensor & padded, const at::Tensor & nt_example, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_unsafe_view_ops.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_unsafe_view_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..08ebff8f8d120a1c702011dee27079572c3dfaec --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_unsafe_view_ops.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#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 _unsafe_view { + using schema = at::Tensor (const at::Tensor &, c10::SymIntArrayRef); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_unsafe_view") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_unsafe_view(Tensor self, SymInt[] size) -> Tensor") + 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); +}; + +struct TORCH_API _unsafe_view_out { + using schema = at::Tensor & (const at::Tensor &, c10::SymIntArrayRef, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_unsafe_view") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_unsafe_view.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_upsample_nearest_exact1d_cuda_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_upsample_nearest_exact1d_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..deeafb0aef4846bfbe38fcb74feecdd52aeaf2b4 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/_upsample_nearest_exact1d_cuda_dispatch.h @@ -0,0 +1,28 @@ +#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 _upsample_nearest_exact1d(const at::Tensor & self, at::IntArrayRef output_size, c10::optional scales=c10::nullopt); +TORCH_API at::Tensor _upsample_nearest_exact1d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, c10::optional scales=c10::nullopt); +TORCH_API at::Tensor & _upsample_nearest_exact1d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, c10::optional scales=c10::nullopt); +TORCH_API at::Tensor & _upsample_nearest_exact1d_outf(const at::Tensor & self, at::IntArrayRef output_size, c10::optional scales, at::Tensor & out); +TORCH_API at::Tensor & _upsample_nearest_exact1d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, c10::optional scales=c10::nullopt); +TORCH_API at::Tensor & _upsample_nearest_exact1d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, c10::optional scales, at::Tensor & out); + +} // namespace cuda +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/adaptive_max_pool3d_backward_ops.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/adaptive_max_pool3d_backward_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..23f2f1d6c90e4f59b438df4432edabe5169ade37 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/adaptive_max_pool3d_backward_ops.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#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 adaptive_max_pool3d_backward_grad_input { + using schema = at::Tensor & (const 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_STR_INL_EXCEPT_WIN_CUDA(name, "aten::adaptive_max_pool3d_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "grad_input") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "adaptive_max_pool3d_backward.grad_input(Tensor grad_output, Tensor self, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices, at::Tensor & grad_input); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices, at::Tensor & grad_input); +}; + +struct TORCH_API adaptive_max_pool3d_backward { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::adaptive_max_pool3d_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "adaptive_max_pool3d_backward(Tensor grad_output, Tensor self, Tensor indices) -> Tensor") + static at::Tensor call(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices); +}; + +}} // namespace at::_ops diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/addr_ops.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/addr_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..b6e2ad0b10e0c7ac89438072c897fdbe239a8caf --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/addr_ops.h @@ -0,0 +1,50 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#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 addr { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::addr") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "addr(Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1) -> Tensor") + static at::Tensor call(const at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha); +}; + +struct TORCH_API addr_ { + using schema = at::Tensor & (at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::addr_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "addr_(Tensor(a!) self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1) -> Tensor(a!)") + static at::Tensor & call(at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha); +}; + +struct TORCH_API addr_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::addr") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "addr.out(Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/asinh_ops.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/asinh_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..f0c23518b83d80b699472536e22ce0e587f4e6e1 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/asinh_ops.h @@ -0,0 +1,50 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#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 asinh { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::asinh") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "asinh(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 asinh_ { + using schema = at::Tensor & (at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::asinh_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "asinh_(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 asinh_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_STR_INL_EXCEPT_WIN_CUDA(name, "aten::asinh") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "asinh.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/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/cholesky_solve_compositeexplicitautograd_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/cholesky_solve_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..b99c5e82d3f52235ba13ec94d3a770625039d461 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/cholesky_solve_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 cholesky_solve(const at::Tensor & self, const at::Tensor & input2, bool upper=false); +TORCH_API at::Tensor & cholesky_solve_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & input2, bool upper=false); +TORCH_API at::Tensor & cholesky_solve_outf(const at::Tensor & self, const at::Tensor & input2, bool upper, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/cosh.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/cosh.h new file mode 100644 index 0000000000000000000000000000000000000000..dc6b6090d3cc17cf738bc88d060c95569c9ba53e --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/cosh.h @@ -0,0 +1,44 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::cosh(Tensor self) -> Tensor +inline at::Tensor cosh(const at::Tensor & self) { + return at::_ops::cosh::call(self); +} + +// aten::cosh_(Tensor(a!) self) -> Tensor(a!) +inline at::Tensor & cosh_(at::Tensor & self) { + return at::_ops::cosh_::call(self); +} + +// aten::cosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & cosh_out(at::Tensor & out, const at::Tensor & self) { + return at::_ops::cosh_out::call(self, out); +} +// aten::cosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & cosh_outf(const at::Tensor & self, at::Tensor & out) { + return at::_ops::cosh_out::call(self, out); +} + +} diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_affine_grid_generator_backward_cuda_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_affine_grid_generator_backward_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..3b868da7cf29b29f069787b2228af0550b8129a0 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_affine_grid_generator_backward_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 cudnn_affine_grid_generator_backward(const at::Tensor & grad, int64_t N, int64_t C, int64_t H, int64_t W); + +} // namespace cuda +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/data.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/data.h new file mode 100644 index 0000000000000000000000000000000000000000..31d5b8067e5d0630f0b62cc9c048995fd70721a5 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/data.h @@ -0,0 +1,26 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + + +} diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/div_native.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/div_native.h new file mode 100644 index 0000000000000000000000000000000000000000..f7073fba5f517aa072decc244ff5bf4abd9519d6 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/div_native.h @@ -0,0 +1,41 @@ +#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_div_out : public at::meta::structured_div_Tensor { +void impl(const at::Tensor & self, const at::Tensor & other, const at::Tensor & out); +}; +TORCH_API at::Tensor NestedTensor_div_Tensor(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor div_sparse(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & div_out_sparse_zerodim(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & div_sparse_(at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor div_zerotensor(const at::Tensor & self, const at::Tensor & other); +struct TORCH_API structured_div_out_mode : public at::meta::structured_div_Tensor_mode { +void impl(const at::Tensor & self, const at::Tensor & other, c10::optional rounding_mode, const at::Tensor & out); +}; +TORCH_API at::Tensor div_sparse(const at::Tensor & self, const at::Tensor & other, c10::optional rounding_mode); +TORCH_API at::Tensor & div_out_sparse_zerodim(const at::Tensor & self, const at::Tensor & other, c10::optional rounding_mode, at::Tensor & out); +TORCH_API at::Tensor & div_sparse_(at::Tensor & self, const at::Tensor & other, c10::optional rounding_mode); +TORCH_API at::Tensor div(const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & div_Scalar_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out); +TORCH_API at::Tensor & div_(at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor NestedTensor_div_Scalar(const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor div(const at::Tensor & self, const at::Scalar & other, c10::optional rounding_mode); +TORCH_API at::Tensor & div_Scalar_mode_out(const at::Tensor & self, const at::Scalar & other, c10::optional rounding_mode, at::Tensor & out); +TORCH_API at::Tensor & div_(at::Tensor & self, const at::Scalar & other, c10::optional rounding_mode); +} // namespace native +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/empty_strided_cuda_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/empty_strided_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..5035b85e1cb32313b6f75260ff372fe76a0287ce --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/empty_strided_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 empty_strided(at::IntArrayRef size, at::IntArrayRef stride, at::TensorOptions options={}); +TORCH_API at::Tensor empty_strided(at::IntArrayRef size, at::IntArrayRef stride, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); +TORCH_API at::Tensor empty_strided_symint(c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::TensorOptions options={}); +TORCH_API at::Tensor empty_strided_symint(c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); + +} // namespace cuda +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/geqrf_ops.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/geqrf_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..80fb5deda707de5d7377460bf0ba574bfd4081e2 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/geqrf_ops.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#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 geqrf_a { + using schema = ::std::tuple (const at::Tensor &, at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::geqrf") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "a") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "geqrf.a(Tensor self, *, Tensor(a!) a, Tensor(b!) tau) -> (Tensor(a!) a, Tensor(b!) tau)") + static ::std::tuple call(const at::Tensor & self, at::Tensor & a, at::Tensor & tau); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & a, at::Tensor & tau); +}; + +struct TORCH_API geqrf { + using schema = ::std::tuple (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::geqrf") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "geqrf(Tensor self) -> (Tensor a, Tensor tau)") + static ::std::tuple call(const at::Tensor & self); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +}} // namespace at::_ops diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/heaviside_meta.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/heaviside_meta.h new file mode 100644 index 0000000000000000000000000000000000000000..e951de9a263d77aea9449fa6b81d6211437b3acf --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/heaviside_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_heaviside : public TensorIteratorBase { + + + void meta(const at::Tensor & self, const at::Tensor & values); +}; + +} // namespace native +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/hsplit_ops.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/hsplit_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..72acce599b2bb8d0616f4f7e45eca601a8e58c4a --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/hsplit_ops.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#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 hsplit_int { + using schema = ::std::vector (const at::Tensor &, int64_t); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::hsplit") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "int") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "hsplit.int(Tensor(a -> *) self, int sections) -> Tensor(a)[]") + static ::std::vector call(const at::Tensor & self, int64_t sections); + static ::std::vector redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t sections); +}; + +struct TORCH_API hsplit_array { + using schema = ::std::vector (const at::Tensor &, at::IntArrayRef); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::hsplit") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "array") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "hsplit.array(Tensor(a -> *) self, int[] indices) -> Tensor(a)[]") + static ::std::vector call(const at::Tensor & self, at::IntArrayRef indices); + static ::std::vector redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef indices); +}; + +}} // namespace at::_ops diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/huber_loss_backward_cuda_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/huber_loss_backward_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..534fd4019d4547dca8c8d7d498233daeac7124a2 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/huber_loss_backward_cuda_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 cuda { + +TORCH_API at::Tensor & huber_loss_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, int64_t reduction, double delta); +TORCH_API at::Tensor & huber_loss_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, int64_t reduction, double delta, at::Tensor & grad_input); + +} // namespace cuda +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/index_reduce_meta_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/index_reduce_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..3a00a88d2ae924fec00dff4a255dd40aa4fe1912 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/index_reduce_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 index_reduce(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, c10::string_view reduce, bool include_self=true); +TORCH_API at::Tensor & index_reduce_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, c10::string_view reduce, bool include_self=true); +TORCH_API at::Tensor & index_reduce_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, c10::string_view reduce, bool include_self, at::Tensor & out); +TORCH_API at::Tensor & index_reduce_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, c10::string_view reduce, bool include_self=true); + +} // namespace meta +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/indices_native.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/indices_native.h new file mode 100644 index 0000000000000000000000000000000000000000..bca0c4f1847395349bf234e1c93bde046fad6f3f --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/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 indices_default(const at::Tensor & self); +TORCH_API at::Tensor indices_sparse(const at::Tensor & self); +} // namespace native +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/log2.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/log2.h new file mode 100644 index 0000000000000000000000000000000000000000..26f1356fb5ec992b25d159d3ec2f77980e4b0463 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/log2.h @@ -0,0 +1,44 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::log2(Tensor self) -> Tensor +inline at::Tensor log2(const at::Tensor & self) { + return at::_ops::log2::call(self); +} + +// aten::log2_(Tensor(a!) self) -> Tensor(a!) +inline at::Tensor & log2_(at::Tensor & self) { + return at::_ops::log2_::call(self); +} + +// aten::log2.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & log2_out(at::Tensor & out, const at::Tensor & self) { + return at::_ops::log2_out::call(self, out); +} +// aten::log2.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & log2_outf(const at::Tensor & self, at::Tensor & out) { + return at::_ops::log2_out::call(self, out); +} + +} diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/log_ops.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/log_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..c4aa74a756df79938946af76396cc0517f3564a6 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/log_ops.h @@ -0,0 +1,50 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#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 log { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::log") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "log(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 log_ { + using schema = at::Tensor & (at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::log_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "log_(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 log_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_STR_INL_EXCEPT_WIN_CUDA(name, "aten::log") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "log.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/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/median_native.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/median_native.h new file mode 100644 index 0000000000000000000000000000000000000000..3279c68175282487af83f8e573a9e680f56267b1 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/median_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 + + +namespace at { +namespace native { +TORCH_API at::Tensor & median_out(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor median_cpu(const at::Tensor & self); +TORCH_API at::Tensor median_cuda(const at::Tensor & self); +TORCH_API ::std::tuple median(const at::Tensor & self, int64_t dim, bool keepdim=false); +TORCH_API ::std::tuple median_out_cpu(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & values, at::Tensor & indices); +TORCH_API ::std::tuple median_out_cuda(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & values, at::Tensor & indices); +TORCH_API ::std::tuple median(const at::Tensor & self, at::Dimname dim, bool keepdim=false); +TORCH_API ::std::tuple median_out(const at::Tensor & self, at::Dimname dim, bool keepdim, at::Tensor & values, at::Tensor & indices); +} // namespace native +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/meshgrid_ops.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/meshgrid_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..ae79a206c288214e56356ac2da0d0f6618b8a823 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/meshgrid_ops.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#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 meshgrid { + using schema = ::std::vector (at::TensorList); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::meshgrid") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "meshgrid(Tensor[] tensors) -> Tensor[]") + static ::std::vector call(at::TensorList tensors); + static ::std::vector redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList tensors); +}; + +struct TORCH_API meshgrid_indexing { + using schema = ::std::vector (at::TensorList, c10::string_view); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::meshgrid") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "indexing") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "meshgrid.indexing(Tensor[] tensors, *, str indexing) -> Tensor[]") + static ::std::vector call(at::TensorList tensors, c10::string_view indexing); + static ::std::vector redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList tensors, c10::string_view indexing); +}; + +}} // namespace at::_ops diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/minimum_compositeexplicitautogradnonfunctional_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/minimum_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..b87be6278a0c7e38199cd1e1f5f176a32c07517d --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/minimum_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 minimum(const at::Tensor & self, const at::Tensor & other); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/miopen_batch_norm_backward_compositeexplicitautograd_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/miopen_batch_norm_backward_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..462c1abf07523b66b8c6da42b342a0ff8e3cdae5 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/miopen_batch_norm_backward_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 ::std::tuple miopen_batch_norm_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & input, const at::Tensor & grad_output, const at::Tensor & weight, const c10::optional & running_mean, const c10::optional & running_var, const c10::optional & save_mean, const c10::optional & save_var, double epsilon); +TORCH_API ::std::tuple miopen_batch_norm_backward_outf(const at::Tensor & input, const at::Tensor & grad_output, const at::Tensor & weight, const c10::optional & running_mean, const c10::optional & running_var, const c10::optional & save_mean, const c10::optional & save_var, double epsilon, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/nanquantile_compositeimplicitautograd_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/nanquantile_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..6d4c3cb97f7b6f2d01ac8b44c7bff59553213c22 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/nanquantile_compositeimplicitautograd_dispatch.h @@ -0,0 +1,28 @@ +#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 nanquantile(const at::Tensor & self, const at::Tensor & q, c10::optional dim=c10::nullopt, bool keepdim=false, c10::string_view interpolation="linear"); +TORCH_API at::Tensor & nanquantile_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & q, c10::optional dim=c10::nullopt, bool keepdim=false, c10::string_view interpolation="linear"); +TORCH_API at::Tensor & nanquantile_outf(const at::Tensor & self, const at::Tensor & q, c10::optional dim, bool keepdim, c10::string_view interpolation, at::Tensor & out); +TORCH_API at::Tensor nanquantile(const at::Tensor & self, double q, c10::optional dim=c10::nullopt, bool keepdim=false, c10::string_view interpolation="linear"); +TORCH_API at::Tensor & nanquantile_out(at::Tensor & out, const at::Tensor & self, double q, c10::optional dim=c10::nullopt, bool keepdim=false, c10::string_view interpolation="linear"); +TORCH_API at::Tensor & nanquantile_outf(const at::Tensor & self, double q, c10::optional dim, bool keepdim, c10::string_view interpolation, at::Tensor & out); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/narrow_copy_native.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/narrow_copy_native.h new file mode 100644 index 0000000000000000000000000000000000000000..fcfdf70b972b0d1c5517881e6bbb4cad5173b5f8 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/narrow_copy_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 narrow_copy_dense_cpu(const at::Tensor & self, int64_t dim, int64_t start, int64_t length); +TORCH_API at::Tensor & narrow_copy_dense_cpu_out(const at::Tensor & self, int64_t dim, int64_t start, int64_t length, at::Tensor & out); +TORCH_API at::Tensor narrow_copy_sparse(const at::Tensor & self, int64_t dim, int64_t start, int64_t length); +TORCH_API at::Tensor narrow_copy_dense_symint(const at::Tensor & self, int64_t dim, c10::SymInt start, c10::SymInt length); +} // namespace native +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/new_full.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/new_full.h new file mode 100644 index 0000000000000000000000000000000000000000..99c9d9844440147770e0f0e16896e5560668df1a --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/new_full.h @@ -0,0 +1,97 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +namespace symint { + template ::value>> + at::Tensor new_full(const at::Tensor & self, at::IntArrayRef size, const at::Scalar & fill_value, at::TensorOptions options={}) { + return at::_ops::new_full::call(self, c10::fromIntArrayRefSlow(size), fill_value, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); + } +} + +namespace symint { + template ::value>> + at::Tensor new_full(const at::Tensor & self, at::IntArrayRef size, const at::Scalar & fill_value, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) { + return at::_ops::new_full::call(self, c10::fromIntArrayRefSlow(size), fill_value, dtype, layout, device, pin_memory); + } +} + +namespace symint { + template ::value>> + at::Tensor new_full(const at::Tensor & self, c10::SymIntArrayRef size, const at::Scalar & fill_value, at::TensorOptions options={}) { + return at::_ops::new_full::call(self, size, fill_value, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); + } +} + +namespace symint { + template ::value>> + at::Tensor new_full(const at::Tensor & self, c10::SymIntArrayRef size, const at::Scalar & fill_value, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) { + return at::_ops::new_full::call(self, size, fill_value, dtype, layout, device, pin_memory); + } +} + +// aten::new_full.out(Tensor self, SymInt[] size, Scalar fill_value, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & new_full_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, const at::Scalar & fill_value) { + return at::_ops::new_full_out::call(self, c10::fromIntArrayRefSlow(size), fill_value, out); +} +namespace symint { + template ::value>> + at::Tensor & new_full_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, const at::Scalar & fill_value) { + return at::_ops::new_full_out::call(self, c10::fromIntArrayRefSlow(size), fill_value, out); + } +} + +// aten::new_full.out(Tensor self, SymInt[] size, Scalar fill_value, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & new_full_outf(const at::Tensor & self, at::IntArrayRef size, const at::Scalar & fill_value, at::Tensor & out) { + return at::_ops::new_full_out::call(self, c10::fromIntArrayRefSlow(size), fill_value, out); +} +namespace symint { + template ::value>> + at::Tensor & new_full_outf(const at::Tensor & self, at::IntArrayRef size, const at::Scalar & fill_value, at::Tensor & out) { + return at::_ops::new_full_out::call(self, c10::fromIntArrayRefSlow(size), fill_value, out); + } +} + +// aten::new_full.out(Tensor self, SymInt[] size, Scalar fill_value, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & new_full_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size, const at::Scalar & fill_value) { + return at::_ops::new_full_out::call(self, size, fill_value, out); +} +namespace symint { + template ::value>> + at::Tensor & new_full_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size, const at::Scalar & fill_value) { + return at::_ops::new_full_out::call(self, size, fill_value, out); + } +} + +// aten::new_full.out(Tensor self, SymInt[] size, Scalar fill_value, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & new_full_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, const at::Scalar & fill_value, at::Tensor & out) { + return at::_ops::new_full_out::call(self, size, fill_value, out); +} +namespace symint { + template ::value>> + at::Tensor & new_full_outf(const at::Tensor & self, c10::SymIntArrayRef size, const at::Scalar & fill_value, at::Tensor & out) { + return at::_ops::new_full_out::call(self, size, fill_value, out); + } +} + +} diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/pixel_unshuffle_compositeexplicitautogradnonfunctional_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/pixel_unshuffle_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..afa8e142702362de4ef26a8c0484561a20ea2ade --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/pixel_unshuffle_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 pixel_unshuffle(const at::Tensor & self, int64_t downscale_factor); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/replication_pad1d_meta_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/replication_pad1d_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..a723ae7e1f9ec7fe51e5b7bf6d5bb2bbb50f16f6 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/replication_pad1d_meta_dispatch.h @@ -0,0 +1,28 @@ +#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 replication_pad1d(const at::Tensor & self, at::IntArrayRef padding); +TORCH_API at::Tensor replication_pad1d_symint(const at::Tensor & self, c10::SymIntArrayRef padding); +TORCH_API at::Tensor & replication_pad1d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef padding); +TORCH_API at::Tensor & replication_pad1d_outf(const at::Tensor & self, at::IntArrayRef padding, at::Tensor & out); +TORCH_API at::Tensor & replication_pad1d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef padding); +TORCH_API at::Tensor & replication_pad1d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & out); + +} // namespace meta +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/rnn_relu_ops.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/rnn_relu_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..7aa4a8869b42c464189203e26cca32e2faf43fd6 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/rnn_relu_ops.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#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 rnn_relu_input { + using schema = ::std::tuple (const at::Tensor &, const at::Tensor &, at::TensorList, bool, int64_t, double, bool, bool, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::rnn_relu") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "input") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "rnn_relu.input(Tensor input, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor)") + static ::std::tuple call(const at::Tensor & input, const at::Tensor & hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first); +}; + +struct TORCH_API rnn_relu_data { + using schema = ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::TensorList, bool, int64_t, double, bool, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::rnn_relu") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "data") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "rnn_relu.data(Tensor data, Tensor batch_sizes, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional) -> (Tensor, Tensor)") + static ::std::tuple call(const at::Tensor & data, const at::Tensor & batch_sizes, const at::Tensor & hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & data, const at::Tensor & batch_sizes, const at::Tensor & hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional); +}; + +}} // namespace at::_ops diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/rot90.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/rot90.h new file mode 100644 index 0000000000000000000000000000000000000000..dde6cb6b74f488fdb5763bb03ab2a7a5c0c829a1 --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/rot90.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::rot90(Tensor self, int k=1, int[] dims=[0,1]) -> Tensor +inline at::Tensor rot90(const at::Tensor & self, int64_t k=1, at::IntArrayRef dims={0,1}) { + return at::_ops::rot90::call(self, k, dims); +} + +// aten::rot90.out(Tensor self, int k=1, int[] dims=[0,1], *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & rot90_out(at::Tensor & out, const at::Tensor & self, int64_t k=1, at::IntArrayRef dims={0,1}) { + return at::_ops::rot90_out::call(self, k, dims, out); +} +// aten::rot90.out(Tensor self, int k=1, int[] dims=[0,1], *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & rot90_outf(const at::Tensor & self, int64_t k, at::IntArrayRef dims, at::Tensor & out) { + return at::_ops::rot90_out::call(self, k, dims, out); +} + +} diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/scatter_meta_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/scatter_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..9294ba854b56891a7c8e1361eca34bdc238896ee --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/scatter_meta_dispatch.h @@ -0,0 +1,38 @@ +#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 scatter(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src); +TORCH_API at::Tensor & scatter_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src); +TORCH_API at::Tensor & scatter_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, at::Tensor & out); +TORCH_API at::Tensor & scatter_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src); +TORCH_API at::Tensor scatter(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value); +TORCH_API at::Tensor & scatter_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value); +TORCH_API at::Tensor & scatter_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, at::Tensor & out); +TORCH_API at::Tensor & scatter_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value); +TORCH_API at::Tensor scatter(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce); +TORCH_API at::Tensor & scatter_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce); +TORCH_API at::Tensor & scatter_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, at::Tensor & out); +TORCH_API at::Tensor & scatter_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce); +TORCH_API at::Tensor scatter(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, c10::string_view reduce); +TORCH_API at::Tensor & scatter_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, c10::string_view reduce); +TORCH_API at::Tensor & scatter_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, c10::string_view reduce, at::Tensor & out); +TORCH_API at::Tensor & scatter_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, c10::string_view reduce); + +} // namespace meta +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/special_bessel_y0_native.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/special_bessel_y0_native.h new file mode 100644 index 0000000000000000000000000000000000000000..6e83ac250bee459d1d3c8848c3ed451418743a8f --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/special_bessel_y0_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_special_bessel_y0_out : public at::meta::structured_special_bessel_y0 { +void impl(const at::Tensor & self, const at::Tensor & out); +}; +} // namespace native +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/special_log_ndtr.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/special_log_ndtr.h new file mode 100644 index 0000000000000000000000000000000000000000..870c11f8833b4e8d5f4ca82c9a3b307b4301542d --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/special_log_ndtr.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::special_log_ndtr(Tensor self) -> Tensor +inline at::Tensor special_log_ndtr(const at::Tensor & self) { + return at::_ops::special_log_ndtr::call(self); +} + +// aten::special_log_ndtr.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & special_log_ndtr_out(at::Tensor & out, const at::Tensor & self) { + return at::_ops::special_log_ndtr_out::call(self, out); +} +// aten::special_log_ndtr.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & special_log_ndtr_outf(const at::Tensor & self, at::Tensor & out) { + return at::_ops::special_log_ndtr_out::call(self, out); +} + +} diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/special_shifted_chebyshev_polynomial_v_compositeimplicitautograd_dispatch.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/special_shifted_chebyshev_polynomial_v_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..ae5e202ed15edc7b6ca4ec2a4c57ff79d6c67dfb --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/special_shifted_chebyshev_polynomial_v_compositeimplicitautograd_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 compositeimplicitautograd { + +TORCH_API at::Tensor special_shifted_chebyshev_polynomial_v(const at::Scalar & x, const at::Tensor & n); +TORCH_API at::Tensor & special_shifted_chebyshev_polynomial_v_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n); +TORCH_API at::Tensor & special_shifted_chebyshev_polynomial_v_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out); +TORCH_API at::Tensor special_shifted_chebyshev_polynomial_v(const at::Tensor & x, const at::Scalar & n); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/special_zeta.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/special_zeta.h new file mode 100644 index 0000000000000000000000000000000000000000..84e6f5814d887ae7cb3e460585e7dc26d64658aa --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/special_zeta.h @@ -0,0 +1,67 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::special_zeta(Tensor self, Tensor other) -> Tensor +inline at::Tensor special_zeta(const at::Tensor & self, const at::Tensor & other) { + return at::_ops::special_zeta::call(self, other); +} + +// aten::special_zeta.self_scalar(Scalar self, Tensor other) -> Tensor +inline at::Tensor special_zeta(const at::Scalar & self, const at::Tensor & other) { + return at::_ops::special_zeta_self_scalar::call(self, other); +} + +// aten::special_zeta.other_scalar(Tensor self, Scalar other) -> Tensor +inline at::Tensor special_zeta(const at::Tensor & self, const at::Scalar & other) { + return at::_ops::special_zeta_other_scalar::call(self, other); +} + +// aten::special_zeta.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & special_zeta_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { + return at::_ops::special_zeta_out::call(self, other, out); +} +// aten::special_zeta.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & special_zeta_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { + return at::_ops::special_zeta_out::call(self, other, out); +} + +// aten::special_zeta.self_scalar_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & special_zeta_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other) { + return at::_ops::special_zeta_self_scalar_out::call(self, other, out); +} +// aten::special_zeta.self_scalar_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & special_zeta_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) { + return at::_ops::special_zeta_self_scalar_out::call(self, other, out); +} + +// aten::special_zeta.other_scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & special_zeta_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) { + return at::_ops::special_zeta_other_scalar_out::call(self, other, out); +} +// aten::special_zeta.other_scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & special_zeta_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { + return at::_ops::special_zeta_other_scalar_out::call(self, other, out); +} + +} diff --git a/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/to_padded_tensor.h b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/to_padded_tensor.h new file mode 100644 index 0000000000000000000000000000000000000000..21f2d6f7aa1e48b28275340948e0a77fc0590a5a --- /dev/null +++ b/wemm/lib/python3.10/site-packages/torch/include/ATen/ops/to_padded_tensor.h @@ -0,0 +1,83 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +namespace symint { + template ::value>> + at::Tensor to_padded_tensor(const at::Tensor & self, double padding, at::OptionalIntArrayRef output_size=c10::nullopt) { + return at::_ops::to_padded_tensor::call(self, padding, output_size.has_value() ? c10::make_optional(c10::fromIntArrayRefSlow(*output_size)) : c10::nullopt); + } +} + +namespace symint { + template ::value>> + at::Tensor to_padded_tensor(const at::Tensor & self, double padding, at::OptionalSymIntArrayRef output_size=c10::nullopt) { + return at::_ops::to_padded_tensor::call(self, padding, output_size); + } +} + +// aten::to_padded_tensor.out(Tensor self, float padding, SymInt[]? output_size=None, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & to_padded_tensor_out(at::Tensor & out, const at::Tensor & self, double padding, at::OptionalIntArrayRef output_size=c10::nullopt) { + return at::_ops::to_padded_tensor_out::call(self, padding, output_size.has_value() ? c10::make_optional(c10::fromIntArrayRefSlow(*output_size)) : c10::nullopt, out); +} +namespace symint { + template ::value>> + at::Tensor & to_padded_tensor_out(at::Tensor & out, const at::Tensor & self, double padding, at::OptionalIntArrayRef output_size=c10::nullopt) { + return at::_ops::to_padded_tensor_out::call(self, padding, output_size.has_value() ? c10::make_optional(c10::fromIntArrayRefSlow(*output_size)) : c10::nullopt, out); + } +} + +// aten::to_padded_tensor.out(Tensor self, float padding, SymInt[]? output_size=None, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & to_padded_tensor_outf(const at::Tensor & self, double padding, at::OptionalIntArrayRef output_size, at::Tensor & out) { + return at::_ops::to_padded_tensor_out::call(self, padding, output_size.has_value() ? c10::make_optional(c10::fromIntArrayRefSlow(*output_size)) : c10::nullopt, out); +} +namespace symint { + template ::value>> + at::Tensor & to_padded_tensor_outf(const at::Tensor & self, double padding, at::OptionalIntArrayRef output_size, at::Tensor & out) { + return at::_ops::to_padded_tensor_out::call(self, padding, output_size.has_value() ? c10::make_optional(c10::fromIntArrayRefSlow(*output_size)) : c10::nullopt, out); + } +} + +// aten::to_padded_tensor.out(Tensor self, float padding, SymInt[]? output_size=None, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & to_padded_tensor_symint_out(at::Tensor & out, const at::Tensor & self, double padding, at::OptionalSymIntArrayRef output_size=c10::nullopt) { + return at::_ops::to_padded_tensor_out::call(self, padding, output_size, out); +} +namespace symint { + template ::value>> + at::Tensor & to_padded_tensor_out(at::Tensor & out, const at::Tensor & self, double padding, at::OptionalSymIntArrayRef output_size=c10::nullopt) { + return at::_ops::to_padded_tensor_out::call(self, padding, output_size, out); + } +} + +// aten::to_padded_tensor.out(Tensor self, float padding, SymInt[]? output_size=None, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & to_padded_tensor_symint_outf(const at::Tensor & self, double padding, at::OptionalSymIntArrayRef output_size, at::Tensor & out) { + return at::_ops::to_padded_tensor_out::call(self, padding, output_size, out); +} +namespace symint { + template ::value>> + at::Tensor & to_padded_tensor_outf(const at::Tensor & self, double padding, at::OptionalSymIntArrayRef output_size, at::Tensor & out) { + return at::_ops::to_padded_tensor_out::call(self, padding, output_size, out); + } +} + +}