diff --git a/.reuse/dep5 b/.reuse/dep5 index 4d4b4dddb2..59b92dd2b8 100644 --- a/.reuse/dep5 +++ b/.reuse/dep5 @@ -35,7 +35,7 @@ Files: source/elements/oneDAL/source/*.cpp Copyright: 2020 Intel Corporation License: MIT -Files: source/elements/oneMKL/source/domains/equations/*.png source/elements/oneMKL/source/domains/equations/*.gif source/elements/oneMKL/source/domains/equations/*.jpg +Files: source/elements/oneMath/source/domains/equations/*.png source/elements/oneMath/source/domains/equations/*.gif source/elements/oneMath/source/domains/equations/*.jpg Copyright: 2020 Intel Corporation License: CC-BY-4.0 diff --git a/doc/versioning.rst b/doc/versioning.rst index 2810ef3720..75757fb8c4 100644 --- a/doc/versioning.rst +++ b/doc/versioning.rst @@ -7,7 +7,7 @@ Specification versioning ======================== This document describes the versioning of the specification for oneAPI -elements (e.g. oneMKL, oneVPL) and for oneAPI, which includes all the +elements (e.g. oneMath, oneVPL) and for oneAPI, which includes all the elements. Specification versioning is independent of oneAPI product versioning. diff --git a/roadmap.rst b/roadmap.rst index c29be2ffa6..763ae6aff5 100644 --- a/roadmap.rst +++ b/roadmap.rst @@ -267,7 +267,7 @@ feedback. - Future - Content? -- oneMKL +- oneMath - New - Future @@ -342,7 +342,7 @@ Date Milestone - 80% content -- oneMKL +- oneMath - USM support - Skeleton of spec, breadown by domain @@ -412,7 +412,7 @@ Date Milestone - Updates deferred to 0.8.5_ -- oneMKL +- oneMath - All domains complete - Finalized BLAS, LAPACK domains @@ -497,7 +497,7 @@ Elements - oneVPL -- oneMKL +- oneMath - finalize FFT, sparse BLAS, RNG, and VM domains diff --git a/scripts/oneapi.py b/scripts/oneapi.py index ca4d1ab103..a1eb8775dd 100644 --- a/scripts/oneapi.py +++ b/scripts/oneapi.py @@ -251,7 +251,7 @@ def sort_words(root, target=None): dirs = [ 'oneCCL', 'oneDAL', - 'oneMKL', + 'oneMath', 'oneTBB', 'oneDPL', 'oneDNN', diff --git a/source/architecture.rst b/source/architecture.rst index 8fb6d19054..94b2da27ce 100644 --- a/source/architecture.rst +++ b/source/architecture.rst @@ -89,7 +89,7 @@ API Programming Example API programming requires the programmer to specify the target device and the memory communication strategy. In the following example, we call the -oneMKL matrix multiply routine, GEMM. We are writing in SYCL and +oneMath matrix multiply routine, GEMM. We are writing in SYCL and omitting irrelevant details. We create a queue initialized with a *gpu_selector* to specify that we @@ -117,7 +117,7 @@ Otherwise this is the standard GEMM C++ interface. buffer b{B, range<1>{N*P}}; buffer c{C, range<1>{M*P}}; - mkl::transpose nT = mkl::transpose::nontrans; + math::transpose nT = math::transpose::nontrans; // Syntax // void gemm(queue &exec_queue, transpose transa, transpose transb, // int64_t m, int64_t n, int64_t k, T alpha, @@ -125,7 +125,7 @@ Otherwise this is the standard GEMM C++ interface. // buffer &b, int64_t ldb, T beta, // buffer &c, int64_t ldc); // call gemm - mkl::blas::gemm(q, nT, nT, M, P, N, 1.0, a, M, b, N, 0.0, c, M); + math::blas::gemm(q, nT, nT, M, P, N, 1.0, a, M, b, N, 0.0, c, M); } // when we exit the block, the buffer destructor will write result back to C. diff --git a/source/conf/common_conf.py b/source/conf/common_conf.py index 51f3938f38..2c31126c03 100644 --- a/source/conf/common_conf.py +++ b/source/conf/common_conf.py @@ -68,8 +68,8 @@ .. |l0_full_name| replace:: oneAPI Level Zero .. |tbb_full_name| replace:: oneAPI Threading Building Blocks .. |tbb_version| replace:: $oneapi_version -.. |mkl_full_name| replace:: oneAPI Math Kernel Library -.. |mkl_version| replace:: $oneapi_version +.. |onemath_full_name| replace:: oneAPI Math Library +.. |onemath_version| replace:: $oneapi_version .. include:: .. |regsup| replace:: :supsub:`reg` .. |intel_r| replace:: Intel\ :supsub:`reg` diff --git a/source/elements/element_list.rst b/source/elements/element_list.rst index 50c982545c..da8c8e9059 100644 --- a/source/elements/element_list.rst +++ b/source/elements/element_list.rst @@ -12,5 +12,5 @@ - :ref:`oneDAL-section`: Algorithms for accelerated data science - :ref:`oneTBB-section`: Library for adding thread-based parallelism to complex applications on multiprocessors -- :ref:`oneMKL-section`: High performance math routines for science, +- :ref:`oneMath-section`: High performance math routines for science, engineering, and financial applications diff --git a/source/elements/oneMKL/source/architecture/architecture.rst b/source/elements/oneMKL/source/architecture/architecture.rst deleted file mode 100644 index 2ea254c0e8..0000000000 --- a/source/elements/oneMKL/source/architecture/architecture.rst +++ /dev/null @@ -1,23 +0,0 @@ -.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation -.. -.. SPDX-License-Identifier: CC-BY-4.0 - -.. _onemkl_architecture: - -oneMKL Architecture -==================== - -The oneMKL element of oneAPI has several general assumptions, requirements and recommendations for all domains contained therein. These will be addressed in this architecture section. -In particular, DPC++ allows for a great control over the execution of kernels on the various devices. We discuss the supported execution models of oneMKL APIs in :ref:`onemkl_execution_model`. -A discussion of how data is stored and passed in and out of the APIs is addressed in :ref:`onemkl_memory_model`. -The general structure and design of oneMKL APIs including namespaces and common data types are expressed in :ref:`onemkl_api_design`. -The exceptions and error handling are described in :ref:`onemkl_exceptions`. -Finally all the other necessary aspects related to oneMKL architecture can be found in :ref:`onemkl_arch_other` including versioning and discussion of pre and post conditions. -Other nonessential, but useful aspects of the oneMKL architecture and design may also be found in the :ref:`onemkl_appendix`. - - -.. include:: execution_model.inc.rst -.. include:: memory_model.inc.rst -.. include:: api_design.inc.rst -.. include:: exceptions.inc.rst -.. include:: other_architecture.inc.rst diff --git a/source/elements/oneMKL/source/architecture/exceptions.inc.rst b/source/elements/oneMKL/source/architecture/exceptions.inc.rst deleted file mode 100644 index e896badd0e..0000000000 --- a/source/elements/oneMKL/source/architecture/exceptions.inc.rst +++ /dev/null @@ -1,81 +0,0 @@ -.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation -.. -.. SPDX-License-Identifier: CC-BY-4.0 - -.. _onemkl_exceptions: - -Exceptions and Error Handling ------------------------------- - -oneMKL error handling relies on the mechanism of C++ exceptions. Should error occur, it will be propagated at the point of a function call where it is caught using standard C++ error handling mechanism. - -.. _onemkl_exception_classification: - -Exception classification -++++++++++++++++++++++++ - -Exception classification in oneMKL is aligned with C++ Standard Library classification. oneMKL introduces class that defines the base class in the hierarchy of oneMKL exception classes. All oneMKL routines throw exceptions inherited from this base class. -In the hierarchy of oneMKL exceptions, ``oneapi::mkl::exception`` is the base class inherited from ``std::exception`` class. All other oneMKL exception classes are derived from this base class. - -This specification does not require implementations to perform error-checking. However, if an implementation does provide error-checking, it shall use the following exception classes. Additional implementation-specific exception classes can be used for exceptional conditions not fitting any of these classes. - -.. _onemkl_common_exceptions: - -Common exceptions -***************** - -.. csv-table:: - :header: "Exception class", "Description" - :widths: 40, 60 - - ".. _onemkl_exception: - - ``oneapi::mkl::exception``", "Reports general unspecified problem" - ".. _onemkl_exception_unsupported_device: - - ``oneapi::mkl::unsupported_device``", "Reports a problem when the routine is not supported on a specific device" - ".. _onemkl_exception_host_bad_alloc: - - ``oneapi::mkl::host_bad_alloc``", "Reports a problem that occurred during memory allocation on the host" - ".. _onemkl_exception_device_bad_alloc: - - ``oneapi::mkl::device_bad_alloc``", "Reports a problem that occurred during memory allocation on a specific device" - ".. _onemkl_exception_unimplemented: - - ``oneapi::mkl::unimplemented``", "Reports a problem when a specific routine has not been implemented for the specified parameters" - ".. _onemkl_exception_invalid_argument: - - ``oneapi::mkl::invalid_argument``", "Reports problem when arguments to the routine were rejected" - ".. _onemkl_exception_uninitialized: - - ``oneapi::mkl::uninitialized``", "Reports problem when a handle (descriptor) has not been initialized" - ".. _onemkl_exception_computation_error: - - ``oneapi::mkl::computation_error``", "Reports any computation errors that have occurred inside a oneMKL routine" - ".. _onemkl_exception_batch_error: - - ``oneapi::mkl::batch_error``", "Reports errors that have occurred inside a batch oneMKL routine" - - -.. _onemkl_lapack_specific_exceptions: - -LAPACK specific exceptions -************************** - -.. csv-table:: - :header: "Exception class", "Description" - :widths: 40, 60 - - ".. _onemkl_lapack_exception: - - ``oneapi::mkl::lapack::exception``", "Base class for all LAPACK exceptions providing access to info code familiar to users of conventional LAPACK API. All LAPACK related exceptions can be handled with catch block for this class." - ".. _onemkl_lapack_exception_invalid_argument: - - ``oneapi::mkl::lapack::invalid_argument``", "Reports errors when arguments provided to the LAPACK subroutine are inconsistent or do not match expected values. Class extends base ``oneapi::mkl::invalid_argument`` with ability to access conventional status info code." - ".. _onemkl_lapack_exception_computation_error: - - ``oneapi::mkl::lapack::computation_error``", "Reports computation errors that have occurred during call to LAPACK subroutine. Class extends base ``oneapi::mkl::computation_error`` with ability to access conventional status info code familiar to LAPACK users." - ".. _onemkl_lapack_exception_batch_error: - - ``oneapi::mkl::lapack::batch_error``", "Reports errors that have occurred during batch LAPACK computations. Class extends base ``oneapi::mkl::batch_error`` with ability to access individual exception objects for each of the issues observed in a batch and an info code. The info code contains the number of errors that occurred in a batch. Positions of problems in a supplied batch that experienced issues during computations can be retrieved with `ids()` method, and list of particular exceptions can be obtained with `exceptions()` method of the exception object. Possible exceptions for a batch are documented for corresponding non-batch API." - diff --git a/source/elements/oneMKL/source/architecture/execution_model.inc.rst b/source/elements/oneMKL/source/architecture/execution_model.inc.rst deleted file mode 100644 index d15c14103c..0000000000 --- a/source/elements/oneMKL/source/architecture/execution_model.inc.rst +++ /dev/null @@ -1,91 +0,0 @@ -.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation -.. -.. SPDX-License-Identifier: CC-BY-4.0 - -.. _onemkl_execution_model: - -Execution Model ---------------- - -This section describes the execution environment common to all oneMKL functionality. The execution environment includes how data is provided to computational routines in :ref:`onemkl_queues`, support for several devices in :ref:`onemkl_device_usage`, synchronous and asynchronous execution models in :ref:`onemkl_asynchronous_synchronous_execution` and :ref:`onemkl_host_thread_safety`. - -.. _onemkl_queues: - -Use of Queues -+++++++++++++ - -The ``sycl::queue`` defined in the oneAPI DPC++ specification is used to specify the device and features enabled on that device on which a task will be enqueued. There are two forms of computational routines in oneMKL: class based :ref:`onemkl_member_functions` and standalone :ref:`onemkl_nonmember_functions`. As these may interact with the ``sycl::queue`` in different ways, we provide a section for each one to describe assumptions. - - -.. _onemkl_nonmember_functions: - -Non-Member Functions -******************** - -Each oneMKL non-member computational routine takes a ``sycl::queue`` reference as its first parameter:: - - mkl::domain::routine(sycl::queue &q, ...); - -All computation performed by the routine shall be done on the hardware device(s) associated with this queue, with possible aid from the host, unless otherwise specified. -In the case of an ordered queue, all computation shall also be ordered with respect to other kernels as if enqueued on that queue. - -A particular oneMKL implementation may not support the execution of a given oneMKL routine on the specified device(s). In this case, the implementation may either perform the computation on the host or throw an exception. See :ref:`onemkl_exceptions` for the possible exceptions. - - -.. _onemkl_member_functions: - -Member Functions -**************** - -oneMKL class-based APIs, such as those in the RNG and DFT domains, require a ``sycl::queue`` as an argument to the constructor or another setup routine. -The execution requirements for computational routines from the previous section also apply to computational class methods. - -.. _onemkl_device_usage: - -Device Usage -++++++++++++ - -oneMKL itself does not currently provide any interfaces for controlling device usage: for instance, controlling the number of cores used on the CPU, or the number of execution units on a GPU. However, such functionality may be available by partitioning a ``sycl::device`` instance into subdevices, when supported by the device. - -When given a queue associated with such a subdevice, a oneMKL implementation shall only perform computation on that subdevice. - -.. _onemkl_asynchronous_synchronous_execution: - -Asynchronous Execution -++++++++++++++++++++++ -The oneMKL API is designed to allow asynchronous execution of computational routines, to facilitate concurrent usage of multiple devices in the system. Each computational routine enqueues work to be performed on the selected device, and may (but is not required to) return before execution completes. - -Hence, it is the calling application's responsibility to ensure that any inputs are valid until computation is complete, and likewise to wait for computation completion before reading any outputs. This can be done automatically when using DPC++ buffers, or manually when using Unified Shared Memory (USM) pointers, as described in the sections below. - -Unless otherwise specified, asynchronous execution is *allowed*, but not *guaranteed*, by any oneMKL computational routine, and may vary between implementations and/or versions. oneMKL implementations must clearly document whether execution is guaranteed to be asynchronous for each supported routine. Regardless, calling applications shall not launch any oneMKL computational routine with a dependency on a future oneMKL API call, even if this computational routine executes asynchronously (i.e. a oneMKL implementation may assume no antidependencies are present). This guarantee allows oneMKL implementations to reserve resources for execution without risking deadlock. - -.. _onemkl_synchronization_with_buffers: - -Synchronization When Using Buffers -*********************************** - -``sycl::buffer`` objects automatically manage synchronization between kernel launches linked by a data dependency (either read-after-write, write-after-write, or write-after-read). - -oneMKL routines are not required to perform any additional synchronization of ``sycl::buffer`` arguments. - -.. _onemkl_synchronization_with_usm: - -Synchronization When Using USM APIs -*********************************** - -When USM pointers are used as input to, or output from, a oneMKL routine, it becomes the calling application's responsibility to manage possible asynchronicity. - -To help the calling application, all oneMKL routines with at least one USM pointer argument also take an optional reference to a list of *input events*, of type ``std::vector``, and have a return value of type ``sycl::event`` representing computation completion:: - - sycl::event mkl::domain::routine(..., std::vector &in_events = {}); - -The routine shall ensure that all input events (if the list is present and non-empty) have occurred before any USM pointers are accessed. Likewise, the routine's output event shall not be complete until the routine has finished accessing all USM pointer arguments. - -For class methods, "argument" includes any USM pointers previously provided to the object via the class constructor or other class methods. - -.. _onemkl_host_thread_safety: - -Host Thread Safety -++++++++++++++++++ - -All oneMKL member and non-member functions shall be *host thread safe*. That is, they may be safely called simultaneously from concurrent host threads. However, oneMKL objects in class-based APIs may not be shared between concurrent host threads unless otherwise specified. diff --git a/source/elements/oneMKL/source/architecture/memory_model.inc.rst b/source/elements/oneMKL/source/architecture/memory_model.inc.rst deleted file mode 100644 index 34693ad64c..0000000000 --- a/source/elements/oneMKL/source/architecture/memory_model.inc.rst +++ /dev/null @@ -1,34 +0,0 @@ -.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation -.. -.. SPDX-License-Identifier: CC-BY-4.0 - -.. _onemkl_memory_model: - -Memory Model -------------- - -The oneMKL memory model shall follow directly from the oneAPI memory model. Mainly, oneMKL shall support two modes of encapsulating data for consumption on the device: the buffer memory abstraction model and the pointer-based memory model using Unified Shared Memory (USM). These two paradigms shall also support both synchronous and asynchronous execution models as described in :ref:`onemkl_asynchronous_synchronous_execution`. - - -.. _onemkl_buffers: - -The Buffer Memory Model -+++++++++++++++++++++++ - -The SYCL 1.2.1 specification defines the buffer container templated on the provided data type which encapsulates the data in a SYCL application across both host and devices. It provides the concept of accessors as the mechanism to access the buffer data with different modes to read and or write into that data. These accessors allow SYCL to create and manage the data dependencies in the SYCL graph that order the kernel executions. With the buffer model, all data movement is handled by the SYCL runtime supporting both synchronous and asynchronous execution. - -oneMKL provides APIs where buffers (in particular 1D buffers, ``sycl::buffer``) contain the memory for all non scalar input and output data arguments. See :ref:`onemkl_synchronization_with_buffers` for details on how oneMKL routines manage any data dependencies with buffer arguments. Any higher dimensional buffer must be converted to a 1D buffer prior to use in oneMKL APIs, e.g., via ``buffer::reinterpret``. - - - -.. _onemkl_usm: - -Unified Shared Memory Model -+++++++++++++++++++++++++++ - -While the buffer model is powerful and elegantly expresses data dependencies, it can be a burden for programmers to replace all pointers and arrays by buffers in their C++ applications. DPC++ also provides pointer-based addressing for device-accessible data, using the Unified Shared Memory (USM) model. Correspondingly, oneMKL provides USM APIs in which non-scalar input and output data arguments are passed by USM pointer. - -USM devices and system configurations vary in their ability to share data between devices and between a device and the host. oneMKL implementations may only assume that user-provided USM pointers are accessible by the device associated with the user-provided queue. In particular, an implementation must not assume that USM pointers can be accessed by any other device, or by the host, without querying the DPC++ runtime. An implementation must accept any device-accessible USM pointer regardless of how it was created (`sycl::malloc_device`, `sycl::malloc_shared`, etc.). - -Unlike buffers, USM pointers cannot automatically manage data dependencies between kernels. Users may use in-order queues to ensure ordered execution, or explicitly manage dependencies with ``sycl::event`` objects. To support the second use case, oneMKL USM APIs accept input events (prerequisites before computation can begin) and return an output event (indicating computation is complete). See :ref:`onemkl_synchronization_with_usm` for details. - diff --git a/source/elements/oneMKL/source/domains/random_number_generators.inc.rst b/source/elements/oneMKL/source/domains/random_number_generators.inc.rst deleted file mode 100644 index 736cb4bab1..0000000000 --- a/source/elements/oneMKL/source/domains/random_number_generators.inc.rst +++ /dev/null @@ -1,17 +0,0 @@ -.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation -.. -.. SPDX-License-Identifier: CC-BY-4.0 - -.. _onemkl_rng: - -Random Number Generators -------------------------- - -The oneAPI Math Kernel Library Random Number Generators provides a :ref:`set of routines ` implementing commonly -used :ref:`pseudorandom, quasi-random, and non-deterministic generators ` -with :ref:`continuous and discrete distributions `. - -.. toctree:: - :hidden: - - rng/onemkl-rng-overview.rst \ No newline at end of file diff --git a/source/elements/oneMKL/source/domains/stats.inc.rst b/source/elements/oneMKL/source/domains/stats.inc.rst deleted file mode 100755 index 3b953cab84..0000000000 --- a/source/elements/oneMKL/source/domains/stats.inc.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation -.. -.. SPDX-License-Identifier: CC-BY-4.0 - -.. _onemkl_stats: - -Summary Statistics -------------------- - -The oneMKL provides a set of :ref:`Summary Statistics routines ` that compute basic statistical estimates for single and double precision multi-dimensional datasets. - -.. toctree:: - :hidden: - - stats/onemkl_stats_overview.rst \ No newline at end of file diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_routines.rst b/source/elements/oneMKL/source/domains/stats/onemkl_stats_routines.rst deleted file mode 100755 index 4ac38578ea..0000000000 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_routines.rst +++ /dev/null @@ -1,76 +0,0 @@ -.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation -.. -.. SPDX-License-Identifier: CC-BY-4.0 - -.. _onemkl_stats_routines: - -Summary Statistics Routines -=========================== - -The oneMKL Summary Statistics routines calculate next estimates: - -.. container:: - - .. container:: tablenoborder - - .. list-table:: - :header-rows: 1 - - * - Routine - - Description - * - :ref:`onemkl_stats_raw_sum` - - Raw sums up to the fourth order - * - :ref:`onemkl_stats_central_sum` - - Central sums up to the fourth order - * - :ref:`onemkl_stats_central_sum_user_mean` - - Central sums up to the fourth order with provided mean - * - :ref:`onemkl_stats_mean` - - Mean value - * - :ref:`onemkl_stats_raw_moment` - - Raw moments up to the fourth order - * - :ref:`onemkl_stats_central_moment` - - Central moments up to the fourth order - * - :ref:`onemkl_stats_central_moment_user_mean` - - Central moments up to the fourth order with provided mean - * - :ref:`onemkl_stats_variation` - - Variation coefficient - * - :ref:`onemkl_stats_variation_user_mean` - - Variation coefficient with provided mean - * - :ref:`onemkl_stats_skewness` - - Skewness value - * - :ref:`onemkl_stats_skewness_user_mean` - - Skewness value with provided mean - * - :ref:`onemkl_stats_kurtosis` - - Kurtosis value - * - :ref:`onemkl_stats_kurtosis_user_mean` - - Kurtosis value with provided mean - * - :ref:`onemkl_stats_min` - - Min value - * - :ref:`onemkl_stats_max` - - Max value - * - :ref:`onemkl_stats_min_max` - - Min and max values -   - **Parent topic:** :ref:`onemkl_stats` - - - -.. toctree:: - :hidden: - - onemkl_stats_raw_sum - onemkl_stats_central_sum - onemkl_stats_central_sum_user_mean - onemkl_stats_mean - onemkl_stats_raw_moment - onemkl_stats_central_moment - onemkl_stats_central_moment_user_mean - onemkl_stats_variation - onemkl_stats_variation_user_mean - onemkl_stats_skewness - onemkl_stats_skewness_user_mean - onemkl_stats_kurtosis - onemkl_stats_kurtosis_user_mean - onemkl_stats_min - onemkl_stats_max - onemkl_stats_min_max \ No newline at end of file diff --git a/source/elements/oneMKL/source/index.rst b/source/elements/oneMKL/source/index.rst deleted file mode 100644 index 2ca635aa05..0000000000 --- a/source/elements/oneMKL/source/index.rst +++ /dev/null @@ -1,24 +0,0 @@ -.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation -.. -.. SPDX-License-Identifier: CC-BY-4.0 - -.. _oneMKL-section: - -====== -oneMKL -====== - -The |mkl_full_name| (oneMKL) defines a set of fundamental mathematical routines for use in high-performance computing and other applications. As part of oneAPI, oneMKL is designed to allow execution on a wide variety of computational devices: CPUs, GPUs, FPGAs, and other accelerators. The functionality is subdivided into several domains: dense linear algebra, sparse linear algebra, discrete Fourier transforms, random number generators and vector math. - - -The general assumptions, design features and requirements for the oneMKL library and host-to-device computational routines will be described in :ref:`onemkl_architecture`. -The individual domains and their APIs are described in :ref:`onemkl_domains`. -Other design considerations that are not necessarily part of the oneMKL specification but that are worth mentioning will be discussed in :ref:`onemkl_appendix`. - - -.. toctree:: - :maxdepth: 2 - - architecture/architecture.rst - domains/domains.rst - appendix/appendix.rst diff --git a/source/elements/oneMKL/source/appendix/acknowledgment.inc.rst b/source/elements/oneMath/source/appendix/acknowledgment.inc.rst similarity index 64% rename from source/elements/oneMKL/source/appendix/acknowledgment.inc.rst rename to source/elements/oneMath/source/appendix/acknowledgment.inc.rst index 1e3ea2e190..41677b3a7f 100644 --- a/source/elements/oneMKL/source/appendix/acknowledgment.inc.rst +++ b/source/elements/oneMath/source/appendix/acknowledgment.inc.rst @@ -2,10 +2,10 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_acknowledgment: +.. _onemath_acknowledgment: Acknowledgment --------------- -The oneMKL `Technical Advisory Board `__ members +The oneMath `Technical Advisory Board `__ members provided valuable feedback to the specification and are thanked for their contributions. diff --git a/source/elements/oneMKL/source/appendix/appendix.rst b/source/elements/oneMath/source/appendix/appendix.rst similarity index 83% rename from source/elements/oneMKL/source/appendix/appendix.rst rename to source/elements/oneMath/source/appendix/appendix.rst index bc25618809..d5e673d2e1 100644 --- a/source/elements/oneMKL/source/appendix/appendix.rst +++ b/source/elements/oneMath/source/appendix/appendix.rst @@ -2,9 +2,9 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_appendix: +.. _onemath_appendix: -oneMKL Appendix +oneMath Appendix ================ .. include:: future_considerations.inc.rst diff --git a/source/elements/oneMKL/source/appendix/future_considerations.inc.rst b/source/elements/oneMath/source/appendix/future_considerations.inc.rst similarity index 93% rename from source/elements/oneMKL/source/appendix/future_considerations.inc.rst rename to source/elements/oneMath/source/appendix/future_considerations.inc.rst index e892ac216d..75e5dfd0f7 100644 --- a/source/elements/oneMKL/source/appendix/future_considerations.inc.rst +++ b/source/elements/oneMath/source/appendix/future_considerations.inc.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_future_considerations: +.. _onemath_future_considerations: Future considerations --------------------- diff --git a/source/elements/oneMKL/source/architecture/api_design.inc.rst b/source/elements/oneMath/source/architecture/api_design.inc.rst similarity index 64% rename from source/elements/oneMKL/source/architecture/api_design.inc.rst rename to source/elements/oneMath/source/architecture/api_design.inc.rst index 22077710ba..3bb755b875 100644 --- a/source/elements/oneMKL/source/architecture/api_design.inc.rst +++ b/source/elements/oneMath/source/architecture/api_design.inc.rst @@ -2,83 +2,83 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_api_design: +.. _onemath_api_design: API Design ----------- -This section discusses the general features of oneMKL API design. In particular, it covers the use of namespaces and data types from C++, from DPC++ and new ones introduced for oneMKL APIs. +This section discusses the general features of oneMath API design. In particular, it covers the use of namespaces and data types from C++, from DPC++ and new ones introduced for oneMath APIs. -.. _onemkl_namespaces: +.. _onemath_namespaces: -oneMKL namespaces +oneMath namespaces ++++++++++++++++++ -The oneMKL library uses C++ namespaces to organize routines by mathematical domain. All oneMKL objects and routines shall be contained within the ``oneapi::mkl`` base namespace. The individual oneMKL domains use a secondary namespace layer as follows: +The oneMath library uses C++ namespaces to organize routines by mathematical domain. All oneMath objects and routines shall be contained within the ``oneapi::math`` base namespace. The individual oneMath domains use a secondary namespace layer as follows: ======================== ======================================================================================================= -namespace oneMKL domain or content +namespace oneMath domain or content ======================== ======================================================================================================= -``oneapi::mkl`` oneMKL base namespace, contains general oneMKL data types, objects, exceptions and routines -``oneapi::mkl::blas`` Dense linear algebra routines from BLAS and BLAS like extensions. The oneapi::mkl::blas namespace should contain two namespaces column_major and row_major to support both matrix layouts. See :ref:`onemkl_blas` -``oneapi::mkl::lapack`` Dense linear algebra routines from LAPACK and LAPACK like extensions. See :ref:`onemkl_lapack` -``oneapi::mkl::sparse`` Sparse linear algebra routines from Sparse BLAS and Sparse Solvers. See :ref:`onemkl_sparse_linear_algebra` -``oneapi::mkl::dft`` Discrete Fourier Transforms. See :ref:`onemkl_dft` -``oneapi::mkl::rng`` Random number generator routines. See :ref:`onemkl_rng` -``oneapi::mkl::vm`` Vector mathematics routines, e.g. trigonometric, exponential functions acting on elements of a vector. See :ref:`onemkl_vm` -``oneapi::mkl::stats`` Routines that compute basic statistical estimates for single and double precision multi-dimensional datasets. See :ref:`onemkl_stats` +``oneapi::math`` oneMath base namespace, contains general oneMath data types, objects, exceptions and routines +``oneapi::math::blas`` Dense linear algebra routines from BLAS and BLAS like extensions. The oneapi::math::blas namespace should contain two namespaces column_major and row_major to support both matrix layouts. See :ref:`onemath_blas` +``oneapi::math::lapack`` Dense linear algebra routines from LAPACK and LAPACK like extensions. See :ref:`onemath_lapack` +``oneapi::math::sparse`` Sparse linear algebra routines from Sparse BLAS and Sparse Solvers. See :ref:`onemath_sparse_linear_algebra` +``oneapi::math::dft`` Discrete Fourier Transforms. See :ref:`onemath_dft` +``oneapi::math::rng`` Random number generator routines. See :ref:`onemath_rng` +``oneapi::math::vm`` Vector mathematics routines, e.g. trigonometric, exponential functions acting on elements of a vector. See :ref:`onemath_vm` +``oneapi::math::stats`` Routines that compute basic statistical estimates for single and double precision multi-dimensional datasets. See :ref:`onemath_stats` ======================== ======================================================================================================= .. note:: :name: Implementation Requirement - Inside each oneMKL domain, there are many routines, classes, enums and objects defined which constitute the breadth and scope of that oneMKL domain. - It is permitted for a library implementation of the oneMKL specification to implement either all, one or more than one of the domains in oneMKL. However, within an implementation of a specific domain, all relevant routines, classes, enums and objects (including those relevant enums and objects which live outside a particular domain in the general ``oneapi::mkl`` namespace must be both declared and defined in the library so that an application that uses that domain could build and link against that library implementation successfully. + Inside each oneMath domain, there are many routines, classes, enums and objects defined which constitute the breadth and scope of that oneMath domain. + It is permitted for a library implementation of the oneMath specification to implement either all, one or more than one of the domains in oneMath. However, within an implementation of a specific domain, all relevant routines, classes, enums and objects (including those relevant enums and objects which live outside a particular domain in the general ``oneapi::math`` namespace must be both declared and defined in the library so that an application that uses that domain could build and link against that library implementation successfully. - It is however acceptable to throw the runtime exception :ref:`oneapi::mkl::unimplemented` inside of the routines or class member functions in that domain that have not been fully implemented. - For instance, a library may choose to implement the oneMKL BLAS functionality and in particular may choose to implement only the :ref:`onemkl_blas_gemm` api for their library, in which case they must also include all the other blas namespaced routines and throw the :ref:`oneapi::mkl::unimplemented` exception inside all the others. + It is however acceptable to throw the runtime exception :ref:`oneapi::math::unimplemented` inside of the routines or class member functions in that domain that have not been fully implemented. + For instance, a library may choose to implement the oneMath BLAS functionality and in particular may choose to implement only the :ref:`onemath_blas_gemm` api for their library, in which case they must also include all the other blas namespaced routines and throw the :ref:`oneapi::math::unimplemented` exception inside all the others. In such a case, the implemented routines in such a library should be communicated clearly and easily understood by users of that library. -.. _onemkl_cpp_datatypes: +.. _onemath_cpp_datatypes: Standard C++ datatype usage +++++++++++++++++++++++++++ -oneMKL uses C++ STL data types for scalars where applicable: +oneMath uses C++ STL data types for scalars where applicable: * Integer scalars are C++ fixed-size integer types (``std::intN_t``, ``std::uintN_t``). * Complex numbers are represented by C++ ``std::complex`` types. -In general, scalar integer arguments to oneMKL routines are 64-bit integers (``std::int64_t`` or ``std::uint64_t``). Integer vectors and matrices may have varying bit widths, defined on a per-routine basis. +In general, scalar integer arguments to oneMath routines are 64-bit integers (``std::int64_t`` or ``std::uint64_t``). Integer vectors and matrices may have varying bit widths, defined on a per-routine basis. -.. _onemkl_dpcpp_datatypes: +.. _onemath_dpcpp_datatypes: DPC++ datatype usage ++++++++++++++++++++ -oneMKL uses the following DPC++ data types: +oneMath uses the following DPC++ data types: -* SYCL queue ``sycl::queue`` for scheduling kernels on a SYCL device. See :ref:`onemkl_queues` for more details. -* SYCL buffer ``sycl::buffer`` for buffer-based memory access. See :ref:`onemkl_buffers` for more details. -* Unified Shared Memory (USM) for pointer-based memory access. See :ref:`onemkl_usm` for more details. -* SYCL event ``sycl::event`` for output event synchronization in oneMKL routines with USM pointers. See :ref:`onemkl_synchronization_with_usm` for more details. -* Vector of SYCL events ``std::vector`` for input events synchronization in oneMKL routines with USM pointers. See :ref:`onemkl_synchronization_with_usm` for more details. +* SYCL queue ``sycl::queue`` for scheduling kernels on a SYCL device. See :ref:`onemath_queues` for more details. +* SYCL buffer ``sycl::buffer`` for buffer-based memory access. See :ref:`onemath_buffers` for more details. +* Unified Shared Memory (USM) for pointer-based memory access. See :ref:`onemath_usm` for more details. +* SYCL event ``sycl::event`` for output event synchronization in oneMath routines with USM pointers. See :ref:`onemath_synchronization_with_usm` for more details. +* Vector of SYCL events ``std::vector`` for input events synchronization in oneMath routines with USM pointers. See :ref:`onemath_synchronization_with_usm` for more details. .. note:: - The class ``sycl::vector_class`` has been removed from SYCL 2020 and the standard class ``std::vector`` should be used instead for vector of SYCL events in oneMKL routines with USM pointers + The class ``sycl::vector_class`` has been removed from SYCL 2020 and the standard class ``std::vector`` should be used instead for vector of SYCL events in oneMath routines with USM pointers -.. _onemkl_datatypes: +.. _onemath_datatypes: -oneMKL defined datatypes -++++++++++++++++++++++++ +oneMath defined datatypes ++++++++++++++++++++++++++ -oneMKL dense and sparse linear algebra routines use scoped enum types as type-safe replacements for the traditional character arguments used in C/Fortran implementations of BLAS and LAPACK. These types all belong to the ``oneapi::mkl`` namespace. +oneMath dense and sparse linear algebra routines use scoped enum types as type-safe replacements for the traditional character arguments used in C/Fortran implementations of BLAS and LAPACK. These types all belong to the ``oneapi::math`` namespace. Each enumeration value comes with two names: A single-character name (the traditional BLAS/LAPACK character) and a longer, more descriptive name. The two names are exactly equivalent and may be used interchangeably. - .. _onemkl_enum_transpose: + .. _onemath_enum_transpose: .. rubric:: transpose :name: transpose @@ -105,7 +105,7 @@ Each enumeration value comes with two names: A single-character name (the tradit - ``transpose::conjtrans`` - Perform Hermitian transpose (transpose and conjugate). Is the same as ``transpose::trans`` for real matrices. - .. _onemkl_enum_uplo: + .. _onemath_enum_uplo: .. rubric:: uplo :name: uplo @@ -133,7 +133,7 @@ Each enumeration value comes with two names: A single-character name (the tradit In both cases, elements that are not in the selected triangle are not accessed or updated. - .. _onemkl_enum_diag: + .. _onemath_enum_diag: .. rubric:: diag :name: diag @@ -157,7 +157,7 @@ Each enumeration value comes with two names: A single-character name (the tradit - ``diag::unit`` - The matrix is unit triangular (the diagonal entries are all 1's). The diagonal entries in the matrix data are not accessed. - .. _onemkl_enum_side: + .. _onemath_enum_side: .. rubric:: side :name: side @@ -182,7 +182,7 @@ Each enumeration value comes with two names: A single-character name (the tradit - ``side::right`` - The special form matrix is on the right in the multiplication. - .. _onemkl_enum_offset: + .. _onemath_enum_offset: .. rubric:: offset :name: offset @@ -210,7 +210,7 @@ Each enumeration value comes with two names: A single-character name (the tradit - ``offset::row`` - The offset to apply to the output matrix is a row offset, that is to say all the rows in the ``C_offset`` matrix are the same and given by the elements in the ``co`` array. - .. _onemkl_enum_index_base: + .. _onemath_enum_index_base: .. rubric:: index_base :name: index_base @@ -233,7 +233,7 @@ Each enumeration value comes with two names: A single-character name (the tradit - Index arrays for an input matrix are provided using one-based (Fortran style) index values. That is, indices start at 1. - .. _onemkl_enum_layout: + .. _onemath_enum_layout: .. rubric:: layout :name: layout @@ -260,6 +260,6 @@ Each enumeration value comes with two names: A single-character name (the tradit .. note:: - :ref:`onemkl_appendix` may contain other API design decisions or recommendations that may be of use to the general developer of oneMKL, but which may not necessarily be part of the oneMKL specification. + :ref:`onemath_appendix` may contain other API design decisions or recommendations that may be of use to the general developer of oneMath, but which may not necessarily be part of the oneMath specification. diff --git a/source/elements/oneMath/source/architecture/architecture.rst b/source/elements/oneMath/source/architecture/architecture.rst new file mode 100644 index 0000000000..64d76726ff --- /dev/null +++ b/source/elements/oneMath/source/architecture/architecture.rst @@ -0,0 +1,23 @@ +.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation +.. +.. SPDX-License-Identifier: CC-BY-4.0 + +.. _onemath_architecture: + +oneMath Architecture +==================== + +The oneMath element of oneAPI has several general assumptions, requirements and recommendations for all domains contained therein. These will be addressed in this architecture section. +In particular, DPC++ allows for a great control over the execution of kernels on the various devices. We discuss the supported execution models of oneMath APIs in :ref:`onemath_execution_model`. +A discussion of how data is stored and passed in and out of the APIs is addressed in :ref:`onemath_memory_model`. +The general structure and design of oneMath APIs including namespaces and common data types are expressed in :ref:`onemath_api_design`. +The exceptions and error handling are described in :ref:`onemath_exceptions`. +Finally all the other necessary aspects related to oneMath architecture can be found in :ref:`onemath_arch_other` including versioning and discussion of pre and post conditions. +Other nonessential, but useful aspects of the oneMath architecture and design may also be found in the :ref:`onemath_appendix`. + + +.. include:: execution_model.inc.rst +.. include:: memory_model.inc.rst +.. include:: api_design.inc.rst +.. include:: exceptions.inc.rst +.. include:: other_architecture.inc.rst diff --git a/source/elements/oneMath/source/architecture/exceptions.inc.rst b/source/elements/oneMath/source/architecture/exceptions.inc.rst new file mode 100644 index 0000000000..4d6ef9eea4 --- /dev/null +++ b/source/elements/oneMath/source/architecture/exceptions.inc.rst @@ -0,0 +1,81 @@ +.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation +.. +.. SPDX-License-Identifier: CC-BY-4.0 + +.. _onemath_exceptions: + +Exceptions and Error Handling +------------------------------ + +oneMath error handling relies on the mechanism of C++ exceptions. Should error occur, it will be propagated at the point of a function call where it is caught using standard C++ error handling mechanism. + +.. _onemath_exception_classification: + +Exception classification +++++++++++++++++++++++++ + +Exception classification in oneMath is aligned with C++ Standard Library classification. oneMath introduces class that defines the base class in the hierarchy of oneMath exception classes. All oneMath routines throw exceptions inherited from this base class. +In the hierarchy of oneMath exceptions, ``oneapi::math::exception`` is the base class inherited from ``std::exception`` class. All other oneMath exception classes are derived from this base class. + +This specification does not require implementations to perform error-checking. However, if an implementation does provide error-checking, it shall use the following exception classes. Additional implementation-specific exception classes can be used for exceptional conditions not fitting any of these classes. + +.. _onemath_common_exceptions: + +Common exceptions +***************** + +.. csv-table:: + :header: "Exception class", "Description" + :widths: 40, 60 + + ".. _onemath_exception: + + ``oneapi::math::exception``", "Reports general unspecified problem" + ".. _onemath_exception_unsupported_device: + + ``oneapi::math::unsupported_device``", "Reports a problem when the routine is not supported on a specific device" + ".. _onemath_exception_host_bad_alloc: + + ``oneapi::math::host_bad_alloc``", "Reports a problem that occurred during memory allocation on the host" + ".. _onemath_exception_device_bad_alloc: + + ``oneapi::math::device_bad_alloc``", "Reports a problem that occurred during memory allocation on a specific device" + ".. _onemath_exception_unimplemented: + + ``oneapi::math::unimplemented``", "Reports a problem when a specific routine has not been implemented for the specified parameters" + ".. _onemath_exception_invalid_argument: + + ``oneapi::math::invalid_argument``", "Reports problem when arguments to the routine were rejected" + ".. _onemath_exception_uninitialized: + + ``oneapi::math::uninitialized``", "Reports problem when a handle (descriptor) has not been initialized" + ".. _onemath_exception_computation_error: + + ``oneapi::math::computation_error``", "Reports any computation errors that have occurred inside a oneMath routine" + ".. _onemath_exception_batch_error: + + ``oneapi::math::batch_error``", "Reports errors that have occurred inside a batch oneMath routine" + + +.. _onemath_lapack_specific_exceptions: + +LAPACK specific exceptions +************************** + +.. csv-table:: + :header: "Exception class", "Description" + :widths: 40, 60 + + ".. _onemath_lapack_exception: + + ``oneapi::math::lapack::exception``", "Base class for all LAPACK exceptions providing access to info code familiar to users of conventional LAPACK API. All LAPACK related exceptions can be handled with catch block for this class." + ".. _onemath_lapack_exception_invalid_argument: + + ``oneapi::math::lapack::invalid_argument``", "Reports errors when arguments provided to the LAPACK subroutine are inconsistent or do not match expected values. Class extends base ``oneapi::math::invalid_argument`` with ability to access conventional status info code." + ".. _onemath_lapack_exception_computation_error: + + ``oneapi::math::lapack::computation_error``", "Reports computation errors that have occurred during call to LAPACK subroutine. Class extends base ``oneapi::math::computation_error`` with ability to access conventional status info code familiar to LAPACK users." + ".. _onemath_lapack_exception_batch_error: + + ``oneapi::math::lapack::batch_error``", "Reports errors that have occurred during batch LAPACK computations. Class extends base ``oneapi::math::batch_error`` with ability to access individual exception objects for each of the issues observed in a batch and an info code. The info code contains the number of errors that occurred in a batch. Positions of problems in a supplied batch that experienced issues during computations can be retrieved with `ids()` method, and list of particular exceptions can be obtained with `exceptions()` method of the exception object. Possible exceptions for a batch are documented for corresponding non-batch API." + diff --git a/source/elements/oneMath/source/architecture/execution_model.inc.rst b/source/elements/oneMath/source/architecture/execution_model.inc.rst new file mode 100644 index 0000000000..5c7671f6c1 --- /dev/null +++ b/source/elements/oneMath/source/architecture/execution_model.inc.rst @@ -0,0 +1,91 @@ +.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation +.. +.. SPDX-License-Identifier: CC-BY-4.0 + +.. _onemath_execution_model: + +Execution Model +--------------- + +This section describes the execution environment common to all oneMath functionality. The execution environment includes how data is provided to computational routines in :ref:`onemath_queues`, support for several devices in :ref:`onemath_device_usage`, synchronous and asynchronous execution models in :ref:`onemath_asynchronous_synchronous_execution` and :ref:`onemath_host_thread_safety`. + +.. _onemath_queues: + +Use of Queues ++++++++++++++ + +The ``sycl::queue`` defined in the oneAPI DPC++ specification is used to specify the device and features enabled on that device on which a task will be enqueued. There are two forms of computational routines in oneMath: class based :ref:`onemath_member_functions` and standalone :ref:`onemath_nonmember_functions`. As these may interact with the ``sycl::queue`` in different ways, we provide a section for each one to describe assumptions. + + +.. _onemath_nonmember_functions: + +Non-Member Functions +******************** + +Each oneMath non-member computational routine takes a ``sycl::queue`` reference as its first parameter:: + + math::domain::routine(sycl::queue &q, ...); + +All computation performed by the routine shall be done on the hardware device(s) associated with this queue, with possible aid from the host, unless otherwise specified. +In the case of an ordered queue, all computation shall also be ordered with respect to other kernels as if enqueued on that queue. + +A particular oneMath implementation may not support the execution of a given oneMath routine on the specified device(s). In this case, the implementation may either perform the computation on the host or throw an exception. See :ref:`onemath_exceptions` for the possible exceptions. + + +.. _onemath_member_functions: + +Member Functions +**************** + +oneMath class-based APIs, such as those in the RNG and DFT domains, require a ``sycl::queue`` as an argument to the constructor or another setup routine. +The execution requirements for computational routines from the previous section also apply to computational class methods. + +.. _onemath_device_usage: + +Device Usage +++++++++++++ + +oneMath itself does not currently provide any interfaces for controlling device usage: for instance, controlling the number of cores used on the CPU, or the number of execution units on a GPU. However, such functionality may be available by partitioning a ``sycl::device`` instance into subdevices, when supported by the device. + +When given a queue associated with such a subdevice, a oneMath implementation shall only perform computation on that subdevice. + +.. _onemath_asynchronous_synchronous_execution: + +Asynchronous Execution +++++++++++++++++++++++ +The oneMath API is designed to allow asynchronous execution of computational routines, to facilitate concurrent usage of multiple devices in the system. Each computational routine enqueues work to be performed on the selected device, and may (but is not required to) return before execution completes. + +Hence, it is the calling application's responsibility to ensure that any inputs are valid until computation is complete, and likewise to wait for computation completion before reading any outputs. This can be done automatically when using DPC++ buffers, or manually when using Unified Shared Memory (USM) pointers, as described in the sections below. + +Unless otherwise specified, asynchronous execution is *allowed*, but not *guaranteed*, by any oneMath computational routine, and may vary between implementations and/or versions. oneMath implementations must clearly document whether execution is guaranteed to be asynchronous for each supported routine. Regardless, calling applications shall not launch any oneMath computational routine with a dependency on a future oneMath API call, even if this computational routine executes asynchronously (i.e. a oneMath implementation may assume no antidependencies are present). This guarantee allows oneMath implementations to reserve resources for execution without risking deadlock. + +.. _onemath_synchronization_with_buffers: + +Synchronization When Using Buffers +*********************************** + +``sycl::buffer`` objects automatically manage synchronization between kernel launches linked by a data dependency (either read-after-write, write-after-write, or write-after-read). + +oneMath routines are not required to perform any additional synchronization of ``sycl::buffer`` arguments. + +.. _onemath_synchronization_with_usm: + +Synchronization When Using USM APIs +*********************************** + +When USM pointers are used as input to, or output from, a oneMath routine, it becomes the calling application's responsibility to manage possible asynchronicity. + +To help the calling application, all oneMath routines with at least one USM pointer argument also take an optional reference to a list of *input events*, of type ``std::vector``, and have a return value of type ``sycl::event`` representing computation completion:: + + sycl::event math::domain::routine(..., std::vector &in_events = {}); + +The routine shall ensure that all input events (if the list is present and non-empty) have occurred before any USM pointers are accessed. Likewise, the routine's output event shall not be complete until the routine has finished accessing all USM pointer arguments. + +For class methods, "argument" includes any USM pointers previously provided to the object via the class constructor or other class methods. + +.. _onemath_host_thread_safety: + +Host Thread Safety +++++++++++++++++++ + +All oneMath member and non-member functions shall be *host thread safe*. That is, they may be safely called simultaneously from concurrent host threads. However, oneMath objects in class-based APIs may not be shared between concurrent host threads unless otherwise specified. diff --git a/source/elements/oneMath/source/architecture/memory_model.inc.rst b/source/elements/oneMath/source/architecture/memory_model.inc.rst new file mode 100644 index 0000000000..cba1ebde37 --- /dev/null +++ b/source/elements/oneMath/source/architecture/memory_model.inc.rst @@ -0,0 +1,34 @@ +.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation +.. +.. SPDX-License-Identifier: CC-BY-4.0 + +.. _onemath_memory_model: + +Memory Model +------------- + +The oneMath memory model shall follow directly from the oneAPI memory model. Mainly, oneMath shall support two modes of encapsulating data for consumption on the device: the buffer memory abstraction model and the pointer-based memory model using Unified Shared Memory (USM). These two paradigms shall also support both synchronous and asynchronous execution models as described in :ref:`onemath_asynchronous_synchronous_execution`. + + +.. _onemath_buffers: + +The Buffer Memory Model ++++++++++++++++++++++++ + +The SYCL 1.2.1 specification defines the buffer container templated on the provided data type which encapsulates the data in a SYCL application across both host and devices. It provides the concept of accessors as the mechanism to access the buffer data with different modes to read and or write into that data. These accessors allow SYCL to create and manage the data dependencies in the SYCL graph that order the kernel executions. With the buffer model, all data movement is handled by the SYCL runtime supporting both synchronous and asynchronous execution. + +oneMath provides APIs where buffers (in particular 1D buffers, ``sycl::buffer``) contain the memory for all non scalar input and output data arguments. See :ref:`onemath_synchronization_with_buffers` for details on how oneMath routines manage any data dependencies with buffer arguments. Any higher dimensional buffer must be converted to a 1D buffer prior to use in oneMath APIs, e.g., via ``buffer::reinterpret``. + + + +.. _onemath_usm: + +Unified Shared Memory Model ++++++++++++++++++++++++++++ + +While the buffer model is powerful and elegantly expresses data dependencies, it can be a burden for programmers to replace all pointers and arrays by buffers in their C++ applications. DPC++ also provides pointer-based addressing for device-accessible data, using the Unified Shared Memory (USM) model. Correspondingly, oneMath provides USM APIs in which non-scalar input and output data arguments are passed by USM pointer. + +USM devices and system configurations vary in their ability to share data between devices and between a device and the host. oneMath implementations may only assume that user-provided USM pointers are accessible by the device associated with the user-provided queue. In particular, an implementation must not assume that USM pointers can be accessed by any other device, or by the host, without querying the DPC++ runtime. An implementation must accept any device-accessible USM pointer regardless of how it was created (`sycl::malloc_device`, `sycl::malloc_shared`, etc.). + +Unlike buffers, USM pointers cannot automatically manage data dependencies between kernels. Users may use in-order queues to ensure ordered execution, or explicitly manage dependencies with ``sycl::event`` objects. To support the second use case, oneMath USM APIs accept input events (prerequisites before computation can begin) and return an output event (indicating computation is complete). See :ref:`onemath_synchronization_with_usm` for details. + diff --git a/source/elements/oneMKL/source/architecture/other_architecture.inc.rst b/source/elements/oneMath/source/architecture/other_architecture.inc.rst similarity index 61% rename from source/elements/oneMKL/source/architecture/other_architecture.inc.rst rename to source/elements/oneMath/source/architecture/other_architecture.inc.rst index 9c5473803c..380ec7f410 100644 --- a/source/elements/oneMKL/source/architecture/other_architecture.inc.rst +++ b/source/elements/oneMath/source/architecture/other_architecture.inc.rst @@ -2,29 +2,29 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_arch_other: +.. _onemath_arch_other: Other Features ---------------- -This section covers all other features in the design of oneMKL architecture. +This section covers all other features in the design of oneMath architecture. -.. _onemkl_spec_current_version: +.. _onemath_spec_current_version: Specification Version and Compliance +++++++++++++++++++++++++++++++++++++++++++++ -Each oneMKL domain must define a preprocessor macro to represent the version of the specification that the implementation is compliant with. +Each oneMath domain must define a preprocessor macro to represent the version of the specification that the implementation is compliant with. The macros for each domain are listed as follows: - | ONEMKL_BLAS_SPEC_VERSION - | ONEMKL_LAPACK_SPEC_VERSION - | ONEMKL_SPBLAS_SPEC_VERSION - | ONEMKL_DFT_SPEC_VERSION - | ONEMKL_RNG_SPEC_VERSION - | ONEMKL_STATS_SPEC_VERSION - | ONEMKL_VM_SPEC_VERSION + | ONEMATH_BLAS_SPEC_VERSION + | ONEMATH_LAPACK_SPEC_VERSION + | ONEMATH_SPBLAS_SPEC_VERSION + | ONEMATH_DFT_SPEC_VERSION + | ONEMATH_RNG_SPEC_VERSION + | ONEMATH_STATS_SPEC_VERSION + | ONEMATH_VM_SPEC_VERSION The specification version can be created by appending all digits of the specification version in the format of . MINOR version always uses two digits. This version can be used to check the compatibility of the implementation with the specification version. Note that the revision is not included here because it reflects changes only for the specification document without affecting the implementation. If the implementation is not compliant with any release of the specification, then the macro must have a numerical value of `000`. @@ -39,21 +39,21 @@ Macro Example .. code-block:: c // For oneAPI 1.2 rev 1 - #define ONEMKL_BLAS_SPEC_VERSION 102 + #define ONEMATH_BLAS_SPEC_VERSION 102 // For oneAPI 1.2 rev 2 - #define ONEMKL_DFT_SPEC_VERSION 102 + #define ONEMATH_DFT_SPEC_VERSION 102 // For oneAPI 1.3 rev 1 - #define ONEMKL_VM_SPEC_VERSION 103 + #define ONEMATH_VM_SPEC_VERSION 103 Versioning details are defined here: https://github.com/uxlfoundation/oneAPI-spec/blob/main/doc/versioning.rst#provisional-versions -.. _onemkl_pre_post_conditions: +.. _onemath_pre_post_conditions: Pre/Post Condition Checking +++++++++++++++++++++++++++++++++++++++ -The individual oneMKL computational routines will define any preconditions and postconditions and will define in this specification any specific checks or verifications that should be enabled for all implementations. +The individual oneMath computational routines will define any preconditions and postconditions and will define in this specification any specific checks or verifications that should be enabled for all implementations. diff --git a/source/elements/oneMKL/source/conf.py b/source/elements/oneMath/source/conf.py similarity index 97% rename from source/elements/oneMKL/source/conf.py rename to source/elements/oneMath/source/conf.py index fcd29abe19..c316d6ae14 100644 --- a/source/elements/oneMKL/source/conf.py +++ b/source/elements/oneMath/source/conf.py @@ -21,7 +21,7 @@ from os.path import join -project = 'oneMKL' +project = 'oneMath' repo_root = join('..', '..', '..', '..') exec(open(join(repo_root, 'source', 'conf', 'common_conf.py')).read()) diff --git a/source/elements/oneMKL/source/domains/blas/asum.rst b/source/elements/oneMath/source/domains/blas/asum.rst similarity index 79% rename from source/elements/oneMKL/source/domains/blas/asum.rst rename to source/elements/oneMath/source/domains/blas/asum.rst index e18c4014e5..e3f0bea069 100644 --- a/source/elements/oneMKL/source/domains/blas/asum.rst +++ b/source/elements/oneMath/source/domains/blas/asum.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_asum: +.. _onemath_blas_asum: asum ==== Computes the sum of magnitudes of the vector elements. -.. _onemkl_blas_asum_description: +.. _onemath_blas_asum_description: .. rubric:: Description @@ -39,7 +39,7 @@ where ``x`` is a vector with ``n`` elements. * - ``std::complex`` - ``double`` -.. _onemkl_blas_asum_buffer: +.. _onemath_blas_asum_buffer: asum (Buffer Version) --------------------- @@ -48,7 +48,7 @@ asum (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void asum(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -57,7 +57,7 @@ asum (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void asum(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -97,22 +97,22 @@ asum (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_asum_usm: +.. _onemath_blas_asum_usm: asum (USM Version) ------------------ @@ -121,7 +121,7 @@ asum (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event asum(sycl::queue &queue, std::int64_t n, const T *x, @@ -131,7 +131,7 @@ asum (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event asum(sycl::queue &queue, std::int64_t n, const T *x, @@ -184,20 +184,20 @@ asum (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/axpby.rst b/source/elements/oneMath/source/domains/blas/axpby.rst similarity index 81% rename from source/elements/oneMKL/source/domains/blas/axpby.rst rename to source/elements/oneMath/source/domains/blas/axpby.rst index 8e499c1730..5fddcf2272 100644 --- a/source/elements/oneMKL/source/domains/blas/axpby.rst +++ b/source/elements/oneMath/source/domains/blas/axpby.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_axpby: +.. _onemath_blas_axpby: axpby ===== Computes a vector-scalar product added to a scaled-vector. -.. _onemkl_blas_axpby_description: +.. _onemath_blas_axpby_description: .. rubric:: Description @@ -32,7 +32,7 @@ where ``x`` and ``y`` are vectors of ``n`` elements and ``alpha`` and ``beta`` a * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_axpby_buffer: +.. _onemath_blas_axpby_buffer: axpby (Buffer Version) ---------------------- @@ -41,7 +41,7 @@ axpby (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void axpby(sycl::queue &queue, std::int64_t n, T alpha, @@ -51,7 +51,7 @@ axpby (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void axpby(sycl::queue &queue, std::int64_t n, T alpha, @@ -105,17 +105,17 @@ axpby (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_axpby_usm: +.. _onemath_blas_axpby_usm: axpby (USM Version) ------------------- @@ -124,7 +124,7 @@ axpby (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event axpby(sycl::queue &queue, std::int64_t n, value_or_pointer alpha, @@ -135,7 +135,7 @@ axpby (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event axpby(sycl::queue &queue, std::int64_t n, value_or_pointer alpha, @@ -200,15 +200,15 @@ axpby (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/axpy.rst b/source/elements/oneMath/source/domains/blas/axpy.rst similarity index 81% rename from source/elements/oneMKL/source/domains/blas/axpy.rst rename to source/elements/oneMath/source/domains/blas/axpy.rst index d44d7bb9f1..fa998673b9 100644 --- a/source/elements/oneMKL/source/domains/blas/axpy.rst +++ b/source/elements/oneMath/source/domains/blas/axpy.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_axpy: +.. _onemath_blas_axpy: axpy ==== Computes a vector-scalar product and adds the result to a vector. -.. _onemkl_blas_axpy_description: +.. _onemath_blas_axpy_description: .. rubric:: Description @@ -39,7 +39,7 @@ where: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_axpy_buffer: +.. _onemath_blas_axpy_buffer: axpy (Buffer Version) --------------------- @@ -48,7 +48,7 @@ axpy (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void axpy(sycl::queue &queue, std::int64_t n, T alpha, @@ -59,7 +59,7 @@ axpy (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void axpy(sycl::queue &queue, std::int64_t n, T alpha, @@ -111,22 +111,22 @@ axpy (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_axpy_usm: +.. _onemath_blas_axpy_usm: axpy (USM Version) ------------------ @@ -135,7 +135,7 @@ axpy (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event axpy(sycl::queue &queue, std::int64_t n, value_or_pointer alpha, @@ -147,7 +147,7 @@ axpy (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event axpy(sycl::queue &queue, std::int64_t n, value_or_pointer alpha, @@ -212,20 +212,20 @@ axpy (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/axpy_batch.rst b/source/elements/oneMath/source/domains/blas/axpy_batch.rst similarity index 89% rename from source/elements/oneMKL/source/domains/blas/axpy_batch.rst rename to source/elements/oneMath/source/domains/blas/axpy_batch.rst index cc3a8ff434..6896b280f3 100644 --- a/source/elements/oneMKL/source/domains/blas/axpy_batch.rst +++ b/source/elements/oneMath/source/domains/blas/axpy_batch.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_axpy_batch: +.. _onemath_blas_axpy_batch: axpy_batch ========== Computes a group of ``axpy`` operations. -.. _onemkl_blas_axpy_batch_description: +.. _onemath_blas_axpy_batch_description: .. rubric:: Description -The ``axpy_batch`` routines are batched versions of :ref:`onemkl_blas_axpy`, performing +The ``axpy_batch`` routines are batched versions of :ref:`onemath_blas_axpy`, performing multiple ``axpy`` operations in a single call. Each ``axpy`` operation adds a scalar-vector product to a vector. @@ -28,7 +28,7 @@ operation adds a scalar-vector product to a vector. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_axpy_batch_buffer: +.. _onemath_blas_axpy_batch_buffer: axpy_batch (Buffer Version) --------------------------- @@ -57,7 +57,7 @@ where: .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void axpy_batch(sycl::queue &queue, std::int64_t n, T alpha, @@ -73,7 +73,7 @@ where: } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void axpy_batch(sycl::queue &queue, std::int64_t n, T alpha, @@ -136,22 +136,22 @@ where: This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_axpy_batch_usm: +.. _onemath_blas_axpy_batch_usm: axpy_batch (USM Version) ------------------------ @@ -202,7 +202,7 @@ The total number of vectors in ``x`` and ``y`` are given by the ``batch_size`` p .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event axpy_batch(sycl::queue &queue, const std::int64_t *n, const T *alpha, @@ -216,7 +216,7 @@ The total number of vectors in ``x`` and ``y`` are given by the ``batch_size`` p } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event axpy_batch(sycl::queue &queue, const std::int64_t *n, const T *alpha, @@ -289,7 +289,7 @@ The total number of vectors in ``x`` and ``y`` are given by the ``batch_size`` p .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event axpy_batch(sycl::queue &queue, std::int64_t n, value_or_pointer alpha, @@ -304,7 +304,7 @@ The total number of vectors in ``x`` and ``y`` are given by the ``batch_size`` p } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event axpy_batch(sycl::queue &queue, std::int64_t n, value_or_pointer alpha, @@ -376,20 +376,20 @@ The total number of vectors in ``x`` and ``y`` are given by the ``batch_size`` p This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:**:ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/blas-level-1-routines.rst b/source/elements/oneMath/source/domains/blas/blas-level-1-routines.rst similarity index 66% rename from source/elements/oneMKL/source/domains/blas/blas-level-1-routines.rst rename to source/elements/oneMath/source/domains/blas/blas-level-1-routines.rst index 756ad03558..aa13886dca 100644 --- a/source/elements/oneMKL/source/domains/blas/blas-level-1-routines.rst +++ b/source/elements/oneMath/source/domains/blas/blas-level-1-routines.rst @@ -23,37 +23,37 @@ BLAS Level 1 Routines * - Routines - Description - * - :ref:`onemkl_blas_asum` + * - :ref:`onemath_blas_asum` - Sum of vector magnitudes - * - :ref:`onemkl_blas_axpy` + * - :ref:`onemath_blas_axpy` - Scalar-vector product - * - :ref:`onemkl_blas_copy` + * - :ref:`onemath_blas_copy` - Copy vector - * - :ref:`onemkl_blas_dot` + * - :ref:`onemath_blas_dot` - Dot product - * - :ref:`onemkl_blas_sdsdot` + * - :ref:`onemath_blas_sdsdot` - Dot product with double precision - * - :ref:`onemkl_blas_dotc` + * - :ref:`onemath_blas_dotc` - Dot product conjugated - * - :ref:`onemkl_blas_dotu` + * - :ref:`onemath_blas_dotu` - Dot product unconjugated - * - :ref:`onemkl_blas_nrm2` + * - :ref:`onemath_blas_nrm2` - Vector 2-norm (Euclidean norm) - * - :ref:`onemkl_blas_rot` + * - :ref:`onemath_blas_rot` - Plane rotation of points - * - :ref:`onemkl_blas_rotg` + * - :ref:`onemath_blas_rotg` - Generate Givens rotation of points - * - :ref:`onemkl_blas_rotm` + * - :ref:`onemath_blas_rotm` - Modified Givens plane rotation of points - * - :ref:`onemkl_blas_rotmg` + * - :ref:`onemath_blas_rotmg` - Generate modified Givens plane rotation of points - * - :ref:`onemkl_blas_scal` + * - :ref:`onemath_blas_scal` - Vector-scalar product - * - :ref:`onemkl_blas_swap` + * - :ref:`onemath_blas_swap` - Vector-vector swap - * - :ref:`onemkl_blas_iamax` + * - :ref:`onemath_blas_iamax` - Index of the maximum absolute value element of a vector - * - :ref:`onemkl_blas_iamin` + * - :ref:`onemath_blas_iamin` - Index of the minimum absolute value element of a vector .. toctree:: @@ -77,4 +77,4 @@ BLAS Level 1 Routines iamin -**Parent topic:** :ref:`onemkl_blas` +**Parent topic:** :ref:`onemath_blas` diff --git a/source/elements/oneMKL/source/domains/blas/blas-level-2-routines.rst b/source/elements/oneMath/source/domains/blas/blas-level-2-routines.rst similarity index 68% rename from source/elements/oneMKL/source/domains/blas/blas-level-2-routines.rst rename to source/elements/oneMath/source/domains/blas/blas-level-2-routines.rst index a1631bf7e2..618246d706 100644 --- a/source/elements/oneMKL/source/domains/blas/blas-level-2-routines.rst +++ b/source/elements/oneMath/source/domains/blas/blas-level-2-routines.rst @@ -23,55 +23,55 @@ BLAS Level 2 Routines * - Routines - Description - * - :ref:`onemkl_blas_gbmv` + * - :ref:`onemath_blas_gbmv` - Matrix-vector product using a general band matrix - * - :ref:`onemkl_blas_gemv` + * - :ref:`onemath_blas_gemv` - Matrix-vector product using a general matrix - * - :ref:`onemkl_blas_ger` + * - :ref:`onemath_blas_ger` - Rank-1 update of a general matrix - * - :ref:`onemkl_blas_gerc` + * - :ref:`onemath_blas_gerc` - Rank-1 update of a conjugated general matrix - * - :ref:`onemkl_blas_geru` + * - :ref:`onemath_blas_geru` - Rank-1 update of a general matrix, unconjugated - * - :ref:`onemkl_blas_hbmv` + * - :ref:`onemath_blas_hbmv` - Matrix-vector product using a Hermitian band matrix - * - :ref:`onemkl_blas_hemv` + * - :ref:`onemath_blas_hemv` - Matrix-vector product using a Hermitian matrix - * - :ref:`onemkl_blas_her` + * - :ref:`onemath_blas_her` - Rank-1 update of a Hermitian matrix - * - :ref:`onemkl_blas_her2` + * - :ref:`onemath_blas_her2` - Rank-2 update of a Hermitian matrix - * - :ref:`onemkl_blas_hpmv` + * - :ref:`onemath_blas_hpmv` - Matrix-vector product using a Hermitian packed matrix - * - :ref:`onemkl_blas_hpr` + * - :ref:`onemath_blas_hpr` - Rank-1 update of a Hermitian packed matrix - * - :ref:`onemkl_blas_hpr2` + * - :ref:`onemath_blas_hpr2` - Rank-2 update of a Hermitian packed matrix - * - :ref:`onemkl_blas_sbmv` + * - :ref:`onemath_blas_sbmv` - Matrix-vector product using symmetric band matrix - * - :ref:`onemkl_blas_spmv` + * - :ref:`onemath_blas_spmv` - Matrix-vector product using a symmetric packed matrix - * - :ref:`onemkl_blas_spr` + * - :ref:`onemath_blas_spr` - Rank-1 update of a symmetric packed matrix - * - :ref:`onemkl_blas_spr2` + * - :ref:`onemath_blas_spr2` - Rank-2 update of a symmetric packed matrix - * - :ref:`onemkl_blas_symv` + * - :ref:`onemath_blas_symv` - Matrix-vector product using a symmetric matrix - * - :ref:`onemkl_blas_syr` + * - :ref:`onemath_blas_syr` - Rank-1 update of a symmetric matrix - * - :ref:`onemkl_blas_syr2` + * - :ref:`onemath_blas_syr2` - Rank-2 update of a symmetric matrix - * - :ref:`onemkl_blas_tbmv` + * - :ref:`onemath_blas_tbmv` - Matrix-vector product using a triangular band matrix - * - :ref:`onemkl_blas_tbsv` + * - :ref:`onemath_blas_tbsv` - Solution of a linear system of equations with a triangular band matrix - * - :ref:`onemkl_blas_tpmv` + * - :ref:`onemath_blas_tpmv` - Matrix-vector product using a triangular packed matrix - * - :ref:`onemkl_blas_tpsv` + * - :ref:`onemath_blas_tpsv` - Solution of a linear system of equations with a triangular packed matrix - * - :ref:`onemkl_blas_trmv` + * - :ref:`onemath_blas_trmv` - Matrix-vector product using a triangular matrix - * - :ref:`onemkl_blas_trsv` + * - :ref:`onemath_blas_trsv` - Solution of a linear system of equations with a triangular matrix @@ -106,4 +106,4 @@ BLAS Level 2 Routines trmv trsv -**Parent topic:** :ref:`onemkl_blas` +**Parent topic:** :ref:`onemath_blas` diff --git a/source/elements/oneMKL/source/domains/blas/blas-level-3-routines.rst b/source/elements/oneMath/source/domains/blas/blas-level-3-routines.rst similarity index 74% rename from source/elements/oneMKL/source/domains/blas/blas-level-3-routines.rst rename to source/elements/oneMath/source/domains/blas/blas-level-3-routines.rst index 85e3720942..28529b240f 100644 --- a/source/elements/oneMKL/source/domains/blas/blas-level-3-routines.rst +++ b/source/elements/oneMath/source/domains/blas/blas-level-3-routines.rst @@ -22,23 +22,23 @@ BLAS Level 3 Routines * - Routines - Description - * - :ref:`onemkl_blas_gemm` + * - :ref:`onemath_blas_gemm` - Computes a matrix-matrix product with general matrices. - * - :ref:`onemkl_blas_hemm` + * - :ref:`onemath_blas_hemm` - Computes a matrix-matrix product where one input matrix is Hermitian and one is general. - * - :ref:`onemkl_blas_herk` + * - :ref:`onemath_blas_herk` - Performs a Hermitian rank-k update. - * - :ref:`onemkl_blas_her2k` + * - :ref:`onemath_blas_her2k` - Performs a Hermitian rank-2k update. - * - :ref:`onemkl_blas_symm` + * - :ref:`onemath_blas_symm` - Computes a matrix-matrix product where one input matrix is symmetric and one matrix is general. - * - :ref:`onemkl_blas_syrk` + * - :ref:`onemath_blas_syrk` - Performs a symmetric rank-k update. - * - :ref:`onemkl_blas_syr2k` + * - :ref:`onemath_blas_syr2k` - Performs a symmetric rank-2k update. - * - :ref:`onemkl_blas_trmm` + * - :ref:`onemath_blas_trmm` - Computes a matrix-matrix product where one input matrix is triangular and one input matrix is general. - * - :ref:`onemkl_blas_trsm` + * - :ref:`onemath_blas_trsm` - Solves a triangular matrix equation (forward or backward solve). @@ -56,4 +56,4 @@ BLAS Level 3 Routines trmm trsm -**Parent topic:** :ref:`onemkl_blas` +**Parent topic:** :ref:`onemath_blas` diff --git a/source/elements/oneMKL/source/domains/blas/blas-like-extensions.rst b/source/elements/oneMath/source/domains/blas/blas-like-extensions.rst similarity index 70% rename from source/elements/oneMKL/source/domains/blas/blas-like-extensions.rst rename to source/elements/oneMath/source/domains/blas/blas-like-extensions.rst index cabc5441b6..65143cbae3 100644 --- a/source/elements/oneMKL/source/domains/blas/blas-like-extensions.rst +++ b/source/elements/oneMath/source/domains/blas/blas-like-extensions.rst @@ -11,8 +11,8 @@ BLAS-like Extensions .. container:: - oneAPI Math Kernel Library DPC++ provides additional routines to - extend the functionality of the BLAS routines. These include routines + |onemath_full_name| DPC++ provides additional routines to extend + the functionality of the BLAS routines. These include routines to compute many independent vector-vector and matrix-matrix operations. The following table lists the BLAS-like extensions with their descriptions. @@ -26,30 +26,30 @@ BLAS-like Extensions * - Routines - Description - * - :ref:`onemkl_blas_axpy_batch` + * - :ref:`onemath_blas_axpy_batch` - Computes groups of vector-scalar products added to a vector. - * - :ref:`onemkl_blas_gemm_batch` + * - :ref:`onemath_blas_gemm_batch` - Computes groups of matrix-matrix products with general matrices. - * - :ref:`onemkl_blas_trsm_batch` + * - :ref:`onemath_blas_trsm_batch` - Solves a triangular matrix equation for a group of matrices. - * - :ref:`onemkl_blas_gemmt` + * - :ref:`onemath_blas_gemmt` - Computes a matrix-matrix product with general matrices, but updates only the upper or lower triangular part of the result matrix. - * - :ref:`onemkl_blas_gemm_bias` + * - :ref:`onemath_blas_gemm_bias` - Computes a matrix-matrix product using general integer matrices with bias - * - :ref:`onemkl_blas_imatcopy` + * - :ref:`onemath_blas_imatcopy` - Computes an in-place matrix transposition or copy. - * - :ref:`onemkl_blas_omatcopy` + * - :ref:`onemath_blas_omatcopy` - Computes an out-of-place matrix transposition or copy. - * - :ref:`onemkl_blas_omatcopy2` + * - :ref:`onemath_blas_omatcopy2` - Computes a two-strided out-of-place matrix transposition or copy. - * - :ref:`onemkl_blas_omatadd` + * - :ref:`onemath_blas_omatadd` - Computes scaled matrix addition with possibly transposed arguments. - * - :ref:`onemkl_blas_imatcopy_batch` + * - :ref:`onemath_blas_imatcopy_batch` - Computes groups of in-place matrix transposition or copy operations. - * - :ref:`onemkl_blas_omatcopy_batch` + * - :ref:`onemath_blas_omatcopy_batch` - Computes groups of out-of-place matrix transposition or copy operations. - * - :ref:`onemkl_blas_omatadd_batch` + * - :ref:`onemath_blas_omatadd_batch` - Computes groups of scaled matrix additions. @@ -77,4 +77,4 @@ BLAS-like Extensions omatcopy_batch omatadd_batch -**Parent topic:** :ref:`onemkl_blas` +**Parent topic:** :ref:`onemath_blas` diff --git a/source/elements/oneMKL/source/domains/blas/blas.rst b/source/elements/oneMath/source/domains/blas/blas.rst similarity index 54% rename from source/elements/oneMKL/source/domains/blas/blas.rst rename to source/elements/oneMath/source/domains/blas/blas.rst index 429b014d9c..8b621d2f20 100644 --- a/source/elements/oneMKL/source/domains/blas/blas.rst +++ b/source/elements/oneMath/source/domains/blas/blas.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas: +.. _onemath_blas: BLAS Routines +++++++++++++ -oneMKL provides DPC++ interfaces to the Basic Linear Algebra Subprograms (BLAS) routines (Level1, Level2, Level3), as well as several BLAS-like extension routines. +oneMath provides DPC++ interfaces to the Basic Linear Algebra Subprograms (BLAS) routines (Level1, Level2, Level3), as well as several BLAS-like extension routines. .. toctree:: :maxdepth: 1 @@ -18,4 +18,4 @@ oneMKL provides DPC++ interfaces to the Basic Linear Algebra Subprograms (BLAS) blas-like-extensions.rst -**Parent topic:** :ref:`onemkl_dense_linear_algebra` +**Parent topic:** :ref:`onemath_dense_linear_algebra` diff --git a/source/elements/oneMKL/source/domains/blas/copy.rst b/source/elements/oneMath/source/domains/blas/copy.rst similarity index 78% rename from source/elements/oneMKL/source/domains/blas/copy.rst rename to source/elements/oneMath/source/domains/blas/copy.rst index 080358e1b5..ee108451f5 100644 --- a/source/elements/oneMKL/source/domains/blas/copy.rst +++ b/source/elements/oneMath/source/domains/blas/copy.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_copy: +.. _onemath_blas_copy: copy ==== Copies a vector to another vector. -.. _onemkl_blas_copy_description: +.. _onemath_blas_copy_description: .. rubric:: Description @@ -33,7 +33,7 @@ where ``x`` and ``y`` are vectors of n elements. * - ``std::complex`` -.. _onemkl_blas_copy_buffer: +.. _onemath_blas_copy_buffer: copy (Buffer Version) --------------------- @@ -42,7 +42,7 @@ copy (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void copy(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -52,7 +52,7 @@ copy (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void copy(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -95,22 +95,22 @@ copy (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_copy_usm: +.. _onemath_blas_copy_usm: copy (USM Version) ------------------ @@ -119,7 +119,7 @@ copy (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event copy(sycl::queue &queue, std::int64_t n, const T *x, @@ -130,7 +130,7 @@ copy (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event copy(sycl::queue &queue, std::int64_t n, const T *x, @@ -185,20 +185,20 @@ copy (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/copy_batch.rst b/source/elements/oneMath/source/domains/blas/copy_batch.rst similarity index 88% rename from source/elements/oneMKL/source/domains/blas/copy_batch.rst rename to source/elements/oneMath/source/domains/blas/copy_batch.rst index 8c845e27c6..2ada0ad075 100644 --- a/source/elements/oneMKL/source/domains/blas/copy_batch.rst +++ b/source/elements/oneMath/source/domains/blas/copy_batch.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_copy_batch: +.. _onemath_blas_copy_batch: copy_batch ========== Computes a group of ``copy`` operations. -.. _onemkl_blas_copy_batch_description: +.. _onemath_blas_copy_batch_description: .. rubric:: Description -The ``copy_batch`` routines are batched versions of :ref:`onemkl_blas_copy`, performing +The ``copy_batch`` routines are batched versions of :ref:`onemath_blas_copy`, performing multiple ``copy`` operations in a single call. Each ``copy`` operation copies one vector to another. @@ -28,7 +28,7 @@ operation copies one vector to another. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_copy_batch_buffer: +.. _onemath_blas_copy_batch_buffer: copy_batch (Buffer Version) --------------------------- @@ -55,7 +55,7 @@ where: .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void copy_batch(sycl::queue &queue, std::int64_t n, sycl::buffer` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_copy_batch_usm: +.. _onemath_blas_copy_batch_usm: copy_batch (USM Version) ------------------------ @@ -192,7 +192,7 @@ The total number of vectors in ``x`` and ``y`` are given by the ``batch_size`` p .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event copy_batch(sycl::queue &queue, const std::int64_t *n, const T **x, @@ -205,7 +205,7 @@ The total number of vectors in ``x`` and ``y`` are given by the ``batch_size`` p } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event copy_batch(sycl::queue &queue, const std::int64_t *n, const T **x, @@ -273,7 +273,7 @@ The total number of vectors in ``x`` and ``y`` are given by the ``batch_size`` p .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event copy_batch(sycl::queue &queue, std::int64_t n, const T *x, @@ -287,7 +287,7 @@ The total number of vectors in ``x`` and ``y`` are given by the ``batch_size`` p } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event copy_batch(sycl::queue &queue, std::int64_t n, const T *x, @@ -354,20 +354,20 @@ The total number of vectors in ``x`` and ``y`` are given by the ``batch_size`` p This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:**:ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/dgmm_batch.rst b/source/elements/oneMath/source/domains/blas/dgmm_batch.rst similarity index 89% rename from source/elements/oneMKL/source/domains/blas/dgmm_batch.rst rename to source/elements/oneMath/source/domains/blas/dgmm_batch.rst index fecd54260d..6a2480c9e5 100644 --- a/source/elements/oneMKL/source/domains/blas/dgmm_batch.rst +++ b/source/elements/oneMath/source/domains/blas/dgmm_batch.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_dgmm_batch: +.. _onemath_blas_dgmm_batch: dgmm_batch ========== Computes a group of ``dgmm`` operations. -.. _onemkl_blas_dgmm_batch_description: +.. _onemath_blas_dgmm_batch_description: .. rubric:: Description @@ -27,7 +27,7 @@ multiple diagonal matrix-matrix product operations in a single call. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_dgmm_batch_buffer: +.. _onemath_blas_dgmm_batch_buffer: dgmm_batch (Buffer Version) --------------------------- @@ -61,9 +61,9 @@ of matrices in ``a`` and ``x`` buffers is given by the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void dgmm_batch(sycl::queue &queue, - oneapi::mkl::side left_right, + oneapi::math::side left_right, std::int64_t m, std::int64_t n, sycl::buffer &a, @@ -79,9 +79,9 @@ of matrices in ``a`` and ``x`` buffers is given by the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void dgmm_batch(sycl::queue &queue, - oneapi::mkl::side left_right, + oneapi::math::side left_right, std::int64_t m, std::int64_t n, sycl::buffer &a, @@ -105,7 +105,7 @@ of matrices in ``a`` and ``x`` buffers is given by the ``batch_size`` parameter. left_right Specifies the position of the diagonal matrix in the product. - See :ref:`onemkl_datatypes` for more details. + See :ref:`onemath_datatypes` for more details. m Number of rows of matrices ``A`` and ``C``. Must be at least zero. @@ -171,22 +171,22 @@ of matrices in ``a`` and ``x`` buffers is given by the ``batch_size`` parameter. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_dgmm_batch_usm: +.. _onemath_blas_dgmm_batch_usm: dgmm_batch (USM Version) --------------------------- @@ -203,7 +203,7 @@ The group API operation is defined as: for j = 0 … group_size – 1 a and c are matrices of size mxn at position idx in a_array and c_array x is a vector of size m or n depending on left_right, at position idx in x_array - if (left_right == oneapi::mkl::side::left) + if (left_right == oneapi::math::side::left) c := diag(x) * a else c := a * diag(x) @@ -246,9 +246,9 @@ in ``a`` and ``x`` are given by the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event dgmm_batch(sycl::queue &queue, - const oneapi::mkl::side *left_right, + const oneapi::math::side *left_right, const std::int64_t *m, const std::int64_t *n, const T **a, @@ -263,9 +263,9 @@ in ``a`` and ``x`` are given by the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event dgmm_batch(sycl::queue &queue, - const oneapi::mkl::side *left_right, + const oneapi::math::side *left_right, const std::int64_t *m, const std::int64_t *n, const T **a, @@ -288,7 +288,7 @@ in ``a`` and ``x`` are given by the ``batch_size`` parameter. left_right Specifies the position of the diagonal matrix in the product. - See :ref:`onemkl_datatypes` for more details. + See :ref:`onemath_datatypes` for more details. m Array of ``group_count`` integers. ``m[i]`` specifies the @@ -370,9 +370,9 @@ in ``a`` and ``x`` are given by the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event dgmm_batch(sycl::queue &queue, - oneapi::mkl::side left_right, + oneapi::math::side left_right, std::int64_t m, std::int64_t n, const T *a, @@ -389,9 +389,9 @@ in ``a`` and ``x`` are given by the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event dgmm_batch(sycl::queue &queue, - oneapi::mkl::side left_right, + oneapi::math::side left_right, std::int64_t m, std::int64_t n, const T *a, @@ -416,7 +416,7 @@ in ``a`` and ``x`` are given by the ``batch_size`` parameter. left_right Specifies the position of the diagonal matrix in the product. - See :ref:`onemkl_datatypes` for more details. + See :ref:`onemath_datatypes` for more details. m Number of rows of ``A``. Must be at least zero. @@ -488,20 +488,20 @@ in ``a`` and ``x`` are given by the ``batch_size`` parameter. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/dot.rst b/source/elements/oneMath/source/domains/blas/dot.rst similarity index 81% rename from source/elements/oneMKL/source/domains/blas/dot.rst rename to source/elements/oneMath/source/domains/blas/dot.rst index 15b5369796..103159eb15 100644 --- a/source/elements/oneMKL/source/domains/blas/dot.rst +++ b/source/elements/oneMath/source/domains/blas/dot.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_dot: +.. _onemath_blas_dot: dot === Computes the dot product of two real vectors. -.. _onemkl_blas_dot_description: +.. _onemath_blas_dot_description: .. rubric:: Description @@ -45,7 +45,7 @@ The ``dot`` routines perform a dot product between two vectors: For the mixed precision version (inputs are float while result is double), the dot product is computed with double precision. -.. _onemkl_blas_dot_buffer: +.. _onemath_blas_dot_buffer: dot (Buffer Version) -------------------- @@ -54,7 +54,7 @@ dot (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void dot(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -65,7 +65,7 @@ dot (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void dot(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -114,22 +114,22 @@ dot (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_dot_usm: +.. _onemath_blas_dot_usm: dot (USM Version) ----------------- @@ -138,7 +138,7 @@ dot (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event dot(sycl::queue &queue, std::int64_t n, const T *x, @@ -150,7 +150,7 @@ dot (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event dot(sycl::queue &queue, std::int64_t n, const T *x, @@ -212,20 +212,20 @@ dot (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/dotc.rst b/source/elements/oneMath/source/domains/blas/dotc.rst similarity index 80% rename from source/elements/oneMKL/source/domains/blas/dotc.rst rename to source/elements/oneMath/source/domains/blas/dotc.rst index c782e4122a..002e81b860 100644 --- a/source/elements/oneMKL/source/domains/blas/dotc.rst +++ b/source/elements/oneMath/source/domains/blas/dotc.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_dotc: +.. _onemath_blas_dotc: dotc ==== Computes the dot product of two complex vectors, conjugating the first vector. -.. _onemkl_blas_dotc_description: +.. _onemath_blas_dotc_description: .. rubric:: Description @@ -29,7 +29,7 @@ vectors, conjugating the first of them: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_dotc_buffer: +.. _onemath_blas_dotc_buffer: dotc (Buffer Version) --------------------- @@ -38,7 +38,7 @@ dotc (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void dotc(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -49,7 +49,7 @@ dotc (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void dotc(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -98,22 +98,22 @@ dotc (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_dotc_usm: +.. _onemath_blas_dotc_usm: dotc (USM Version) ------------------ @@ -122,7 +122,7 @@ dotc (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void dotc(sycl::queue &queue, std::int64_t n, const T *x, @@ -134,7 +134,7 @@ dotc (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void dotc(sycl::queue &queue, std::int64_t n, const T *x, @@ -196,20 +196,20 @@ dotc (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/dotu.rst b/source/elements/oneMath/source/domains/blas/dotu.rst similarity index 80% rename from source/elements/oneMKL/source/domains/blas/dotu.rst rename to source/elements/oneMath/source/domains/blas/dotu.rst index 551ad2fb52..d1a2dbdf6a 100644 --- a/source/elements/oneMKL/source/domains/blas/dotu.rst +++ b/source/elements/oneMath/source/domains/blas/dotu.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_dotu: +.. _onemath_blas_dotu: dotu ==== Computes the dot product of two complex vectors. -.. _onemkl_blas_dotu_description: +.. _onemath_blas_dotu_description: .. rubric:: Description @@ -28,7 +28,7 @@ The ``dotu`` routines perform a dot product between two complex vectors: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_dotu_buffer: +.. _onemath_blas_dotu_buffer: dotu (Buffer Version) --------------------- @@ -37,7 +37,7 @@ dotu (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void dotu(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -48,7 +48,7 @@ dotu (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void dotu(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -98,22 +98,22 @@ dotu (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_dotu_usm: +.. _onemath_blas_dotu_usm: dotu (USM Version) ------------------ @@ -122,7 +122,7 @@ dotu (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event dotu(sycl::queue &queue, std::int64_t n, const T *x, @@ -134,7 +134,7 @@ dotu (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event dotu(sycl::queue &queue, std::int64_t n, const T *x, @@ -196,20 +196,20 @@ dotu (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/gbmv.rst b/source/elements/oneMath/source/domains/blas/gbmv.rst similarity index 85% rename from source/elements/oneMKL/source/domains/blas/gbmv.rst rename to source/elements/oneMath/source/domains/blas/gbmv.rst index fd90069ba1..52111276bb 100644 --- a/source/elements/oneMKL/source/domains/blas/gbmv.rst +++ b/source/elements/oneMath/source/domains/blas/gbmv.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_gbmv: +.. _onemath_blas_gbmv: gbmv ==== Computes a matrix-vector product with a general band matrix. -.. _onemkl_blas_gbmv_description: +.. _onemath_blas_gbmv_description: .. rubric:: Description @@ -44,7 +44,7 @@ op(``A``) is one of op(``A``) = ``A``, or op(``A``) = * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_gbmv_buffer: +.. _onemath_blas_gbmv_buffer: gbmv (Buffer Version) --------------------- @@ -53,9 +53,9 @@ gbmv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void gbmv(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t kl, @@ -71,9 +71,9 @@ gbmv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void gbmv(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t kl, @@ -98,7 +98,7 @@ gbmv (Buffer Version) trans Specifies op(``A``), the transposition operation applied to ``A``. See - :ref:`onemkl_datatypes` for more + :ref:`onemath_datatypes` for more details. m @@ -164,22 +164,22 @@ gbmv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_gbmv_usm: +.. _onemath_blas_gbmv_usm: gbmv (USM Version) ------------------ @@ -188,9 +188,9 @@ gbmv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event gbmv(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t kl, @@ -207,9 +207,9 @@ gbmv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event gbmv(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t kl, @@ -235,7 +235,7 @@ gbmv (USM Version) trans Specifies op(``A``), the transposition operation applied to ``A``. See - :ref:`onemkl_datatypes` for + :ref:`onemath_datatypes` for more details. m @@ -312,20 +312,20 @@ gbmv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/gemm.rst b/source/elements/oneMath/source/domains/blas/gemm.rst similarity index 90% rename from source/elements/oneMKL/source/domains/blas/gemm.rst rename to source/elements/oneMath/source/domains/blas/gemm.rst index b9d1956e4f..7c8b0cc45f 100644 --- a/source/elements/oneMKL/source/domains/blas/gemm.rst +++ b/source/elements/oneMath/source/domains/blas/gemm.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_gemm: +.. _onemath_blas_gemm: gemm ==== Computes a matrix-matrix product with general matrices. -.. _onemkl_blas_gemm_description: +.. _onemath_blas_gemm_description: .. rubric:: Description @@ -90,7 +90,7 @@ op(``X``) = ``X``\ :sup:`H`, - ``std::complex`` - ``std::complex`` -.. _onemkl_blas_gemm_buffer: +.. _onemath_blas_gemm_buffer: gemm (Buffer Version) --------------------- @@ -99,10 +99,10 @@ gemm (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void gemm(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, std::int64_t k, @@ -117,10 +117,10 @@ gemm (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void gemm(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, std::int64_t k, @@ -277,22 +277,22 @@ gemm (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_gemm_usm: +.. _onemath_blas_gemm_usm: gemm (USM Version) ------------------ @@ -301,10 +301,10 @@ gemm (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event gemm(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, std::int64_t k, @@ -320,10 +320,10 @@ gemm (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event gemm(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, std::int64_t k, @@ -497,19 +497,19 @@ gemm (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-3-routines` diff --git a/source/elements/oneMKL/source/domains/blas/gemm_batch.rst b/source/elements/oneMath/source/domains/blas/gemm_batch.rst similarity index 87% rename from source/elements/oneMKL/source/domains/blas/gemm_batch.rst rename to source/elements/oneMath/source/domains/blas/gemm_batch.rst index 0dfb4fff2f..690e725cda 100644 --- a/source/elements/oneMKL/source/domains/blas/gemm_batch.rst +++ b/source/elements/oneMath/source/domains/blas/gemm_batch.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_gemm_batch: +.. _onemath_blas_gemm_batch: gemm_batch ========== Computes a group of ``gemm`` operations. -.. _onemkl_blas_gemm_batch_description: +.. _onemath_blas_gemm_batch_description: .. rubric:: Description -The ``gemm_batch`` routines are batched versions of :ref:`onemkl_blas_gemm`, performing +The ``gemm_batch`` routines are batched versions of :ref:`onemath_blas_gemm`, performing multiple ``gemm`` operations in a single call. Each ``gemm`` operation perform a matrix-matrix product with general matrices. @@ -71,7 +71,7 @@ operation perform a matrix-matrix product with general matrices. - ``std::complex`` - ``std::complex`` -.. _onemkl_blas_gemm_batch_buffer: +.. _onemath_blas_gemm_batch_buffer: gemm_batch (Buffer Version) --------------------------- @@ -109,10 +109,10 @@ of matrices in ``a``, ``b`` and ``c`` buffers is given by the ``batch_size`` par .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void gemm_batch(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, std::int64_t k, @@ -131,10 +131,10 @@ of matrices in ``a``, ``b`` and ``c`` buffers is given by the ``batch_size`` par } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void gemm_batch(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, std::int64_t k, @@ -161,11 +161,11 @@ of matrices in ``a``, ``b`` and ``c`` buffers is given by the ``batch_size`` par transa Specifies op(``A``) the transposition operation applied to the - matrices ``A``. See :ref:`onemkl_datatypes` for more details. + matrices ``A``. See :ref:`onemath_datatypes` for more details. transb Specifies op(``B``) the transposition operation applied to the - matrices ``B``. See :ref:`onemkl_datatypes` for more details. + matrices ``B``. See :ref:`onemath_datatypes` for more details. m Number of rows of op(``A``) and ``C``. Must be at least zero. @@ -265,22 +265,22 @@ of matrices in ``a``, ``b`` and ``c`` buffers is given by the ``batch_size`` par This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_gemm_batch_usm: +.. _onemath_blas_gemm_batch_usm: gemm_batch (USM Version) --------------------------- @@ -356,10 +356,10 @@ in ``a``, ``b`` and ``c`` are given by the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event gemm_batch(sycl::queue &queue, - const oneapi::mkl::transpose *transa, - const oneapi::mkl::transpose *transb, + const oneapi::math::transpose *transa, + const oneapi::math::transpose *transb, const std::int64_t *m, const std::int64_t *n, const std::int64_t *k, @@ -376,8 +376,8 @@ in ``a``, ``b`` and ``c`` are given by the ``batch_size`` parameter. const std::vector &dependencies = {}) sycl::event gemm_batch(sycl::queue &queue, - const sycl::span &transa, - const sycl::span &transb, + const sycl::span &transa, + const sycl::span &transb, const sycl::span &m, const sycl::span &n, const sycl::span &k, @@ -395,10 +395,10 @@ in ``a``, ``b`` and ``c`` are given by the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event gemm_batch(sycl::queue &queue, - const oneapi::mkl::transpose *transa, - const oneapi::mkl::transpose *transb, + const oneapi::math::transpose *transa, + const oneapi::math::transpose *transb, const std::int64_t *m, const std::int64_t *n, const std::int64_t *k, @@ -415,8 +415,8 @@ in ``a``, ``b`` and ``c`` are given by the ``batch_size`` parameter. const std::vector &dependencies = {}) sycl::event gemm_batch(sycl::queue &queue, - const sycl::span &transa, - const sycl::span &transb, + const sycl::span &transa, + const sycl::span &transb, const sycl::span &m, const sycl::span &n, const sycl::span &k, @@ -441,12 +441,12 @@ in ``a``, ``b`` and ``c`` are given by the ``batch_size`` parameter. The queue where the routine should be executed. transa - Array or span of ``group_count`` ``oneapi::mkl::transpose`` values. ``transa[i]`` specifies the form of op(``A``) used in - the matrix multiplication in group ``i``. See :ref:`onemkl_datatypes` for more details. + Array or span of ``group_count`` ``oneapi::math::transpose`` values. ``transa[i]`` specifies the form of op(``A``) used in + the matrix multiplication in group ``i``. See :ref:`onemath_datatypes` for more details. transb - Array or span of ``group_count`` ``oneapi::mkl::transpose`` values. ``transb[i]`` specifies the form of op(``B``) used in - the matrix multiplication in group ``i``. See :ref:`onemkl_datatypes` for more details. + Array or span of ``group_count`` ``oneapi::math::transpose`` values. ``transb[i]`` specifies the form of op(``B``) used in + the matrix multiplication in group ``i``. See :ref:`onemath_datatypes` for more details. m Array or span of ``group_count`` integers. ``m[i]`` specifies the @@ -586,10 +586,10 @@ in ``a``, ``b`` and ``c`` are given by the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event gemm_batch(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, std::int64_t k, @@ -609,10 +609,10 @@ in ``a``, ``b`` and ``c`` are given by the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event gemm_batch(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, std::int64_t k, @@ -640,11 +640,11 @@ in ``a``, ``b`` and ``c`` are given by the ``batch_size`` parameter. transa Specifies op(``A``) the transposition operation applied to the - matrices ``A``. See :ref:`onemkl_datatypes` for more details. + matrices ``A``. See :ref:`onemath_datatypes` for more details. transb Specifies op(``B``) the transposition operation applied to the - matrices ``B``. See :ref:`onemkl_datatypes` for more details. + matrices ``B``. See :ref:`onemath_datatypes` for more details. m Number of rows of op(``A``) and ``C``. Must be at least zero. @@ -751,20 +751,20 @@ in ``a``, ``b`` and ``c`` are given by the ``batch_size`` parameter. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/gemm_bias.rst b/source/elements/oneMath/source/domains/blas/gemm_bias.rst similarity index 88% rename from source/elements/oneMKL/source/domains/blas/gemm_bias.rst rename to source/elements/oneMath/source/domains/blas/gemm_bias.rst index 0ca1a841da..0ecb073a7b 100644 --- a/source/elements/oneMKL/source/domains/blas/gemm_bias.rst +++ b/source/elements/oneMath/source/domains/blas/gemm_bias.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_gemm_bias: +.. _onemath_blas_gemm_bias: gemm_bias ========= Computes a matrix-matrix product using general integer matrices with bias. -.. _onemkl_blas_gemm_bias_description: +.. _onemath_blas_gemm_bias_description: .. rubric:: Description @@ -56,7 +56,7 @@ op(``A``) is ``m`` x ``k``, op(``B``) is ``k`` x ``n``, and * - ``std::int8_t`` - ``std::int8_t`` -.. _onemkl_blas_gemm_bias_buffer: +.. _onemath_blas_gemm_bias_buffer: gemm_bias (Buffer Version) -------------------------- @@ -65,11 +65,11 @@ gemm_bias (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void gemm_bias(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, - oneapi::mkl::offset offset_type, + oneapi::math::transpose transa, + oneapi::math::transpose transb, + oneapi::math::offset offset_type, std::int64_t m, std::int64_t n, std::int64_t k, @@ -87,11 +87,11 @@ gemm_bias (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void gemm_bias(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, - oneapi::mkl::offset offset_type, + oneapi::math::transpose transa, + oneapi::math::transpose transb, + oneapi::math::offset offset_type, std::int64_t m, std::int64_t n, std::int64_t k, @@ -118,19 +118,19 @@ gemm_bias (Buffer Version) transa Specifies op(``A``), the transposition operation applied to ``A``. See - :ref:`onemkl_datatypes` for + :ref:`onemath_datatypes` for more details. transb Specifies op(``B``), the transposition operation applied to ``B``. See - :ref:`onemkl_datatypes` for + :ref:`onemath_datatypes` for more details. offset_type Specifies the form of ``C_offset`` used in the matrix multiplication. See - :ref:`onemkl_datatypes` for + :ref:`onemath_datatypes` for more details. m @@ -279,22 +279,22 @@ gemm_bias (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_gemm_bias_usm: +.. _onemath_blas_gemm_bias_usm: gemm_bias (USM Version) ----------------------- @@ -303,11 +303,11 @@ gemm_bias (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event gemm_bias(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, - oneapi::mkl::offset offset_type, + oneapi::math::transpose transa, + oneapi::math::transpose transb, + oneapi::math::offset offset_type, std::int64_t m, std::int64_t n, std::int64_t k, @@ -326,11 +326,11 @@ gemm_bias (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event gemm_bias(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, - oneapi::mkl::offset offset_type, + oneapi::math::transpose transa, + oneapi::math::transpose transb, + oneapi::math::offset offset_type, std::int64_t m, std::int64_t n, std::int64_t k, @@ -358,19 +358,19 @@ gemm_bias (USM Version) transa Specifies op(``A``), the transposition operation applied to ``A``. See - :ref:`onemkl_datatypes` for + :ref:`onemath_datatypes` for more details. transb Specifies op(``B``), the transposition operation applied to ``B``. See - :ref:`onemkl_datatypes` for + :ref:`onemath_datatypes` for more details. offset_type Specifies the form of ``C_offset`` used in the matrix multiplication. See - :ref:`onemkl_datatypes` for + :ref:`onemath_datatypes` for more details. m @@ -529,20 +529,20 @@ gemm_bias (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/gemmt.rst b/source/elements/oneMath/source/domains/blas/gemmt.rst similarity index 85% rename from source/elements/oneMKL/source/domains/blas/gemmt.rst rename to source/elements/oneMath/source/domains/blas/gemmt.rst index 76e7ef61a2..e876ce7a06 100644 --- a/source/elements/oneMKL/source/domains/blas/gemmt.rst +++ b/source/elements/oneMath/source/domains/blas/gemmt.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_gemmt: +.. _onemath_blas_gemmt: gemmt ===== @@ -10,7 +10,7 @@ gemmt Computes a matrix-matrix product with general matrices, but updates only the upper or lower triangular part of the result matrix. -.. _onemkl_blas_gemmt_description: +.. _onemath_blas_gemmt_description: .. rubric:: Description @@ -45,7 +45,7 @@ op(``A``) is ``n`` x ``k``, op(``B``) is ``k`` x ``n``, and * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_gemmt_buffer: +.. _onemath_blas_gemmt_buffer: gemmt (Buffer Version) ---------------------- @@ -54,11 +54,11 @@ gemmt (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void gemmt(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::uplo upper_lower, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t n, std::int64_t k, T alpha, @@ -72,11 +72,11 @@ gemmt (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void gemmt(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::uplo upper_lower, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t n, std::int64_t k, T alpha, @@ -98,15 +98,15 @@ gemmt (Buffer Version) upper_lower Specifies whether ``C``\ ’s data is stored in its upper or - lower triangle. See :ref:`onemkl_datatypes` for more details. + lower triangle. See :ref:`onemath_datatypes` for more details. transa Specifies op(``A``), the transposition operation applied to - ``A``. See :ref:`onemkl_datatypes` for more details. + ``A``. See :ref:`onemath_datatypes` for more details. transb Specifies op(``B``), the transposition operation applied to - ``B``. See :ref:`onemkl_datatypes` for more details. + ``B``. See :ref:`onemath_datatypes` for more details. n Number of rows of op(``A``), columns of op(``B``), and @@ -228,22 +228,22 @@ gemmt (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_gemmt_usm: +.. _onemath_blas_gemmt_usm: gemmt (USM Version) ------------------- @@ -252,11 +252,11 @@ gemmt (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event gemmt(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::uplo upper_lower, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -271,11 +271,11 @@ gemmt (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event gemmt(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::uplo upper_lower, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -299,19 +299,19 @@ gemmt (USM Version) upper_lower Specifies whether ``C``\ ’s data is stored in its upper or lower triangle. See - :ref:`onemkl_datatypes` for + :ref:`onemath_datatypes` for more details. transa Specifies op(``A``), the transposition operation applied to ``A``. See - :ref:`onemkl_datatypes` for + :ref:`onemath_datatypes` for more details. transb Specifies op(``B``), the transposition operation applied to ``B``. See - :ref:`onemkl_datatypes` for + :ref:`onemath_datatypes` for more details. n @@ -444,20 +444,20 @@ gemmt (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/gemv.rst b/source/elements/oneMath/source/domains/blas/gemv.rst similarity index 85% rename from source/elements/oneMKL/source/domains/blas/gemv.rst rename to source/elements/oneMath/source/domains/blas/gemv.rst index aa95b5d2e4..8aae56c0c6 100644 --- a/source/elements/oneMKL/source/domains/blas/gemv.rst +++ b/source/elements/oneMath/source/domains/blas/gemv.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_gemv: +.. _onemath_blas_gemv: gemv ==== Computes a matrix-vector product using a general matrix. -.. _onemkl_blas_gemv_description: +.. _onemath_blas_gemv_description: .. rubric:: Description @@ -41,7 +41,7 @@ op(``A``) is one of op(``A``) = ``A``, or op(``A``) = * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_gemv_buffer: +.. _onemath_blas_gemv_buffer: gemv (Buffer Version) --------------------- @@ -50,9 +50,9 @@ gemv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void gemv(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -66,9 +66,9 @@ gemv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void gemv(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -148,22 +148,22 @@ gemv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_gemv_usm: +.. _onemath_blas_gemv_usm: gemv (USM Version) ------------------ @@ -172,9 +172,9 @@ gemv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event gemv(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -189,9 +189,9 @@ gemv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event gemv(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -215,7 +215,7 @@ gemv (USM Version) trans Specifies ``op(A)``, the transposition operation applied to ``A``. See - :ref:`onemkl_datatypes` for + :ref:`onemath_datatypes` for more details. m @@ -287,20 +287,20 @@ gemv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/gemv_batch.rst b/source/elements/oneMath/source/domains/blas/gemv_batch.rst similarity index 87% rename from source/elements/oneMKL/source/domains/blas/gemv_batch.rst rename to source/elements/oneMath/source/domains/blas/gemv_batch.rst index 1db7c8ff93..17b64eff9a 100644 --- a/source/elements/oneMKL/source/domains/blas/gemv_batch.rst +++ b/source/elements/oneMath/source/domains/blas/gemv_batch.rst @@ -2,19 +2,19 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_gemv_batch: +.. _onemath_blas_gemv_batch: gemv_batch ========== Computes a group of ``gemv`` operations. -.. _onemkl_blas_gemv_batch_description: +.. _onemath_blas_gemv_batch_description: .. rubric:: Description The ``gemv_batch`` routines are batched versions of -:ref:`onemkl_blas_gemv`, performing multiple ``gemv`` operations in a +:ref:`onemath_blas_gemv`, performing multiple ``gemv`` operations in a single call. Each ``gemv`` operations perform a scalar-matrix-vector product and add the result to a scalar-vector product. @@ -29,7 +29,7 @@ product and add the result to a scalar-vector product. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_gemv_batch_buffer: +.. _onemath_blas_gemv_batch_buffer: gemv_batch (Buffer Version) --------------------------- @@ -66,9 +66,9 @@ parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void gemv_batch(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -86,9 +86,9 @@ parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void gemv_batch(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -114,7 +114,7 @@ parameter. trans Specifies op(``A``) the transposition operation applied to the - matrices ``A``. See :ref:`onemkl_datatypes` for more details. + matrices ``A``. See :ref:`onemath_datatypes` for more details. m Number of rows of ``A``. Must be at least zero. @@ -174,22 +174,22 @@ parameter. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_gemv_batch_usm: +.. _onemath_blas_gemv_batch_usm: gemv_batch (USM Version) --------------------------- @@ -247,9 +247,9 @@ total number of vectors in ``x`` and ``y`` and matrices in ``A`` are given by th .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event gemv_batch(sycl::queue &queue, - const oneapi::mkl::transpose *trans, + const oneapi::math::transpose *trans, const std::int64_t *m, const std::int64_t *n, const T *alpha, @@ -266,9 +266,9 @@ total number of vectors in ``x`` and ``y`` and matrices in ``A`` are given by th } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event gemv_batch(sycl::queue &queue, - const oneapi::mkl::transpose *trans, + const oneapi::math::transpose *trans, const std::int64_t *m, const std::int64_t *n, const T *alpha, @@ -292,8 +292,8 @@ total number of vectors in ``x`` and ``y`` and matrices in ``A`` are given by th The queue where the routine should be executed. trans - Array of ``group_count`` ``oneapi::mkl::transpose`` values. ``trans[i]`` specifies the form of op(``A``) used in - the matrix-vector product in group ``i``. See :ref:`onemkl_datatypes` for more details. + Array of ``group_count`` ``oneapi::math::transpose`` values. ``trans[i]`` specifies the form of op(``A``) used in + the matrix-vector product in group ``i``. See :ref:`onemath_datatypes` for more details. m Array of ``group_count`` integers. ``m[i]`` specifies the @@ -375,9 +375,9 @@ total number of vectors in ``x`` and ``y`` and matrices in ``A`` are given by th .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event gemv_batch(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -396,9 +396,9 @@ total number of vectors in ``x`` and ``y`` and matrices in ``A`` are given by th } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event gemv_batch(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -426,7 +426,7 @@ total number of vectors in ``x`` and ``y`` and matrices in ``A`` are given by th trans Specifies op(``A``) the transposition operation applied to the - matrices ``A``. See :ref:`onemkl_datatypes` for more details. + matrices ``A``. See :ref:`onemath_datatypes` for more details. m Number of rows of ``A``. Must be at least zero. @@ -492,20 +492,20 @@ total number of vectors in ``x`` and ``y`` and matrices in ``A`` are given by th This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/ger.rst b/source/elements/oneMath/source/domains/blas/ger.rst similarity index 85% rename from source/elements/oneMKL/source/domains/blas/ger.rst rename to source/elements/oneMath/source/domains/blas/ger.rst index 5179367eb1..f1c8d81c7c 100644 --- a/source/elements/oneMKL/source/domains/blas/ger.rst +++ b/source/elements/oneMath/source/domains/blas/ger.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_ger: +.. _onemath_blas_ger: ger === Computes a rank-1 update of a general matrix. -.. _onemkl_blas_ger_description: +.. _onemath_blas_ger_description: .. rubric:: Description @@ -39,7 +39,7 @@ where: * - ``float`` * - ``double`` -.. _onemkl_blas_ger_buffer: +.. _onemath_blas_ger_buffer: ger (Buffer Version) -------------------- @@ -48,7 +48,7 @@ ger (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void ger(sycl::queue &queue, std::int64_t m, std::int64_t n, @@ -62,7 +62,7 @@ ger (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void ger(sycl::queue &queue, std::int64_t m, std::int64_t n, @@ -131,22 +131,22 @@ ger (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_ger_usm: +.. _onemath_blas_ger_usm: ger (USM Version) ----------------- @@ -155,7 +155,7 @@ ger (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event ger(sycl::queue &queue, std::int64_t m, std::int64_t n, @@ -170,7 +170,7 @@ ger (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event ger(sycl::queue &queue, std::int64_t m, std::int64_t n, @@ -251,20 +251,20 @@ ger (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/gerc.rst b/source/elements/oneMath/source/domains/blas/gerc.rst similarity index 85% rename from source/elements/oneMKL/source/domains/blas/gerc.rst rename to source/elements/oneMath/source/domains/blas/gerc.rst index da26513588..0946ade3fc 100644 --- a/source/elements/oneMKL/source/domains/blas/gerc.rst +++ b/source/elements/oneMath/source/domains/blas/gerc.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_gerc: +.. _onemath_blas_gerc: gerc ==== Computes a rank-1 update (conjugated) of a general complex matrix. -.. _onemkl_blas_gerc_description: +.. _onemath_blas_gerc_description: .. rubric:: Description @@ -40,7 +40,7 @@ where: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_gerc_buffer: +.. _onemath_blas_gerc_buffer: gerc (Buffer Version) --------------------- @@ -49,7 +49,7 @@ gerc (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void gerc(sycl::queue &queue, std::int64_t m, std::int64_t n, @@ -63,7 +63,7 @@ gerc (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void gerc(sycl::queue &queue, std::int64_t m, std::int64_t n, @@ -133,22 +133,22 @@ gerc (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_gerc_usm: +.. _onemath_blas_gerc_usm: gerc (USM Version) ------------------ @@ -157,7 +157,7 @@ gerc (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event gerc(sycl::queue &queue, std::int64_t m, std::int64_t n, @@ -172,7 +172,7 @@ gerc (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event gerc(sycl::queue &queue, std::int64_t m, std::int64_t n, @@ -254,20 +254,20 @@ gerc (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/geru.rst b/source/elements/oneMath/source/domains/blas/geru.rst similarity index 85% rename from source/elements/oneMKL/source/domains/blas/geru.rst rename to source/elements/oneMath/source/domains/blas/geru.rst index b9952a75d7..fec5fae70b 100644 --- a/source/elements/oneMKL/source/domains/blas/geru.rst +++ b/source/elements/oneMath/source/domains/blas/geru.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_geru: +.. _onemath_blas_geru: geru ==== Computes a rank-1 update (unconjugated) of a general complex matrix. -.. _onemkl_blas_geru_description: +.. _onemath_blas_geru_description: .. rubric:: Description @@ -39,7 +39,7 @@ where: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_geru_buffer: +.. _onemath_blas_geru_buffer: geru (Buffer Version) --------------------- @@ -48,7 +48,7 @@ geru (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void geru(sycl::queue &queue, std::int64_t m, std::int64_t n, @@ -62,7 +62,7 @@ geru (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void geru(sycl::queue &queue, std::int64_t m, std::int64_t n, @@ -131,22 +131,22 @@ geru (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_geru_usm: +.. _onemath_blas_geru_usm: geru (USM Version) ------------------ @@ -155,7 +155,7 @@ geru (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event geru(sycl::queue &queue, std::int64_t m, std::int64_t n, @@ -170,7 +170,7 @@ geru (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event geru(sycl::queue &queue, std::int64_t m, std::int64_t n, @@ -252,20 +252,20 @@ geru (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/hbmv.rst b/source/elements/oneMath/source/domains/blas/hbmv.rst similarity index 82% rename from source/elements/oneMKL/source/domains/blas/hbmv.rst rename to source/elements/oneMath/source/domains/blas/hbmv.rst index 7e3958d201..4c44e3bb05 100644 --- a/source/elements/oneMKL/source/domains/blas/hbmv.rst +++ b/source/elements/oneMath/source/domains/blas/hbmv.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_hbmv: +.. _onemath_blas_hbmv: hbmv ==== Computes a matrix-vector product using a Hermitian band matrix. -.. _onemkl_blas_hbmv_description: +.. _onemath_blas_hbmv_description: .. rubric:: Description @@ -39,7 +39,7 @@ super-diagonals, * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_hbmv_buffer: +.. _onemath_blas_hbmv_buffer: hbmv (Buffer Version) --------------------- @@ -48,9 +48,9 @@ hbmv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void hbmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t k, T alpha, @@ -64,9 +64,9 @@ hbmv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void hbmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t k, T alpha, @@ -87,7 +87,7 @@ hbmv (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -140,22 +140,22 @@ hbmv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_hbmv_usm: +.. _onemath_blas_hbmv_usm: hbmv (USM Version) ------------------ @@ -164,9 +164,9 @@ hbmv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event hbmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -181,9 +181,9 @@ hbmv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event hbmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -205,7 +205,7 @@ hbmv (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -271,20 +271,20 @@ hbmv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/hemm.rst b/source/elements/oneMath/source/domains/blas/hemm.rst similarity index 84% rename from source/elements/oneMKL/source/domains/blas/hemm.rst rename to source/elements/oneMath/source/domains/blas/hemm.rst index defb56a4ae..f16efb752b 100644 --- a/source/elements/oneMKL/source/domains/blas/hemm.rst +++ b/source/elements/oneMath/source/domains/blas/hemm.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_hemm: +.. _onemath_blas_hemm: hemm ==== @@ -10,7 +10,7 @@ hemm Computes a matrix-matrix product where one input matrix is Hermitian and one is general. -.. _onemkl_blas_hemm_description: +.. _onemath_blas_hemm_description: .. rubric:: Description @@ -50,7 +50,7 @@ matrices, * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_hemm_buffer: +.. _onemath_blas_hemm_buffer: hemm (Buffer Version) --------------------- @@ -59,10 +59,10 @@ hemm (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void hemm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, std::int64_t m, std::int64_t n, T alpha, @@ -76,10 +76,10 @@ hemm (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void hemm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, std::int64_t m, std::int64_t n, T alpha, @@ -101,11 +101,11 @@ hemm (Buffer Version) left_right Specifies whether ``A`` is on the left side of the multiplication - (``side::left``) or on the right side (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::left``) or on the right side (``side::right``). See :ref:`onemath_datatypes` for more details. uplo Specifies whether ``A``'s data is stored in its upper or lower - triangle. See :ref:`onemkl_datatypes` for more details. + triangle. See :ref:`onemath_datatypes` for more details. m Specifies the number of rows of the matrix ``B`` and ``C``. @@ -180,22 +180,22 @@ hemm (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_hemm_usm: +.. _onemath_blas_hemm_usm: hemm (USM Version) ------------------ @@ -204,10 +204,10 @@ hemm (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event hemm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -222,10 +222,10 @@ hemm (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event hemm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -249,11 +249,11 @@ hemm (USM Version) left_right Specifies whether ``A`` is on the left side of the multiplication (``side::left``) or on the right side - (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::right``). See :ref:`onemath_datatypes` for more details. uplo Specifies whether ``A``'s data is stored in its upper or lower - triangle. See :ref:`onemkl_datatypes` for more details. + triangle. See :ref:`onemath_datatypes` for more details. m Specifies the number of rows of the matrix ``B`` and ``C``. @@ -340,20 +340,20 @@ hemm (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-3-routines` diff --git a/source/elements/oneMKL/source/domains/blas/hemv.rst b/source/elements/oneMath/source/domains/blas/hemv.rst similarity index 81% rename from source/elements/oneMKL/source/domains/blas/hemv.rst rename to source/elements/oneMath/source/domains/blas/hemv.rst index 87cd997e0c..264506b78b 100644 --- a/source/elements/oneMKL/source/domains/blas/hemv.rst +++ b/source/elements/oneMath/source/domains/blas/hemv.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_hemv: +.. _onemath_blas_hemv: hemv ==== Computes a matrix-vector product using a Hermitian matrix. -.. _onemkl_blas_hemv_description: +.. _onemath_blas_hemv_description: .. rubric:: Description @@ -38,7 +38,7 @@ where: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_hemv_buffer: +.. _onemath_blas_hemv_buffer: hemv (Buffer Version) --------------------- @@ -47,9 +47,9 @@ hemv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void hemv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &a, @@ -62,9 +62,9 @@ hemv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void hemv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &a, @@ -84,7 +84,7 @@ hemv (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether *A* is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether *A* is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -133,22 +133,22 @@ hemv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_hemv_usm: +.. _onemath_blas_hemv_usm: hemv (USM Version) ------------------ @@ -157,9 +157,9 @@ hemv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event hemv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *a, @@ -173,9 +173,9 @@ hemv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event hemv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *a, @@ -196,7 +196,7 @@ hemv (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether *A* is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether *A* is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -257,20 +257,20 @@ hemv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/her.rst b/source/elements/oneMath/source/domains/blas/her.rst similarity index 80% rename from source/elements/oneMKL/source/domains/blas/her.rst rename to source/elements/oneMath/source/domains/blas/her.rst index 101109bc17..b7bd9a474e 100644 --- a/source/elements/oneMKL/source/domains/blas/her.rst +++ b/source/elements/oneMath/source/domains/blas/her.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_her: +.. _onemath_blas_her: her === Computes a rank-1 update of a Hermitian matrix. -.. _onemkl_blas_her_description: +.. _onemath_blas_her_description: .. rubric:: Description @@ -40,7 +40,7 @@ where: * - ``std::complex`` - ``double`` -.. _onemkl_blas_her_buffer: +.. _onemath_blas_her_buffer: her (Buffer Version) -------------------- @@ -49,9 +49,9 @@ her (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void her(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, Treal alpha, sycl::buffer &x, @@ -61,9 +61,9 @@ her (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void her(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, Treal alpha, sycl::buffer &x, @@ -80,7 +80,7 @@ her (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -123,22 +123,22 @@ her (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_her_usm: +.. _onemath_blas_her_usm: her (USM Version) ----------------- @@ -147,9 +147,9 @@ her (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event her(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -160,9 +160,9 @@ her (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event her(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -180,7 +180,7 @@ her (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether *A* is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether *A* is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -234,20 +234,20 @@ her (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/her2.rst b/source/elements/oneMath/source/domains/blas/her2.rst similarity index 82% rename from source/elements/oneMKL/source/domains/blas/her2.rst rename to source/elements/oneMath/source/domains/blas/her2.rst index 5fdce1277a..566f6478ec 100644 --- a/source/elements/oneMKL/source/domains/blas/her2.rst +++ b/source/elements/oneMath/source/domains/blas/her2.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_her2: +.. _onemath_blas_her2: her2 ==== Computes a rank-2 update of a Hermitian matrix. -.. _onemkl_blas_her2_description: +.. _onemath_blas_her2_description: .. rubric:: Description @@ -37,7 +37,7 @@ where: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_her2_buffer: +.. _onemath_blas_her2_buffer: her2 (Buffer Version) --------------------- @@ -46,9 +46,9 @@ her2 (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void her2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &x, @@ -60,9 +60,9 @@ her2 (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void her2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &x, @@ -81,7 +81,7 @@ her2 (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of columns of ``A``. Must be at least zero. @@ -132,22 +132,22 @@ her2 (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_her2_usm: +.. _onemath_blas_her2_usm: her2 (USM Version) ------------------ @@ -156,9 +156,9 @@ her2 (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event her2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -171,9 +171,9 @@ her2 (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event her2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -193,7 +193,7 @@ her2 (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of columns of ``A``. Must be at least zero. @@ -256,20 +256,20 @@ her2 (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/her2k.rst b/source/elements/oneMath/source/domains/blas/her2k.rst similarity index 87% rename from source/elements/oneMKL/source/domains/blas/her2k.rst rename to source/elements/oneMath/source/domains/blas/her2k.rst index 80cdbb733e..960edda013 100644 --- a/source/elements/oneMKL/source/domains/blas/her2k.rst +++ b/source/elements/oneMath/source/domains/blas/her2k.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_her2k: +.. _onemath_blas_her2k: her2k ===== Performs a Hermitian rank-2k update. -.. _onemkl_blas_her2k_description: +.. _onemath_blas_her2k_description: .. rubric:: Description @@ -52,7 +52,7 @@ The inner dimension of both matrix multiplications is ``k``. * - ``std::complex`` - ``double`` -.. _onemkl_blas_her2k_buffer: +.. _onemath_blas_her2k_buffer: her2k (Buffer Version) ---------------------- @@ -61,10 +61,10 @@ her2k (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void her2k(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, T alpha, @@ -78,10 +78,10 @@ her2k (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void her2k(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, T alpha, @@ -103,7 +103,7 @@ her2k (Buffer Version) upper_lower Specifies whether ``A``'s data is stored in its upper or lower - triangle. See :ref:`onemkl_datatypes` for more details. + triangle. See :ref:`onemath_datatypes` for more details. trans Specifies the operation to apply, as described above. Supported @@ -223,22 +223,22 @@ her2k (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_her2k_usm: +.. _onemath_blas_her2k_usm: her2k (USM Version) ------------------- @@ -247,10 +247,10 @@ her2k (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event her2k(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -265,10 +265,10 @@ her2k (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event her2k(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -291,7 +291,7 @@ her2k (USM Version) upper_lower Specifies whether ``A``'s data is stored in its upper or lower - triangle. See :ref:`onemkl_datatypes` for more details. + triangle. See :ref:`onemath_datatypes` for more details. trans Specifies the operation to apply, as described above. Supported @@ -422,20 +422,20 @@ her2k (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-3-routines` diff --git a/source/elements/oneMKL/source/domains/blas/herk.rst b/source/elements/oneMath/source/domains/blas/herk.rst similarity index 83% rename from source/elements/oneMKL/source/domains/blas/herk.rst rename to source/elements/oneMath/source/domains/blas/herk.rst index ea80e89b00..0e59a509a6 100644 --- a/source/elements/oneMKL/source/domains/blas/herk.rst +++ b/source/elements/oneMath/source/domains/blas/herk.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_herk: +.. _onemath_blas_herk: herk ==== Performs a Hermitian rank-k update. -.. _onemkl_blas_herk_description: +.. _onemath_blas_herk_description: .. rubric:: Description @@ -42,7 +42,7 @@ Here op(``A``) is ``n`` x ``k``, and ``C`` is ``n`` x ``n``. * - ``std::complex`` - ``double`` -.. _onemkl_blas_herk_buffer: +.. _onemath_blas_herk_buffer: herk (Buffer Version) --------------------- @@ -51,10 +51,10 @@ herk (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void herk(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, Treal alpha, @@ -66,10 +66,10 @@ herk (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void herk(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, Treal alpha, @@ -89,11 +89,11 @@ herk (Buffer Version) upper_lower Specifies whether ``A``'s data is stored in its upper or lower - triangle. See :ref:`onemkl_datatypes` for more details. + triangle. See :ref:`onemath_datatypes` for more details. trans Specifies op(``A``), the transposition operation applied to ``A``. See - :ref:`onemkl_datatypes` for more + :ref:`onemath_datatypes` for more details. Supported operations are ``transpose::nontrans`` and ``transpose::conjtrans``. @@ -174,22 +174,22 @@ herk (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_herk_usm: +.. _onemath_blas_herk_usm: herk (USM Version) ------------------ @@ -198,10 +198,10 @@ herk (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event herk(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -214,10 +214,10 @@ herk (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event herk(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -238,11 +238,11 @@ herk (USM Version) upper_lower Specifies whether ``A``'s data is stored in its upper or lower - triangle. See :ref:`onemkl_datatypes` for more details. + triangle. See :ref:`onemath_datatypes` for more details. trans Specifies op(``A``), the transposition operation applied to - ``A``. See :ref:`onemkl_datatypes` for more details. Supported operations are ``transpose::nontrans`` + ``A``. See :ref:`onemath_datatypes` for more details. Supported operations are ``transpose::nontrans`` and ``transpose::conjtrans``. n @@ -333,20 +333,20 @@ herk (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-3-routines` diff --git a/source/elements/oneMKL/source/domains/blas/hpmv.rst b/source/elements/oneMath/source/domains/blas/hpmv.rst similarity index 81% rename from source/elements/oneMKL/source/domains/blas/hpmv.rst rename to source/elements/oneMath/source/domains/blas/hpmv.rst index b89dff3f9a..cb2c4e5a19 100644 --- a/source/elements/oneMKL/source/domains/blas/hpmv.rst +++ b/source/elements/oneMath/source/domains/blas/hpmv.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_hpmv: +.. _onemath_blas_hpmv: hpmv ==== Computes a matrix-vector product using a Hermitian packed matrix. -.. _onemkl_blas_hpmv_description: +.. _onemath_blas_hpmv_description: .. rubric:: Description @@ -38,7 +38,7 @@ where: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_hpmv_buffer: +.. _onemath_blas_hpmv_buffer: hpmv (Buffer Version) --------------------- @@ -47,9 +47,9 @@ hpmv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void hpmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &a, @@ -61,9 +61,9 @@ hpmv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void hpmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &a, @@ -82,7 +82,7 @@ hpmv (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -130,22 +130,22 @@ hpmv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_hpmv_usm: +.. _onemath_blas_hpmv_usm: hpmv (USM Version) ------------------ @@ -154,9 +154,9 @@ hpmv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event hpmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *a, @@ -169,9 +169,9 @@ hpmv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event hpmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *a, @@ -191,7 +191,7 @@ hpmv (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -252,20 +252,20 @@ hpmv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/hpr.rst b/source/elements/oneMath/source/domains/blas/hpr.rst similarity index 80% rename from source/elements/oneMKL/source/domains/blas/hpr.rst rename to source/elements/oneMath/source/domains/blas/hpr.rst index d528c22e06..c1891d6265 100644 --- a/source/elements/oneMKL/source/domains/blas/hpr.rst +++ b/source/elements/oneMath/source/domains/blas/hpr.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_hpr: +.. _onemath_blas_hpr: hpr === Computes a rank-1 update of a Hermitian packed matrix. -.. _onemkl_blas_hpr_description: +.. _onemath_blas_hpr_description: .. rubric:: Description @@ -40,7 +40,7 @@ where: * - ``std::complex`` - ``double`` -.. _onemkl_blas_hpr_buffer: +.. _onemath_blas_hpr_buffer: hpr (Buffer Version) -------------------- @@ -49,9 +49,9 @@ hpr (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void hpr(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, Treal alpha, sycl::buffer &x, @@ -60,9 +60,9 @@ hpr (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void hpr(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, Treal alpha, sycl::buffer &x, @@ -78,7 +78,7 @@ hpr (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -120,22 +120,22 @@ hpr (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_hpr_usm: +.. _onemath_blas_hpr_usm: hpr (USM Version) ----------------- @@ -144,9 +144,9 @@ hpr (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event hpr(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -156,9 +156,9 @@ hpr (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event hpr(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -175,7 +175,7 @@ hpr (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -229,20 +229,20 @@ hpr (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/hpr2.rst b/source/elements/oneMath/source/domains/blas/hpr2.rst similarity index 82% rename from source/elements/oneMKL/source/domains/blas/hpr2.rst rename to source/elements/oneMath/source/domains/blas/hpr2.rst index d0f263ceb8..ce5bb506ad 100644 --- a/source/elements/oneMKL/source/domains/blas/hpr2.rst +++ b/source/elements/oneMath/source/domains/blas/hpr2.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_hpr2: +.. _onemath_blas_hpr2: hpr2 ==== Performs a rank-2 update of a Hermitian packed matrix. -.. _onemkl_blas_hpr2_description: +.. _onemath_blas_hpr2_description: .. rubric:: Description @@ -37,7 +37,7 @@ where: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_hpr2_buffer: +.. _onemath_blas_hpr2_buffer: hpr2 (Buffer Version) --------------------- @@ -46,9 +46,9 @@ hpr2 (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void hpr2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &x, @@ -59,9 +59,9 @@ hpr2 (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void hpr2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &x, @@ -79,7 +79,7 @@ hpr2 (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -129,22 +129,22 @@ hpr2 (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_hpr2_usm: +.. _onemath_blas_hpr2_usm: hpr2 (USM Version) ------------------ @@ -153,9 +153,9 @@ hpr2 (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event hpr2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -167,9 +167,9 @@ hpr2 (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event hpr2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -188,7 +188,7 @@ hpr2 (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -251,20 +251,20 @@ hpr2 (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/iamax.rst b/source/elements/oneMath/source/domains/blas/iamax.rst similarity index 74% rename from source/elements/oneMKL/source/domains/blas/iamax.rst rename to source/elements/oneMath/source/domains/blas/iamax.rst index 708b940f5c..4cc5b4c6a9 100644 --- a/source/elements/oneMKL/source/domains/blas/iamax.rst +++ b/source/elements/oneMath/source/domains/blas/iamax.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_iamax: +.. _onemath_blas_iamax: iamax ===== Finds the index of the element with the largest absolute value in a vector. -.. _onemkl_blas_iamax_description: +.. _onemath_blas_iamax_description: .. rubric:: Description @@ -18,8 +18,8 @@ has the maximum absolute value of all elements in vector ``x`` (real variants), or such that (\|Re(``x[i]``)\| + \|Im(``x[i]``)\|) is maximal (complex variants). -The index is zero-based if ``base`` is set to ``oneapi::mkl::index_base::zero`` (default) -or one-based if it is set to ``oneapi::mkl::index_base::one``. +The index is zero-based if ``base`` is set to ``oneapi::math::index_base::zero`` (default) +or one-based if it is set to ``oneapi::math::index_base::one``. If either ``n`` or ``incx`` is not positive, the routine returns ``0``, regardless of the base of the index selected. @@ -41,7 +41,7 @@ index of the first ``NaN``. * - ``std::complex`` * - ``std:complex`` -.. _onemkl_blas_iamax_buffer: +.. _onemath_blas_iamax_buffer: iamax (Buffer Version) ---------------------- @@ -50,23 +50,23 @@ iamax (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void iamax(sycl::queue &queue, std::int64_t n, sycl::buffer &x, std::int64_t incx, sycl::buffer &result, - oneapi::mkl::index_base base = oneapi::mkl::index_base::zero) + oneapi::math::index_base base = oneapi::math::index_base::zero) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void iamax(sycl::queue &queue, std::int64_t n, sycl::buffer &x, std::int64_t incx, sycl::buffer &result, - oneapi::mkl::index_base base = oneapi::mkl::index_base::zero) + oneapi::math::index_base base = oneapi::math::index_base::zero) } .. container:: section @@ -105,22 +105,22 @@ iamax (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_iamax_usm: +.. _onemath_blas_iamax_usm: iamax (USM Version) ------------------- @@ -129,24 +129,24 @@ iamax (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event iamax(sycl::queue &queue, std::int64_t n, const T *x, std::int64_t incx, std::int64_t *result, - oneapi::mkl::index_base base = oneapi::mkl::index_base::zero, + oneapi::math::index_base base = oneapi::math::index_base::zero, const std::vector &dependencies = {}) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event iamax(sycl::queue &queue, std::int64_t n, const T *x, std::int64_t incx, std::int64_t *result, - oneapi::mkl::index_base base = oneapi::mkl::index_base::zero, + oneapi::math::index_base base = oneapi::math::index_base::zero, const std::vector &dependencies = {}) } @@ -197,20 +197,20 @@ iamax (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/iamin.rst b/source/elements/oneMath/source/domains/blas/iamin.rst similarity index 74% rename from source/elements/oneMKL/source/domains/blas/iamin.rst rename to source/elements/oneMath/source/domains/blas/iamin.rst index ca84466ded..031d5ebf97 100644 --- a/source/elements/oneMKL/source/domains/blas/iamin.rst +++ b/source/elements/oneMath/source/domains/blas/iamin.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_iamin: +.. _onemath_blas_iamin: iamin ===== Finds the index of the element with the smallest absolute value. -.. _onemkl_blas_iamin_description: +.. _onemath_blas_iamin_description: .. rubric:: Description @@ -18,8 +18,8 @@ the minimum absolute value of all elements in vector ``x`` (real variants), or such that (\|Re(``x[i]``)\| + \|Im(``x[i]``)\|) is minimal (complex variants). -The index is zero-based if ``base`` is set to ``oneapi::mkl::index_base::zero`` (default) -or one-based if it is set to ``oneapi::mkl::index_base::one``. +The index is zero-based if ``base`` is set to ``oneapi::math::index_base::zero`` (default) +or one-based if it is set to ``oneapi::math::index_base::one``. If either ``n`` or ``incx`` is not positive, the routine returns ``0``, regardless of the base of the index selected. @@ -42,7 +42,7 @@ index of the first ``NaN``. * - ``std::complex`` -.. _onemkl_blas_iamin_buffer: +.. _onemath_blas_iamin_buffer: iamin (Buffer Version) ---------------------- @@ -51,23 +51,23 @@ iamin (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void iamin(sycl::queue &queue, std::int64_t n, sycl::buffer &x, std::int64_t incx, sycl::buffer &result, - oneapi::mkl::index_base base = oneapi::mkl::index_base::zero) + oneapi::math::index_base base = oneapi::math::index_base::zero) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void iamin(sycl::queue &queue, std::int64_t n, sycl::buffer &x, std::int64_t incx, sycl::buffer &result, - oneapi::mkl::index_base base = oneapi::mkl::index_base::zero) + oneapi::math::index_base base = oneapi::math::index_base::zero) } .. container:: section @@ -106,22 +106,22 @@ iamin (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_iamin_usm: +.. _onemath_blas_iamin_usm: iamin (USM Version) ------------------- @@ -130,24 +130,24 @@ iamin (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event iamin(sycl::queue &queue, std::int64_t n, const T *x, std::int64_t incx, std::int64_t *result, - oneapi::mkl::index_base base = oneapi::mkl::index_base::zero, + oneapi::math::index_base base = oneapi::math::index_base::zero, const std::vector &dependencies = {}) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event iamin(sycl::queue &queue, std::int64_t n, const T *x, std::int64_t incx, std::int64_t *result, - oneapi::mkl::index_base base = oneapi::mkl::index_base::zero, + oneapi::math::index_base base = oneapi::math::index_base::zero, const std::vector &dependencies = {}) } @@ -198,20 +198,20 @@ iamin (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/imatcopy.rst b/source/elements/oneMath/source/domains/blas/imatcopy.rst similarity index 84% rename from source/elements/oneMKL/source/domains/blas/imatcopy.rst rename to source/elements/oneMath/source/domains/blas/imatcopy.rst index 5c8c0ecfbf..dc5c14bef5 100644 --- a/source/elements/oneMKL/source/domains/blas/imatcopy.rst +++ b/source/elements/oneMath/source/domains/blas/imatcopy.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_imatcopy: +.. _onemath_blas_imatcopy: imatcopy ======== @@ -10,7 +10,7 @@ imatcopy Computes an in-place scaled matrix transpose or copy operation using a general dense matrix. -.. _onemkl_blas_imatcopy_description: +.. _onemath_blas_imatcopy_description: .. rubric:: Description @@ -44,7 +44,7 @@ and ``C`` is ``m`` x ``n`` on input. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_imatcopy_buffer: +.. _onemath_blas_imatcopy_buffer: imatcopy (Buffer Version) ------------------------- @@ -53,9 +53,9 @@ imatcopy (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void imatcopy(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -65,9 +65,9 @@ imatcopy (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void imatcopy(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -85,7 +85,7 @@ imatcopy (Buffer Version) trans Specifies op(``C``), the transposition operation applied to the - matrix ``C``. See :ref:`onemkl_datatypes` for more details. + matrix ``C``. See :ref:`onemath_datatypes` for more details. m Number of rows of ``C`` on input. Must be at least zero. @@ -149,22 +149,22 @@ imatcopy (Buffer Version) implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_imatcopy_usm: +.. _onemath_blas_imatcopy_usm: imatcopy (USM Version) ---------------------- @@ -173,9 +173,9 @@ imatcopy (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event imatcopy(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -185,9 +185,9 @@ imatcopy (USM Version) const std::vector &dependencies = {}); .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event imatcopy(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -205,7 +205,7 @@ imatcopy (USM Version) trans Specifies op(``C``), the transposition operation applied to the - matrix ``C``. See :ref:`onemkl_datatypes` for more details. + matrix ``C``. See :ref:`onemath_datatypes` for more details. m Number of rows for the matrix ``C`` on input. Must be at least zero. @@ -280,19 +280,19 @@ imatcopy (USM Version) implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/imatcopy_batch.rst b/source/elements/oneMath/source/domains/blas/imatcopy_batch.rst similarity index 89% rename from source/elements/oneMKL/source/domains/blas/imatcopy_batch.rst rename to source/elements/oneMath/source/domains/blas/imatcopy_batch.rst index 5de027211f..7a74d616e1 100644 --- a/source/elements/oneMKL/source/domains/blas/imatcopy_batch.rst +++ b/source/elements/oneMath/source/domains/blas/imatcopy_batch.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_imatcopy_batch: +.. _onemath_blas_imatcopy_batch: imatcopy_batch ============== @@ -10,12 +10,12 @@ imatcopy_batch Computes a group of in-place scaled matrix transpose or copy operations using general dense matrices. -.. _onemkl_blas_imatcopy_batch_description: +.. _onemath_blas_imatcopy_batch_description: .. rubric:: Description The ``imatcopy_batch`` routines perform a series of in-place scaled matrix -copies or transpositions. They are batched versions of :ref:`onemkl_blas_imatcopy`, +copies or transpositions. They are batched versions of :ref:`onemath_blas_imatcopy`, but the ``imatcopy_batch`` routines perform their operations with groups of matrices. Each group contains matrices with the same parameters. @@ -53,7 +53,7 @@ and buffer memory. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_imatcopy_batch_buffer: +.. _onemath_blas_imatcopy_batch_buffer: imatcopy_batch (Buffer Version) ------------------------------- @@ -91,9 +91,9 @@ parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void imatcopy_batch(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -105,9 +105,9 @@ parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void imatcopy_batch(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -127,7 +127,7 @@ parameter. trans Specifies op(``C``), the transposition operation applied to the - matrices ``C``. See :ref:`onemkl_datatypes` for more details. + matrices ``C``. See :ref:`onemath_datatypes` for more details. m Number of rows of each matrix ``C`` on input. Must be at least zero. @@ -199,22 +199,22 @@ parameter. implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_imatcopy_batch_usm: +.. _onemath_blas_imatcopy_batch_usm: imatcopy_batch (USM Version) ---------------------------- @@ -274,9 +274,9 @@ matrices is given by the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { event imatcopy_batch(sycl::queue &queue, - const oneapi::mkl::transpose *trans_array, + const oneapi::math::transpose *trans_array, const std::int64_t *m_array, const std::int64_t *n_array, const T *alpha_array, @@ -289,9 +289,9 @@ matrices is given by the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { event imatcopy_batch(sycl::queue &queue, - const oneapi::mkl::transpose *trans_array, + const oneapi::math::transpose *trans_array, const std::int64_t *m_array, const std::int64_t *n_array, const T *alpha_array, @@ -381,9 +381,9 @@ matrices is given by the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event imatcopy_batch(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -395,9 +395,9 @@ matrices is given by the ``batch_size`` parameter. const std::vector &dependencies = {}); .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event imatcopy_batch(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -491,19 +491,19 @@ matrices is given by the ``batch_size`` parameter. implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/nrm2.rst b/source/elements/oneMath/source/domains/blas/nrm2.rst similarity index 78% rename from source/elements/oneMKL/source/domains/blas/nrm2.rst rename to source/elements/oneMath/source/domains/blas/nrm2.rst index 537360cf97..85e78c61c7 100644 --- a/source/elements/oneMKL/source/domains/blas/nrm2.rst +++ b/source/elements/oneMath/source/domains/blas/nrm2.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_nrm2: +.. _onemath_blas_nrm2: nrm2 ==== Computes the Euclidean norm of a vector. -.. _onemkl_blas_nrm2_description: +.. _onemath_blas_nrm2_description: .. rubric:: Description @@ -43,7 +43,7 @@ where: * - ``std::complex`` - ``double`` -.. _onemkl_blas_nrm2_buffer: +.. _onemath_blas_nrm2_buffer: nrm2 (Buffer Version) --------------------- @@ -52,7 +52,7 @@ nrm2 (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void nrm2(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -61,7 +61,7 @@ nrm2 (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void nrm2(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -101,22 +101,22 @@ nrm2 (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_nrm2_usm: +.. _onemath_blas_nrm2_usm: nrm2 (USM Version) ------------------ @@ -125,7 +125,7 @@ nrm2 (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event nrm2(sycl::queue &queue, std::int64_t n, const T *x, @@ -135,7 +135,7 @@ nrm2 (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event nrm2(sycl::queue &queue, std::int64_t n, const T *x, @@ -187,20 +187,20 @@ nrm2 (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/omatadd.rst b/source/elements/oneMath/source/domains/blas/omatadd.rst similarity index 87% rename from source/elements/oneMKL/source/domains/blas/omatadd.rst rename to source/elements/oneMath/source/domains/blas/omatadd.rst index 953e572791..ee07bfcb5e 100644 --- a/source/elements/oneMKL/source/domains/blas/omatadd.rst +++ b/source/elements/oneMath/source/domains/blas/omatadd.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_omatadd: +.. _onemath_blas_omatadd: omatadd ======= Computes a sum of two general dense matrices, with optional transposes. -.. _onemkl_blas_omatadd_description: +.. _onemath_blas_omatadd_description: .. rubric:: Description @@ -54,7 +54,7 @@ the following in-place operations: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_omatadd_buffer: +.. _onemath_blas_omatadd_buffer: omatadd (Buffer Version) ------------------------ @@ -63,10 +63,10 @@ omatadd (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void omatadd(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, T alpha, @@ -80,10 +80,10 @@ omatadd (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void omatadd(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, T alpha, @@ -105,11 +105,11 @@ omatadd (Buffer Version) transa Specifies op(``A``), the transposition operation applied to the - matrix ``A``. See :ref:`onemkl_datatypes` for more details. + matrix ``A``. See :ref:`onemath_datatypes` for more details. transb Specifies op(``B``), the transposition operation applied to the - matrix ``B``. See :ref:`onemkl_datatypes` for more details. + matrix ``B``. See :ref:`onemath_datatypes` for more details. m Number of rows for the result matrix ``C``. Must be at least zero. @@ -219,22 +219,22 @@ omatadd (Buffer Version) implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_omatadd_usm: +.. _onemath_blas_omatadd_usm: omatadd (USM Version) --------------------- @@ -243,10 +243,10 @@ omatadd (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event omatadd(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -261,10 +261,10 @@ omatadd (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event omatadd(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -287,11 +287,11 @@ omatadd (USM Version) transa Specifies op(``A``), the transposition operation applied to the - matrix ``A``. See :ref:`onemkl_datatypes` for more details. + matrix ``A``. See :ref:`onemath_datatypes` for more details. transb Specifies op(``B``), the transposition operation applied to the - matrix ``B``. See :ref:`onemkl_datatypes` for more details. + matrix ``B``. See :ref:`onemath_datatypes` for more details. m Number of rows for the result matrix ``C``. Must be at least zero. @@ -411,19 +411,19 @@ omatadd (USM Version) implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/omatadd_batch.rst b/source/elements/oneMath/source/domains/blas/omatadd_batch.rst similarity index 91% rename from source/elements/oneMKL/source/domains/blas/omatadd_batch.rst rename to source/elements/oneMath/source/domains/blas/omatadd_batch.rst index 200acbaae6..63ba47159c 100644 --- a/source/elements/oneMKL/source/domains/blas/omatadd_batch.rst +++ b/source/elements/oneMath/source/domains/blas/omatadd_batch.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_omatadd_batch: +.. _onemath_blas_omatadd_batch: omatadd_batch ============= @@ -10,12 +10,12 @@ omatadd_batch Computes a group of out-of-place scaled matrix additions using general dense matrices. -.. _onemkl_blas_omatadd_batch_description: +.. _onemath_blas_omatadd_batch_description: .. rubric:: Description The ``omatadd_batch`` routines perform a series of out-of-place scaled matrix -additions. They are batched versions of :ref:`onemkl_blas_omatadd`, +additions. They are batched versions of :ref:`onemath_blas_omatadd`, but the ``omatadd_batch`` routines perform their operations with groups of matrices. Each group contains matrices with the same parameters. @@ -53,7 +53,7 @@ and buffer memory. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_omatadd_batch_buffer: +.. _onemath_blas_omatadd_batch_buffer: omatadd_batch (Buffer Version) ------------------------------ @@ -106,10 +106,10 @@ memory, with the exception of the following in-place operations: .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void omatadd_batch(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, T alpha, @@ -127,10 +127,10 @@ memory, with the exception of the following in-place operations: } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void omatadd_batch(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, T alpha, @@ -156,11 +156,11 @@ memory, with the exception of the following in-place operations: transa Specifies op(``A``), the transposition operation applied to the - matrices ``A``. See :ref:`onemkl_datatypes` for more details. + matrices ``A``. See :ref:`onemath_datatypes` for more details. transb Specifies op(``B``), the transposition operation applied to the - matrices ``B``. See :ref:`onemkl_datatypes` for more details. + matrices ``B``. See :ref:`onemath_datatypes` for more details. m Number of rows for the result matrix ``C``. Must be at least zero. @@ -282,22 +282,22 @@ memory, with the exception of the following in-place operations: implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_omatadd_batch_usm: +.. _onemath_blas_omatadd_batch_usm: omatadd_batch (USM Version) --------------------------- @@ -373,10 +373,10 @@ in-place operations: .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event omatadd_batch(sycl::queue &queue, - const oneapi::mkl::transpose *transa_array, - const oneapi::mkl::transpose *transb_array, + const oneapi::math::transpose *transa_array, + const oneapi::math::transpose *transb_array, const std::int64_t *m_array, const std::int64_t *n_array, const T *alpha_array, @@ -393,10 +393,10 @@ in-place operations: } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event omatadd_batch(sycl::queue &queue, - const oneapi::mkl::transpose *transa_array, - const oneapi::mkl::transpose *transb_array, + const oneapi::math::transpose *transa_array, + const oneapi::math::transpose *transb_array, const std::int64_t *m_array, const std::int64_t *n_array, const T *alpha_array, @@ -564,10 +564,10 @@ in-place operations: .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event omatadd_batch(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -586,10 +586,10 @@ in-place operations: } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event omatadd_batch(sycl::queue &queue, - oneapi::mkl::transpose transa, - oneapi::mkl::transpose transb, + oneapi::math::transpose transa, + oneapi::math::transpose transb, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -616,11 +616,11 @@ in-place operations: transa Specifies op(``A``), the transposition operation applied to the - matrices ``A``. See :ref:`onemkl_datatypes` for more details. + matrices ``A``. See :ref:`onemath_datatypes` for more details. transb Specifies op(``B``), the transposition operation applied to the - matrices ``B``. See :ref:`onemkl_datatypes` for more details. + matrices ``B``. See :ref:`onemath_datatypes` for more details. m Number of rows for the result matrix ``C``. Must be at least zero. @@ -752,19 +752,19 @@ in-place operations: implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/omatcopy.rst b/source/elements/oneMath/source/domains/blas/omatcopy.rst similarity index 84% rename from source/elements/oneMKL/source/domains/blas/omatcopy.rst rename to source/elements/oneMath/source/domains/blas/omatcopy.rst index b0d99f9bdd..af5f9dc148 100644 --- a/source/elements/oneMKL/source/domains/blas/omatcopy.rst +++ b/source/elements/oneMath/source/domains/blas/omatcopy.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_omatcopy: +.. _onemath_blas_omatcopy: omatcopy ======== @@ -10,7 +10,7 @@ omatcopy Computes an out-of-place scaled matrix transpose or copy operation using a general dense matrix. -.. _onemkl_blas_omatcopy_description: +.. _onemath_blas_omatcopy_description: .. rubric:: Description @@ -46,7 +46,7 @@ op(``X``) is one of op(``X``) = ``X``, or op(``X``) = ``X``\ :sup:`T`, or op(``X * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_omatcopy_buffer: +.. _onemath_blas_omatcopy_buffer: omatcopy (Buffer Version) ------------------------- @@ -55,9 +55,9 @@ omatcopy (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void omatcopy(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -68,9 +68,9 @@ omatcopy (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void omatcopy(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -89,7 +89,7 @@ omatcopy (Buffer Version) trans Specifies op(``A``), the transposition operation applied to the - matrix ``A``. See :ref:`onemkl_datatypes` for more details. + matrix ``A``. See :ref:`onemath_datatypes` for more details. m Number of rows for the matrix ``A``. Must be at least zero. @@ -158,22 +158,22 @@ omatcopy (Buffer Version) implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_omatcopy_usm: +.. _onemath_blas_omatcopy_usm: omatcopy (USM Version) ---------------------- @@ -182,9 +182,9 @@ omatcopy (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event omatcopy(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -196,9 +196,9 @@ omatcopy (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event omatcopy(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -218,7 +218,7 @@ omatcopy (USM Version) trans Specifies op(``A``), the transposition operation applied to the - matrix ``A``. See :ref:`onemkl_datatypes` for more details. + matrix ``A``. See :ref:`onemath_datatypes` for more details. m Number of rows for the matrix ``A``. Must be at least zero. @@ -297,19 +297,19 @@ omatcopy (USM Version) implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/omatcopy2.rst b/source/elements/oneMath/source/domains/blas/omatcopy2.rst similarity index 88% rename from source/elements/oneMKL/source/domains/blas/omatcopy2.rst rename to source/elements/oneMath/source/domains/blas/omatcopy2.rst index 302f321f0e..30c9858bc5 100644 --- a/source/elements/oneMKL/source/domains/blas/omatcopy2.rst +++ b/source/elements/oneMath/source/domains/blas/omatcopy2.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_omatcopy2: +.. _onemath_blas_omatcopy2: omatcopy2 ========= @@ -10,7 +10,7 @@ omatcopy2 Computes two-strided scaling and out-of-place transposition or copying of general dense matrices. -.. _onemkl_blas_omatcopy2_description: +.. _onemath_blas_omatcopy2_description: .. rubric:: Description @@ -54,7 +54,7 @@ op(``X``) is one of op(``X``) = ``X``, or op(``X``) = ``X``\ :sup:`T`, or op(``X * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_omatcopy2_buffer: +.. _onemath_blas_omatcopy2_buffer: omatcopy2 (Buffer Version) -------------------------- @@ -63,9 +63,9 @@ omatcopy2 (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void omatcopy2(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -78,9 +78,9 @@ omatcopy2 (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void omatcopy2(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -101,7 +101,7 @@ omatcopy2 (Buffer Version) trans Specifies op(``A``), the transposition operation applied to the - matrix ``A``. See :ref:`onemkl_datatypes` for more details. + matrix ``A``. See :ref:`onemath_datatypes` for more details. m Number of rows for the matrix ``A``. Must be at least zero. @@ -184,22 +184,22 @@ omatcopy2 (Buffer Version) implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_omatcopy2_usm: +.. _onemath_blas_omatcopy2_usm: omatcopy2 (USM Version) ----------------------- @@ -208,9 +208,9 @@ omatcopy2 (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event omatcopy2(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -224,9 +224,9 @@ omatcopy2 (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event omatcopy2(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -248,7 +248,7 @@ omatcopy2 (USM Version) trans Specifies op(``A``), the transposition operation applied to matrix ``A``. - See :ref:`onemkl_datatypes` for more details. + See :ref:`onemath_datatypes` for more details. m Number of rows for the matrix ``A``. Must be at least zero. @@ -340,19 +340,19 @@ omatcopy2 (USM Version) implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/omatcopy_batch.rst b/source/elements/oneMath/source/domains/blas/omatcopy_batch.rst similarity index 91% rename from source/elements/oneMKL/source/domains/blas/omatcopy_batch.rst rename to source/elements/oneMath/source/domains/blas/omatcopy_batch.rst index c361b3d304..1e9182eb81 100644 --- a/source/elements/oneMKL/source/domains/blas/omatcopy_batch.rst +++ b/source/elements/oneMath/source/domains/blas/omatcopy_batch.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_omatcopy_batch: +.. _onemath_blas_omatcopy_batch: omatcopy_batch ============== @@ -10,12 +10,12 @@ omatcopy_batch Computes a group of out-of-place scaled matrix transpose or copy operations using general dense matrices. -.. _onemkl_blas_omatcopy_batch_description: +.. _onemath_blas_omatcopy_batch_description: .. rubric:: Description The ``omatcopy_batch`` routines perform a series of out-of-place scaled matrix -copies or transpositions. They are batched versions of :ref:`onemkl_blas_omatcopy`, +copies or transpositions. They are batched versions of :ref:`onemath_blas_omatcopy`, but the ``omatcopy_batch`` routines perform their operations with groups of matrices. Each group contains matrices with the same parameters. @@ -53,7 +53,7 @@ and buffer memory. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_omatcopy_batch_buffer: +.. _onemath_blas_omatcopy_batch_buffer: omatcopy_batch (Buffer Version) ------------------------------- @@ -94,9 +94,9 @@ each buffer is given by the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void omatcopy_batch(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -110,9 +110,9 @@ each buffer is given by the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void omatcopy_batch(sycl::queue &queue, - oneapi::mkl::transpose trans, + oneapi::math::transpose trans, std::int64_t m, std::int64_t n, T alpha, @@ -134,7 +134,7 @@ each buffer is given by the ``batch_size`` parameter. trans Specifies op(``A``), the transposition operation applied to the - matrices ``A``. See :ref:`onemkl_datatypes` for more details. + matrices ``A``. See :ref:`onemath_datatypes` for more details. m Number of rows for each matrix ``A``. Must be at least zero. @@ -214,22 +214,22 @@ each buffer is given by the ``batch_size`` parameter. implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_omatcopy_batch_usm: +.. _onemath_blas_omatcopy_batch_usm: omatcopy_batch (USM Version) ---------------------------- @@ -292,9 +292,9 @@ the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event omatcopy_batch(sycl::queue &queue, - const oneapi::mkl::transpose *trans_array, + const oneapi::math::transpose *trans_array, const std::int64_t *m_array, const std::int64_t *n_array, const T *alpha_array, @@ -308,9 +308,9 @@ the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event omatcopy_batch(sycl::queue &queue, - const oneapi::mkl::transpose *trans_array, + const oneapi::math::transpose *trans_array, const std::int64_t *m_array, const std::int64_t *n_array, const T *alpha_array, @@ -425,7 +425,7 @@ the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { event omatcopy_batch(queue &queue, transpose trans, std::int64_t m, @@ -442,7 +442,7 @@ the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { event omatcopy_batch(queue &queue, transpose trans, std::int64_t m, @@ -560,19 +560,19 @@ the ``batch_size`` parameter. implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/rot.rst b/source/elements/oneMath/source/domains/blas/rot.rst similarity index 82% rename from source/elements/oneMKL/source/domains/blas/rot.rst rename to source/elements/oneMath/source/domains/blas/rot.rst index f7e4b46a0b..63af867488 100644 --- a/source/elements/oneMKL/source/domains/blas/rot.rst +++ b/source/elements/oneMath/source/domains/blas/rot.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_rot: +.. _onemath_blas_rot: rot === Performs rotation of points in the plane. -.. _onemkl_blas_rot_description: +.. _onemath_blas_rot_description: .. rubric:: Description @@ -51,9 +51,9 @@ If ``s`` is a complex type, the operation is defined as: * - ``sycl::half`` - ``sycl::half`` - ``sycl::half`` - * - ``oneapi::mkl::bfloat16`` - - ``oneapi::mkl::bfloat16`` - - ``oneapi::mkl::bfloat16`` + * - ``oneapi::math::bfloat16`` + - ``oneapi::math::bfloat16`` + - ``oneapi::math::bfloat16`` * - ``float`` - ``float`` - ``float`` @@ -73,7 +73,7 @@ If ``s`` is a complex type, the operation is defined as: - ``double`` - ``double`` -.. _onemkl_blas_rot_buffer: +.. _onemath_blas_rot_buffer: rot (Buffer Version) -------------------- @@ -82,7 +82,7 @@ rot (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void rot(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -94,7 +94,7 @@ rot (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void rot(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -153,22 +153,22 @@ rot (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_rot_usm: +.. _onemath_blas_rot_usm: rot (USM Version) ----------------- @@ -177,7 +177,7 @@ rot (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event rot(sycl::queue &queue, std::int64_t n, T *x, @@ -190,7 +190,7 @@ rot (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event rot(sycl::queue &queue, std::int64_t n, T *x, @@ -262,20 +262,20 @@ rot (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/rotg.rst b/source/elements/oneMath/source/domains/blas/rotg.rst similarity index 80% rename from source/elements/oneMKL/source/domains/blas/rotg.rst rename to source/elements/oneMath/source/domains/blas/rotg.rst index 0409a2a02f..7d47466c3e 100644 --- a/source/elements/oneMKL/source/domains/blas/rotg.rst +++ b/source/elements/oneMath/source/domains/blas/rotg.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_rotg: +.. _onemath_blas_rotg: rotg ==== Computes the parameters for a Givens rotation. -.. _onemkl_blas_rotg_description: +.. _onemath_blas_rotg_description: .. rubric:: Description @@ -44,7 +44,7 @@ The parameter ``z`` is defined such that if \|\ ``a``\ \| > * - ``std::complex`` - ``double`` -.. _onemkl_blas_rotg_buffer: +.. _onemath_blas_rotg_buffer: rotg (Buffer Version) --------------------- @@ -53,7 +53,7 @@ rotg (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void rotg(sycl::queue &queue, sycl::buffer &a, sycl::buffer &b, @@ -62,7 +62,7 @@ rotg (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void rotg(sycl::queue &queue, sycl::buffer &a, sycl::buffer &b, @@ -109,22 +109,22 @@ rotg (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_rotg_usm: +.. _onemath_blas_rotg_usm: rotg (USM Version) ------------------ @@ -133,7 +133,7 @@ rotg (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event rotg(sycl::queue &queue, T *a, T *b, @@ -143,7 +143,7 @@ rotg (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event rotg(sycl::queue &queue, T *a, T *b, @@ -201,20 +201,20 @@ rotg (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/rotm.rst b/source/elements/oneMath/source/domains/blas/rotm.rst similarity index 86% rename from source/elements/oneMKL/source/domains/blas/rotm.rst rename to source/elements/oneMath/source/domains/blas/rotm.rst index fde25b6ae0..f3fc2ae2be 100644 --- a/source/elements/oneMKL/source/domains/blas/rotm.rst +++ b/source/elements/oneMath/source/domains/blas/rotm.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_rotm: +.. _onemath_blas_rotm: rotm ==== Performs modified Givens rotation of points in the plane. -.. _onemkl_blas_rotm_description: +.. _onemath_blas_rotm_description: .. rubric:: Description @@ -34,7 +34,7 @@ transformation matrix. * - ``float`` * - ``double`` -.. _onemkl_blas_rotm_buffer: +.. _onemath_blas_rotm_buffer: rotm (Buffer Version) --------------------- @@ -43,7 +43,7 @@ rotm (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void rotm(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -54,7 +54,7 @@ rotm (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void rotm(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -148,22 +148,22 @@ rotm (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_rotm_usm: +.. _onemath_blas_rotm_usm: rotm (USM Version) ------------------ @@ -172,7 +172,7 @@ rotm (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event rotm(sycl::queue &queue, std::int64_t n, T *x, @@ -184,7 +184,7 @@ rotm (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event rotm(sycl::queue &queue, std::int64_t n, T *x, @@ -291,20 +291,20 @@ rotm (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/rotmg.rst b/source/elements/oneMath/source/domains/blas/rotmg.rst similarity index 86% rename from source/elements/oneMKL/source/domains/blas/rotmg.rst rename to source/elements/oneMath/source/domains/blas/rotmg.rst index 2474a105e4..511a787c39 100644 --- a/source/elements/oneMKL/source/domains/blas/rotmg.rst +++ b/source/elements/oneMath/source/domains/blas/rotmg.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_rotmg: +.. _onemath_blas_rotmg: rotmg ===== Computes the parameters for a modified Givens rotation. -.. _onemkl_blas_rotmg_description: +.. _onemath_blas_rotmg_description: .. rubric:: Description @@ -33,7 +33,7 @@ the resulting vector: * - ``float`` * - ``double`` -.. _onemkl_blas_rotmg_buffer: +.. _onemath_blas_rotmg_buffer: rotmg (Buffer Version) ---------------------- @@ -42,7 +42,7 @@ rotmg (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void rotmg(sycl::queue &queue, sycl::buffer &d1, sycl::buffer &d2, @@ -52,7 +52,7 @@ rotmg (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void rotmg(sycl::queue &queue, sycl::buffer &d1, sycl::buffer &d2, @@ -144,22 +144,22 @@ rotmg (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_rotmg_usm: +.. _onemath_blas_rotmg_usm: rotmg (USM Version) ------------------- @@ -168,7 +168,7 @@ rotmg (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event rotmg(sycl::queue &queue, T *d1, T *d2, @@ -179,7 +179,7 @@ rotmg (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event rotmg(sycl::queue &queue, T *d1, T *d2, @@ -282,20 +282,20 @@ rotmg (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/sbmv.rst b/source/elements/oneMath/source/domains/blas/sbmv.rst similarity index 82% rename from source/elements/oneMKL/source/domains/blas/sbmv.rst rename to source/elements/oneMath/source/domains/blas/sbmv.rst index aad42517f5..4589c89525 100644 --- a/source/elements/oneMKL/source/domains/blas/sbmv.rst +++ b/source/elements/oneMath/source/domains/blas/sbmv.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_sbmv: +.. _onemath_blas_sbmv: sbmv ==== Computes a matrix-vector product with a symmetric band matrix. -.. _onemkl_blas_sbmv_description: +.. _onemath_blas_sbmv_description: .. rubric:: Description @@ -39,7 +39,7 @@ super-diagonals, * - ``float`` * - ``double`` -.. _onemkl_blas_sbmv_buffer: +.. _onemath_blas_sbmv_buffer: sbmv (Buffer Version) --------------------- @@ -48,9 +48,9 @@ sbmv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void sbmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t k, T alpha, @@ -64,9 +64,9 @@ sbmv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void sbmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t k, T alpha, @@ -87,7 +87,7 @@ sbmv (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -140,22 +140,22 @@ sbmv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_sbmv_usm: +.. _onemath_blas_sbmv_usm: sbmv (USM Version) ------------------ @@ -164,9 +164,9 @@ sbmv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event sbmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -181,9 +181,9 @@ sbmv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event sbmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -205,7 +205,7 @@ sbmv (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -270,20 +270,20 @@ sbmv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/scal.rst b/source/elements/oneMath/source/domains/blas/scal.rst similarity index 78% rename from source/elements/oneMKL/source/domains/blas/scal.rst rename to source/elements/oneMath/source/domains/blas/scal.rst index bef42a9e46..c74ada279a 100644 --- a/source/elements/oneMKL/source/domains/blas/scal.rst +++ b/source/elements/oneMath/source/domains/blas/scal.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_scal: +.. _onemath_blas_scal: scal ==== Computes the product of a vector by a scalar. -.. _onemkl_blas_scal_description: +.. _onemath_blas_scal_description: .. rubric:: Description @@ -49,7 +49,7 @@ where: * - ``std::complex`` - ``double`` -.. _onemkl_blas_scal_buffer: +.. _onemath_blas_scal_buffer: scal (Buffer Version) --------------------- @@ -58,7 +58,7 @@ scal (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void scal(sycl::queue &queue, std::int64_t n, Ts alpha, @@ -67,7 +67,7 @@ scal (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void scal(sycl::queue &queue, std::int64_t n, Ts alpha, @@ -109,22 +109,22 @@ scal (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_scal_usm: +.. _onemath_blas_scal_usm: scal (USM Version) ------------------ @@ -133,7 +133,7 @@ scal (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event scal(sycl::queue &queue, std::int64_t n, value_or_pointer alpha, @@ -143,7 +143,7 @@ scal (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event scal(sycl::queue &queue, std::int64_t n, value_or_pointer alpha, @@ -192,20 +192,20 @@ scal (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/sdsdot.rst b/source/elements/oneMath/source/domains/blas/sdsdot.rst similarity index 81% rename from source/elements/oneMKL/source/domains/blas/sdsdot.rst rename to source/elements/oneMath/source/domains/blas/sdsdot.rst index c606e4cdd1..1406441243 100644 --- a/source/elements/oneMKL/source/domains/blas/sdsdot.rst +++ b/source/elements/oneMath/source/domains/blas/sdsdot.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_sdsdot: +.. _onemath_blas_sdsdot: sdsdot ====== Computes a vector-vector dot product with double precision. -.. _onemkl_blas_sdsdot_description: +.. _onemath_blas_sdsdot_description: .. rubric:: Description @@ -20,7 +20,7 @@ double precision: result = sb + \sum_{i=1}^{n}X_iY_i -.. _onemkl_blas_sdsdot_buffer: +.. _onemath_blas_sdsdot_buffer: sdsdot (Buffer Version) ----------------------- @@ -29,7 +29,7 @@ sdsdot (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void sdsdot(sycl::queue &queue, std::int64_t n, float sb, @@ -41,7 +41,7 @@ sdsdot (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void sdsdot(sycl::queue &queue, std::int64_t n, float sb, @@ -95,22 +95,22 @@ sdsdot (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_sdsdot_usm: +.. _onemath_blas_sdsdot_usm: sdsdot (USM Version) -------------------- @@ -119,7 +119,7 @@ sdsdot (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event sdsdot(sycl::queue &queue, std::int64_t n, float sb, @@ -132,7 +132,7 @@ sdsdot (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event sdsdot(sycl::queue &queue, std::int64_t n, float sb, @@ -197,20 +197,20 @@ sdsdot (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/spmv.rst b/source/elements/oneMath/source/domains/blas/spmv.rst similarity index 81% rename from source/elements/oneMKL/source/domains/blas/spmv.rst rename to source/elements/oneMath/source/domains/blas/spmv.rst index d3bf3b72da..09242b6580 100644 --- a/source/elements/oneMKL/source/domains/blas/spmv.rst +++ b/source/elements/oneMath/source/domains/blas/spmv.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_spmv: +.. _onemath_blas_spmv: spmv ==== Computes a matrix-vector product with a symmetric packed matrix. -.. _onemkl_blas_spmv_description: +.. _onemath_blas_spmv_description: .. rubric:: Description @@ -38,7 +38,7 @@ where: * - ``float`` * - ``double`` -.. _onemkl_blas_spmv_buffer: +.. _onemath_blas_spmv_buffer: spmv (Buffer Version) --------------------- @@ -47,9 +47,9 @@ spmv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void spmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &a, @@ -61,9 +61,9 @@ spmv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void spmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &a, @@ -82,7 +82,7 @@ spmv (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -127,22 +127,22 @@ spmv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_spmv_usm: +.. _onemath_blas_spmv_usm: spmv (USM Version) ------------------ @@ -151,9 +151,9 @@ spmv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event spmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *a, @@ -166,9 +166,9 @@ spmv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event spmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *a, @@ -188,7 +188,7 @@ spmv (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -246,20 +246,20 @@ spmv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/spr.rst b/source/elements/oneMath/source/domains/blas/spr.rst similarity index 78% rename from source/elements/oneMKL/source/domains/blas/spr.rst rename to source/elements/oneMath/source/domains/blas/spr.rst index 595c8f64e6..e23d0f12e4 100644 --- a/source/elements/oneMKL/source/domains/blas/spr.rst +++ b/source/elements/oneMath/source/domains/blas/spr.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_spr: +.. _onemath_blas_spr: spr === Performs a rank-1 update of a symmetric packed matrix. -.. _onemkl_blas_spr_description: +.. _onemath_blas_spr_description: .. rubric:: Description @@ -37,7 +37,7 @@ where: * - ``float`` * - ``double`` -.. _onemkl_blas_spr_buffer: +.. _onemath_blas_spr_buffer: spr (Buffer Version) -------------------- @@ -46,9 +46,9 @@ spr (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void spr(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::std::int64_t n, T alpha, sycl::buffer &x, @@ -57,9 +57,9 @@ spr (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void spr(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::std::int64_t n, T alpha, sycl::buffer &x, @@ -75,7 +75,7 @@ spr (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -113,22 +113,22 @@ spr (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_spr_usm: +.. _onemath_blas_spr_usm: spr (USM Version) ----------------- @@ -137,9 +137,9 @@ spr (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event spr(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -149,9 +149,9 @@ spr (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event spr(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -168,7 +168,7 @@ spr (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -217,20 +217,20 @@ spr (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/spr2.rst b/source/elements/oneMath/source/domains/blas/spr2.rst similarity index 81% rename from source/elements/oneMKL/source/domains/blas/spr2.rst rename to source/elements/oneMath/source/domains/blas/spr2.rst index 49a495108b..09244c2dda 100644 --- a/source/elements/oneMKL/source/domains/blas/spr2.rst +++ b/source/elements/oneMath/source/domains/blas/spr2.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_spr2: +.. _onemath_blas_spr2: spr2 ==== Computes a rank-2 update of a symmetric packed matrix. -.. _onemkl_blas_spr2_description: +.. _onemath_blas_spr2_description: .. rubric:: Description @@ -37,7 +37,7 @@ where: * - ``float`` * - ``double`` -.. _onemkl_blas_spr2_buffer: +.. _onemath_blas_spr2_buffer: spr2 (Buffer Version) --------------------- @@ -46,9 +46,9 @@ spr2 (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void spr2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &x, @@ -59,9 +59,9 @@ spr2 (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void spr2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &x, @@ -79,7 +79,7 @@ spr2 (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -124,22 +124,22 @@ spr2 (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_spr2_usm: +.. _onemath_blas_spr2_usm: spr2 (USM Version) ------------------ @@ -148,9 +148,9 @@ spr2 (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event spr2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -162,9 +162,9 @@ spr2 (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event spr2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -183,7 +183,7 @@ spr2 (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -241,20 +241,20 @@ spr2 (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/swap.rst b/source/elements/oneMath/source/domains/blas/swap.rst similarity index 81% rename from source/elements/oneMKL/source/domains/blas/swap.rst rename to source/elements/oneMath/source/domains/blas/swap.rst index 0f01714e40..d8da26d1a5 100644 --- a/source/elements/oneMKL/source/domains/blas/swap.rst +++ b/source/elements/oneMath/source/domains/blas/swap.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_swap: +.. _onemath_blas_swap: swap ==== Swaps a vector with another vector. -.. _onemkl_blas_swap_description: +.. _onemath_blas_swap_description: .. rubric:: Description @@ -38,7 +38,7 @@ other. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_swap_buffer: +.. _onemath_blas_swap_buffer: swap (Buffer Version) --------------------- @@ -47,7 +47,7 @@ swap (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void swap(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -57,7 +57,7 @@ swap (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void swap(sycl::queue &queue, std::int64_t n, sycl::buffer &x, @@ -110,22 +110,22 @@ swap (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_swap_usm: +.. _onemath_blas_swap_usm: swap (USM Version) ------------------ @@ -134,7 +134,7 @@ swap (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event swap(sycl::queue &queue, std::int64_t n, T *x, @@ -145,7 +145,7 @@ swap (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event swap(sycl::queue &queue, std::int64_t n, T *x, @@ -209,20 +209,20 @@ swap (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-1-routines` diff --git a/source/elements/oneMKL/source/domains/blas/symm.rst b/source/elements/oneMath/source/domains/blas/symm.rst similarity index 84% rename from source/elements/oneMKL/source/domains/blas/symm.rst rename to source/elements/oneMath/source/domains/blas/symm.rst index f65bca11fa..929ada9579 100644 --- a/source/elements/oneMKL/source/domains/blas/symm.rst +++ b/source/elements/oneMath/source/domains/blas/symm.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_symm: +.. _onemath_blas_symm: symm ==== @@ -10,7 +10,7 @@ symm Computes a matrix-matrix product where one input matrix is symmetric and one matrix is general. -.. _onemkl_blas_symm_description: +.. _onemath_blas_symm_description: .. rubric:: Description @@ -51,7 +51,7 @@ where: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_symm_buffer: +.. _onemath_blas_symm_buffer: symm (Buffer Version) --------------------- @@ -60,10 +60,10 @@ symm (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void symm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, std::int64_t m, std::int64_t n, T alpha, @@ -77,10 +77,10 @@ symm (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void symm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, std::int64_t m, std::int64_t n, T alpha, @@ -102,11 +102,11 @@ symm (Buffer Version) left_right Specifies whether ``A`` is on the left side of the multiplication - (``side::left``) or on the right side (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::left``) or on the right side (``side::right``). See :ref:`onemath_datatypes` for more details. upper_lower Specifies whether ``A``'s data is stored in its upper or lower - triangle. See :ref:`onemkl_datatypes` for more details. + triangle. See :ref:`onemath_datatypes` for more details. m Number of rows of ``B`` and ``C``. The value of ``m`` must be at @@ -179,22 +179,22 @@ symm (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_symm_usm: +.. _onemath_blas_symm_usm: symm (USM Version) ------------------ @@ -203,10 +203,10 @@ symm (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event symm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -221,10 +221,10 @@ symm (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event symm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -248,11 +248,11 @@ symm (USM Version) left_right Specifies whether ``A`` is on the left side of the multiplication (``side::left``) or on the right side - (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::right``). See :ref:`onemath_datatypes` for more details. upper_lower Specifies whether ``A``'s data is stored in its upper or lower - triangle. See :ref:`onemkl_datatypes` for more details. + triangle. See :ref:`onemath_datatypes` for more details. m Number of rows of ``B`` and ``C``. The value of ``m`` must be @@ -337,20 +337,20 @@ symm (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-3-routines` diff --git a/source/elements/oneMKL/source/domains/blas/symv.rst b/source/elements/oneMath/source/domains/blas/symv.rst similarity index 82% rename from source/elements/oneMKL/source/domains/blas/symv.rst rename to source/elements/oneMath/source/domains/blas/symv.rst index e79e3574c9..5d72b06d1c 100644 --- a/source/elements/oneMKL/source/domains/blas/symv.rst +++ b/source/elements/oneMath/source/domains/blas/symv.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_symv: +.. _onemath_blas_symv: symv ==== Computes a matrix-vector product for a symmetric matrix. -.. _onemkl_blas_symv_description: +.. _onemath_blas_symv_description: .. rubric:: Description @@ -40,7 +40,7 @@ where: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_symv_buffer: +.. _onemath_blas_symv_buffer: symv (Buffer Version) --------------------- @@ -49,9 +49,9 @@ symv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void symv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &a, @@ -64,9 +64,9 @@ symv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void symv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &a, @@ -86,7 +86,7 @@ symv (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -135,22 +135,22 @@ symv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_symv_usm: +.. _onemath_blas_symv_usm: symv (USM Version) ------------------ @@ -159,9 +159,9 @@ symv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event symv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *a, @@ -175,9 +175,9 @@ symv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event symv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *a, @@ -198,7 +198,7 @@ symv (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -260,20 +260,20 @@ symv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/syr.rst b/source/elements/oneMath/source/domains/blas/syr.rst similarity index 79% rename from source/elements/oneMKL/source/domains/blas/syr.rst rename to source/elements/oneMath/source/domains/blas/syr.rst index 18d7137d4d..a6fa5a56e7 100644 --- a/source/elements/oneMKL/source/domains/blas/syr.rst +++ b/source/elements/oneMath/source/domains/blas/syr.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_syr: +.. _onemath_blas_syr: syr === Computes a rank-1 update of a symmetric matrix. -.. _onemkl_blas_syr_description: +.. _onemath_blas_syr_description: .. rubric:: Description @@ -40,7 +40,7 @@ where: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_syr_buffer: +.. _onemath_blas_syr_buffer: syr (Buffer Version) -------------------- @@ -49,9 +49,9 @@ syr (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void syr(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &x, @@ -61,9 +61,9 @@ syr (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void syr(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &x, @@ -80,7 +80,7 @@ syr (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of columns of ``A``. Must be at least zero. @@ -121,22 +121,22 @@ syr (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_syr_usm: +.. _onemath_blas_syr_usm: syr (USM Version) ----------------- @@ -145,9 +145,9 @@ syr (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event syr(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -158,9 +158,9 @@ syr (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event syr(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -178,7 +178,7 @@ syr (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of columns of ``A``. Must be at least zero. @@ -230,20 +230,20 @@ syr (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/syr2.rst b/source/elements/oneMath/source/domains/blas/syr2.rst similarity index 82% rename from source/elements/oneMKL/source/domains/blas/syr2.rst rename to source/elements/oneMath/source/domains/blas/syr2.rst index 00e6191b4e..3a248579fb 100644 --- a/source/elements/oneMKL/source/domains/blas/syr2.rst +++ b/source/elements/oneMath/source/domains/blas/syr2.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_syr2: +.. _onemath_blas_syr2: syr2 ==== Computes a rank-2 update of a symmetric matrix. -.. _onemkl_blas_syr2_description: +.. _onemath_blas_syr2_description: .. rubric:: Description @@ -40,7 +40,7 @@ where: * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_syr2_buffer: +.. _onemath_blas_syr2_buffer: syr2 (Buffer Version) --------------------- @@ -49,9 +49,9 @@ syr2 (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void syr2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &x, @@ -63,9 +63,9 @@ syr2 (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void syr2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, T alpha, sycl::buffer &x, @@ -84,7 +84,7 @@ syr2 (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of columns of ``A``. Must be at least zero. @@ -133,22 +133,22 @@ syr2 (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_syr2_usm: +.. _onemath_blas_syr2_usm: syr2 (USM Version) ------------------ @@ -157,9 +157,9 @@ syr2 (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event syr2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -172,9 +172,9 @@ syr2 (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event syr2(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, + oneapi::math::uplo upper_lower, std::int64_t n, value_or_pointer alpha, const T *x, @@ -194,7 +194,7 @@ syr2 (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. n Number of columns of ``A``. Must be at least zero. @@ -255,20 +255,20 @@ syr2 (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/syr2k.rst b/source/elements/oneMath/source/domains/blas/syr2k.rst similarity index 87% rename from source/elements/oneMKL/source/domains/blas/syr2k.rst rename to source/elements/oneMath/source/domains/blas/syr2k.rst index 8be26c8940..5f5a74fb9b 100644 --- a/source/elements/oneMKL/source/domains/blas/syr2k.rst +++ b/source/elements/oneMath/source/domains/blas/syr2k.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_syr2k: +.. _onemath_blas_syr2k: syr2k ===== Performs a symmetric rank-2k update. -.. _onemkl_blas_syr2k_description: +.. _onemath_blas_syr2k_description: .. rubric:: Description @@ -53,7 +53,7 @@ The inner dimension of both matrix multiplications is ``k``. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_syr2k_buffer: +.. _onemath_blas_syr2k_buffer: syr2k (Buffer Version) ---------------------- @@ -62,10 +62,10 @@ syr2k (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void syr2k(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, T alpha, @@ -79,10 +79,10 @@ syr2k (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void syr2k(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, T alpha, @@ -104,7 +104,7 @@ syr2k (Buffer Version) upper_lower Specifies whether ``C``'s data is stored in its upper or lower - triangle. See :ref:`onemkl_datatypes` for more details. + triangle. See :ref:`onemath_datatypes` for more details. trans Specifies the operation to apply, as described above. Conjugation @@ -223,22 +223,22 @@ syr2k (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_syr2k_usm: +.. _onemath_blas_syr2k_usm: syr2k (USM Version) ------------------- @@ -247,10 +247,10 @@ syr2k (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event syr2k(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -265,10 +265,10 @@ syr2k (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event syr2k(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -291,7 +291,7 @@ syr2k (USM Version) upper_lower Specifies whether ``C``'s data is stored in its upper or lower - triangle. See :ref:`onemkl_datatypes` for more details. + triangle. See :ref:`onemath_datatypes` for more details. trans Specifies the operation to apply, as described above. @@ -422,20 +422,20 @@ syr2k (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-3-routines` diff --git a/source/elements/oneMKL/source/domains/blas/syrk.rst b/source/elements/oneMath/source/domains/blas/syrk.rst similarity index 81% rename from source/elements/oneMKL/source/domains/blas/syrk.rst rename to source/elements/oneMath/source/domains/blas/syrk.rst index cdc35413cc..589882224a 100644 --- a/source/elements/oneMKL/source/domains/blas/syrk.rst +++ b/source/elements/oneMath/source/domains/blas/syrk.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_syrk: +.. _onemath_blas_syrk: syrk ==== Performs a symmetric rank-k update. -.. _onemkl_blas_syrk_description: +.. _onemath_blas_syrk_description: .. rubric:: Description @@ -42,7 +42,7 @@ Here op(``A``) is ``n``-by-``k``, and ``C`` is ``n``-by-``n``. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_syrk_buffer: +.. _onemath_blas_syrk_buffer: syrk (Buffer Version) --------------------- @@ -51,10 +51,10 @@ syrk (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void syrk(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, T alpha, @@ -66,10 +66,10 @@ syrk (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void syrk(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, T alpha, @@ -89,10 +89,10 @@ syrk (Buffer Version) upper_lower Specifies whether ``C``'s data is stored in its upper or lower - triangle. See :ref:`onemkl_datatypes` for more details. + triangle. See :ref:`onemath_datatypes` for more details. trans - Specifies op(``A``), the transposition operation applied to ``A`` (See :ref:`onemkl_datatypes` for more details). Conjugation is never performed, even if ``trans`` = ``transpose::conjtrans``. + Specifies op(``A``), the transposition operation applied to ``A`` (See :ref:`onemath_datatypes` for more details). Conjugation is never performed, even if ``trans`` = ``transpose::conjtrans``. n Number of rows and columns in ``C``. The value of ``n`` must be at @@ -169,22 +169,22 @@ syrk (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_syrk_usm: +.. _onemath_blas_syrk_usm: syrk (USM Version) ------------------ @@ -193,10 +193,10 @@ syrk (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event syrk(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -209,10 +209,10 @@ syrk (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event syrk(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, value_or_pointer alpha, @@ -233,11 +233,11 @@ syrk (USM Version) upper_lower Specifies whether ``C``'s data is stored in its upper or lower - triangle. See :ref:`onemkl_datatypes` for more details. + triangle. See :ref:`onemath_datatypes` for more details. trans Specifies op(``A``), the transposition operation applied to - ``A`` (See :ref:`onemkl_datatypes` for more details). Conjugation is never performed, even if + ``A`` (See :ref:`onemath_datatypes` for more details). Conjugation is never performed, even if ``trans`` = ``transpose::conjtrans``. n @@ -322,20 +322,20 @@ syrk (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-3-routines` diff --git a/source/elements/oneMKL/source/domains/blas/syrk_batch.rst b/source/elements/oneMath/source/domains/blas/syrk_batch.rst similarity index 87% rename from source/elements/oneMKL/source/domains/blas/syrk_batch.rst rename to source/elements/oneMath/source/domains/blas/syrk_batch.rst index c106468dcc..5438bfa1a7 100644 --- a/source/elements/oneMKL/source/domains/blas/syrk_batch.rst +++ b/source/elements/oneMath/source/domains/blas/syrk_batch.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_syrk_batch: +.. _onemath_blas_syrk_batch: syrk_batch ========== Computes a group of ``syrk`` operations. -.. _onemkl_blas_syrk_batch_description: +.. _onemath_blas_syrk_batch_description: .. rubric:: Description -The ``syrk_batch`` routines are batched versions of :ref:`onemkl_blas_syrk`, performing +The ``syrk_batch`` routines are batched versions of :ref:`onemath_blas_syrk`, performing multiple ``syrk`` operations in a single call. Each ``syrk`` operation perform a rank-k update with general matrices. @@ -28,7 +28,7 @@ operation perform a rank-k update with general matrices. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_syrk_batch_buffer: +.. _onemath_blas_syrk_batch_buffer: syrk_batch (Buffer Version) --------------------------- @@ -65,10 +65,10 @@ of matrices in ``a`` and ``c`` buffers is given by the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void syrk_batch(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, T alpha, @@ -83,10 +83,10 @@ of matrices in ``a`` and ``c`` buffers is given by the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void syrk_batch(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, std::int64_t n, std::int64_t k, T alpha, @@ -109,12 +109,12 @@ of matrices in ``a`` and ``c`` buffers is given by the ``batch_size`` parameter. upper_lower Specifies whether data in ``C`` is stored in its upper or lower triangle. - For more details, see :ref:`onemkl_datatypes`. + For more details, see :ref:`onemath_datatypes`. trans Specifies op(``A``) the transposition operation applied to the matrix ``A``. Conjugation is never performed, even if trans = - transpose::conjtrans. See :ref:`onemkl_datatypes` for more + transpose::conjtrans. See :ref:`onemath_datatypes` for more details. n @@ -181,22 +181,22 @@ of matrices in ``a`` and ``c`` buffers is given by the ``batch_size`` parameter. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_syrk_batch_usm: +.. _onemath_blas_syrk_batch_usm: syrk_batch (USM Version) --------------------------- @@ -252,7 +252,7 @@ in ``a`` and ``c`` are given by the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event syrk_batch(sycl::queue &queue, const uplo *upper_lower, const transpose *trans, @@ -270,7 +270,7 @@ in ``a`` and ``c`` are given by the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event syrk_batch(sycl::queue &queue, const uplo *upper_lower, const transpose *trans, @@ -295,13 +295,13 @@ in ``a`` and ``c`` are given by the ``batch_size`` parameter. The queue where the routine should be executed. upper_lower - Array of ``group_count`` ``oneapi::mkl::upper_lower`` + Array of ``group_count`` ``oneapi::math::upper_lower`` values. ``upper_lower[i]`` specifies whether data in C for every matrix in group ``i`` is in upper or lower triangle. trans - Array of ``group_count`` ``oneapi::mkl::transpose`` values. ``trans[i]`` specifies the form of op(``A``) used in - the rank-k update in group ``i``. See :ref:`onemkl_datatypes` for more details. + Array of ``group_count`` ``oneapi::math::transpose`` values. ``trans[i]`` specifies the form of op(``A``) used in + the rank-k update in group ``i``. See :ref:`onemath_datatypes` for more details. n Array of ``group_count`` integers. ``n[i]`` specifies the @@ -383,7 +383,7 @@ in ``a`` and ``c`` are given by the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event syrk_batch(sycl::queue &queue, uplo upper_lower, transpose trans, @@ -402,7 +402,7 @@ in ``a`` and ``c`` are given by the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event syrk_batch(sycl::queue &queue, uplo upper_lower, transpose trans, @@ -429,12 +429,12 @@ in ``a`` and ``c`` are given by the ``batch_size`` parameter. upper_lower Specifies whether data in ``C`` is stored in its upper or lower triangle. - For more details, see :ref:`onemkl_datatypes`. + For more details, see :ref:`onemath_datatypes`. trans Specifies op(``A``) the transposition operation applied to the matrices ``A``. Conjugation is never performed, even if trans = - transpose::conjtrans. See :ref:`onemkl_datatypes` for more + transpose::conjtrans. See :ref:`onemath_datatypes` for more details. n @@ -510,20 +510,20 @@ in ``a`` and ``c`` are given by the ``batch_size`` parameter. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/tbmv.rst b/source/elements/oneMath/source/domains/blas/tbmv.rst similarity index 73% rename from source/elements/oneMKL/source/domains/blas/tbmv.rst rename to source/elements/oneMath/source/domains/blas/tbmv.rst index 6de8c9f655..abe86166df 100644 --- a/source/elements/oneMKL/source/domains/blas/tbmv.rst +++ b/source/elements/oneMath/source/domains/blas/tbmv.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_tbmv: +.. _onemath_blas_tbmv: tbmv ==== Computes a matrix-vector product using a triangular band matrix. -.. _onemkl_blas_tbmv_description: +.. _onemath_blas_tbmv_description: .. rubric:: Description @@ -41,7 +41,7 @@ triangular band matrix, with (``k`` + 1) diagonals, * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_tbmv_buffer: +.. _onemath_blas_tbmv_buffer: tbmv (Buffer Version) --------------------- @@ -50,11 +50,11 @@ tbmv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void tbmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, std::int64_t k, sycl::buffer &a, @@ -64,11 +64,11 @@ tbmv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void tbmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, std::int64_t k, sycl::buffer &a, @@ -85,13 +85,13 @@ tbmv (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans - Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemkl_datatypes` for more details. + Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemath_datatypes` for more details. unit_nonunit - Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemath_datatypes` for more details. n Numbers of rows and columns of ``A``. Must be at least zero. @@ -130,22 +130,22 @@ tbmv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_tbmv_usm: +.. _onemath_blas_tbmv_usm: tbmv (USM Version) ------------------ @@ -154,11 +154,11 @@ tbmv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event tbmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, std::int64_t k, const T *a, @@ -169,11 +169,11 @@ tbmv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event tbmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, std::int64_t k, const T *a, @@ -191,14 +191,14 @@ tbmv (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans Specifies op(``A``), the transposition operation applied to - ``A``. See :ref:`onemkl_datatypes` for more details. + ``A``. See :ref:`onemath_datatypes` for more details. unit_nonunit - Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemath_datatypes` for more details. n Numbers of rows and columns of ``A``. Must be at least zero. @@ -248,20 +248,20 @@ tbmv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/tbsv.rst b/source/elements/oneMath/source/domains/blas/tbsv.rst similarity index 73% rename from source/elements/oneMKL/source/domains/blas/tbsv.rst rename to source/elements/oneMath/source/domains/blas/tbsv.rst index 0bd82caffa..ca81c03fa1 100644 --- a/source/elements/oneMKL/source/domains/blas/tbsv.rst +++ b/source/elements/oneMath/source/domains/blas/tbsv.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_tbsv: +.. _onemath_blas_tbsv: tbsv ==== @@ -10,7 +10,7 @@ tbsv Solves a system of linear equations whose coefficients are in a triangular band matrix. -.. _onemkl_blas_tbsv_description: +.. _onemath_blas_tbsv_description: .. rubric:: Description @@ -43,7 +43,7 @@ triangular band matrix, with (``k`` + 1) diagonals, * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_tbsv_buffer: +.. _onemath_blas_tbsv_buffer: tbsv (Buffer Version) --------------------- @@ -52,11 +52,11 @@ tbsv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void tbsv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, std::int64_t k, sycl::buffer &a, @@ -66,11 +66,11 @@ tbsv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void tbsv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, std::int64_t k, sycl::buffer &a, @@ -87,13 +87,13 @@ tbsv (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans - Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemkl_datatypes` for more details. + Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemath_datatypes` for more details. unit_nonunit - Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -132,22 +132,22 @@ tbsv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_tbsv_usm: +.. _onemath_blas_tbsv_usm: tbsv (USM Version) ------------------ @@ -156,11 +156,11 @@ tbsv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event tbsv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, std::int64_t k, const T *a, @@ -171,11 +171,11 @@ tbsv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event tbsv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, std::int64_t k, const T *a, @@ -193,14 +193,14 @@ tbsv (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans Specifies op(``A``), the transposition operation applied to - ``A``. See :ref:`onemkl_datatypes` for more details. + ``A``. See :ref:`onemath_datatypes` for more details. unit_nonunit - Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemath_datatypes` for more details. n Number of rows and columns of ``A``. Must be at least zero. @@ -250,20 +250,20 @@ tbsv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/tpmv.rst b/source/elements/oneMath/source/domains/blas/tpmv.rst similarity index 70% rename from source/elements/oneMKL/source/domains/blas/tpmv.rst rename to source/elements/oneMath/source/domains/blas/tpmv.rst index a15b57c622..c10a11db24 100644 --- a/source/elements/oneMKL/source/domains/blas/tpmv.rst +++ b/source/elements/oneMath/source/domains/blas/tpmv.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_tpmv: +.. _onemath_blas_tpmv: tpmv ==== Computes a matrix-vector product using a triangular packed matrix. -.. _onemkl_blas_tpmv_description: +.. _onemath_blas_tpmv_description: .. rubric:: Description @@ -41,7 +41,7 @@ triangular band matrix, supplied in packed form, * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_tpmv_buffer: +.. _onemath_blas_tpmv_buffer: tpmv (Buffer Version) --------------------- @@ -50,11 +50,11 @@ tpmv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void tpmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, sycl::buffer &a, sycl::buffer &x, @@ -62,11 +62,11 @@ tpmv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void tpmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, sycl::buffer &a, sycl::buffer &x, @@ -81,13 +81,13 @@ tpmv (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans - Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemkl_datatypes` for more details. + Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemath_datatypes` for more details. unit_nonunit - Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemath_datatypes` for more details. n Numbers of rows and columns of ``A``. Must be at least zero. @@ -118,22 +118,22 @@ tpmv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_tpmv_usm: +.. _onemath_blas_tpmv_usm: tpmv (USM Version) ------------------ @@ -142,11 +142,11 @@ tpmv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event tpmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, const T *a, T *x, @@ -155,11 +155,11 @@ tpmv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event tpmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, const T *a, T *x, @@ -175,14 +175,14 @@ tpmv (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans Specifies op(``A``), the transposition operation applied to - ``A``. See :ref:`onemkl_datatypes` for more details. + ``A``. See :ref:`onemath_datatypes` for more details. unit_nonunit - Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemath_datatypes` for more details. n Numbers of rows and columns of ``A``. Must be at least zero. @@ -225,20 +225,20 @@ tpmv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/tpsv.rst b/source/elements/oneMath/source/domains/blas/tpsv.rst similarity index 71% rename from source/elements/oneMKL/source/domains/blas/tpsv.rst rename to source/elements/oneMath/source/domains/blas/tpsv.rst index e5f67633bd..80f9297f0a 100644 --- a/source/elements/oneMKL/source/domains/blas/tpsv.rst +++ b/source/elements/oneMath/source/domains/blas/tpsv.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_tpsv: +.. _onemath_blas_tpsv: tpsv ==== @@ -10,7 +10,7 @@ tpsv Solves a system of linear equations whose coefficients are in a triangular packed matrix. -.. _onemkl_blas_tpsv_description: +.. _onemath_blas_tpsv_description: .. rubric:: Description @@ -43,7 +43,7 @@ triangular band matrix, supplied in packed form, * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_tpsv_buffer: +.. _onemath_blas_tpsv_buffer: tpsv (Buffer Version) --------------------- @@ -52,11 +52,11 @@ tpsv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void tpsv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, std::int64_t k, sycl::buffer &a, @@ -65,11 +65,11 @@ tpsv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void tpsv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, std::int64_t k, sycl::buffer &a, @@ -85,13 +85,13 @@ tpsv (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans - Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemkl_datatypes` for more details. + Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemath_datatypes` for more details. unit_nonunit - Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemath_datatypes` for more details. n Numbers of rows and columns of ``A``. Must be at least zero. @@ -123,22 +123,22 @@ tpsv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_tpsv_usm: +.. _onemath_blas_tpsv_usm: tpsv (USM Version) ------------------ @@ -147,11 +147,11 @@ tpsv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event tpsv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, std::int64_t k, const T *a, @@ -161,11 +161,11 @@ tpsv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event tpsv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, std::int64_t k, const T *a, @@ -182,14 +182,14 @@ tpsv (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans Specifies op(``A``), the transposition operation applied to - ``A``. See :ref:`onemkl_datatypes` for more details. + ``A``. See :ref:`onemath_datatypes` for more details. unit_nonunit - Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemath_datatypes` for more details. n Numbers of rows and columns of ``A``. Must be at least zero. @@ -233,20 +233,20 @@ tpsv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/trmm.rst b/source/elements/oneMath/source/domains/blas/trmm.rst similarity index 77% rename from source/elements/oneMKL/source/domains/blas/trmm.rst rename to source/elements/oneMath/source/domains/blas/trmm.rst index e864846675..3770b36b06 100644 --- a/source/elements/oneMKL/source/domains/blas/trmm.rst +++ b/source/elements/oneMath/source/domains/blas/trmm.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_trmm: +.. _onemath_blas_trmm: trmm ==== @@ -10,7 +10,7 @@ trmm Computes a matrix-matrix product where one input matrix is triangular and one input matrix is general. -.. _onemkl_blas_trmm_description: +.. _onemath_blas_trmm_description: .. rubric:: Description @@ -68,7 +68,7 @@ Here ``B`` and ``C`` are ``m`` x ``n`` and ``A`` is either ``m`` x ``m`` or * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_trmm_buffer: +.. _onemath_blas_trmm_buffer: trmm (Buffer Version) --------------------- @@ -80,12 +80,12 @@ trmm (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void trmm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose transa, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose transa, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, T alpha, @@ -96,12 +96,12 @@ trmm (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void trmm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose transa, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose transa, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, T alpha, @@ -120,17 +120,17 @@ trmm (Buffer Version) left_right Specifies whether ``A`` is on the left side of the multiplication - (``side::left``) or on the right side (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::left``) or on the right side (``side::right``). See :ref:`onemath_datatypes` for more details. upper_lower - Specifies whether the matrix ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans - Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemkl_datatypes` for more details. + Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemath_datatypes` for more details. unit_diag Specifies whether ``A`` is assumed to be unit triangular (all - diagonal elements are 1). See :ref:`onemkl_datatypes` for more details. + diagonal elements are 1). See :ref:`onemath_datatypes` for more details. m Specifies the number of rows of ``B``. The value of ``m`` must be @@ -187,19 +187,19 @@ trmm (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Out-of-place API** -------------------- @@ -208,12 +208,12 @@ trmm (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void trmm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, T alpha, @@ -228,12 +228,12 @@ trmm (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void trmm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, T alpha, @@ -256,16 +256,16 @@ trmm (Buffer Version) left_right Specifies whether ``A`` is on the left side of the multiplication - (``side::left``) or on the right side (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::left``) or on the right side (``side::right``). See :ref:`onemath_datatypes` for more details. upper_lower - Specifies whether the matrix ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans - Specifies op(``A``), the transposition operation applied to matrix ``A``. See :ref:`onemkl_datatypes` for more details. + Specifies op(``A``), the transposition operation applied to matrix ``A``. See :ref:`onemath_datatypes` for more details. unit_diag - Specifies whether ``A`` is assumed to be unit triangular (all diagonal elements are 1). See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is assumed to be unit triangular (all diagonal elements are 1). See :ref:`onemath_datatypes` for more details. m Specifices the number of rows of ``B``. The value of ``m`` must be at least zero. @@ -313,22 +313,22 @@ trmm (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_trmm_usm: +.. _onemath_blas_trmm_usm: trmm (USM Version) ------------------ @@ -340,12 +340,12 @@ trmm (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event trmm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose transa, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose transa, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -357,12 +357,12 @@ trmm (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event trmm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose transa, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose transa, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -383,19 +383,19 @@ trmm (USM Version) left_right Specifies whether ``A`` is on the left side of the multiplication (``side::left``) or on the right side - (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::right``). See :ref:`onemath_datatypes` for more details. upper_lower Specifies whether the matrix ``A`` is upper or lower - triangular. See :ref:`onemkl_datatypes` for more details. + triangular. See :ref:`onemath_datatypes` for more details. trans Specifies op(``A``), the transposition operation applied to - ``A``. See :ref:`onemkl_datatypes` for more details. + ``A``. See :ref:`onemath_datatypes` for more details. unit_diag Specifies whether ``A`` is assumed to be unit triangular (all - diagonal elements are 1). See :ref:`onemkl_datatypes` for more details. + diagonal elements are 1). See :ref:`onemath_datatypes` for more details. m Specifies the number of rows of ``B``. The value of ``m`` must @@ -463,20 +463,20 @@ trmm (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Out-of-place API** -------------------- @@ -485,12 +485,12 @@ trmm (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void trmm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -506,12 +506,12 @@ trmm (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void trmm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -535,16 +535,16 @@ trmm (USM Version) left_right Specifies whether ``A`` is on the left side of the multiplication - (``side::left``) or on the right side (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::left``) or on the right side (``side::right``). See :ref:`onemath_datatypes` for more details. upper_lower - Specifies whether the matrix ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans - Specifies op(``A``), the transposition operation applied to matrix ``A``. See :ref:`onemkl_datatypes` for more details. + Specifies op(``A``), the transposition operation applied to matrix ``A``. See :ref:`onemath_datatypes` for more details. unit_diag - Specifies whether ``A`` is assumed to be unit triangular (all diagonal elements are 1). See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is assumed to be unit triangular (all diagonal elements are 1). See :ref:`onemath_datatypes` for more details. m Specifices the number of rows of ``B``. The value of ``m`` must be at least zero. @@ -596,18 +596,18 @@ trmm (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-3-routines` diff --git a/source/elements/oneMKL/source/domains/blas/trmv.rst b/source/elements/oneMath/source/domains/blas/trmv.rst similarity index 71% rename from source/elements/oneMKL/source/domains/blas/trmv.rst rename to source/elements/oneMath/source/domains/blas/trmv.rst index e660a932a2..eaed138023 100644 --- a/source/elements/oneMKL/source/domains/blas/trmv.rst +++ b/source/elements/oneMath/source/domains/blas/trmv.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_trmv: +.. _onemath_blas_trmv: trmv ==== Computes a matrix-vector product using a triangular matrix. -.. _onemkl_blas_trmv_description: +.. _onemath_blas_trmv_description: .. rubric:: Description @@ -41,7 +41,7 @@ triangular band matrix, * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_trmv_buffer: +.. _onemath_blas_trmv_buffer: trmv (Buffer Version) --------------------- @@ -50,11 +50,11 @@ trmv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void trmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, sycl::buffer &a, std::int64_t lda, @@ -63,11 +63,11 @@ trmv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void trmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, sycl::buffer &a, std::int64_t lda, @@ -83,13 +83,13 @@ trmv (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans - Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemkl_datatypes` for more details. + Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemath_datatypes` for more details. unit_nonunit - Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemath_datatypes` for more details. n Numbers of rows and columns of ``A``. Must be at least zero. @@ -124,22 +124,22 @@ trmv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_trmv_usm: +.. _onemath_blas_trmv_usm: trmv (USM Version) ------------------ @@ -148,11 +148,11 @@ trmv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event trmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, const T *a, std::int64_t lda, @@ -162,11 +162,11 @@ trmv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event trmv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, const T *a, std::int64_t lda, @@ -183,14 +183,14 @@ trmv (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans Specifies op(``A``), the transposition operation applied to - ``A``. See :ref:`onemkl_datatypes` for more details. + ``A``. See :ref:`onemath_datatypes` for more details. unit_nonunit - Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemath_datatypes` for more details. n Numbers of rows and columns of ``A``. Must be at least zero. @@ -236,20 +236,20 @@ trmv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/blas/trsm.rst b/source/elements/oneMath/source/domains/blas/trsm.rst similarity index 76% rename from source/elements/oneMKL/source/domains/blas/trsm.rst rename to source/elements/oneMath/source/domains/blas/trsm.rst index 70bac6b62c..4b889a9af1 100644 --- a/source/elements/oneMKL/source/domains/blas/trsm.rst +++ b/source/elements/oneMath/source/domains/blas/trsm.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_trsm: +.. _onemath_blas_trsm: trsm ==== Solves a triangular matrix equation (forward or backward solve). -.. _onemkl_blas_trsm_description: +.. _onemath_blas_trsm_description: .. rubric:: Description @@ -66,7 +66,7 @@ For the out-of-place operation, ``B`` remains untouched and the solution is adde * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_trsm_buffer: +.. _onemath_blas_trsm_buffer: trsm (Buffer Version) --------------------- @@ -78,12 +78,12 @@ trsm (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void trsm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose transa, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose transa, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, T alpha, @@ -94,12 +94,12 @@ trsm (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void trsm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose transa, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose transa, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, T alpha, @@ -118,17 +118,17 @@ trsm (Buffer Version) left_right Specifies whether ``A`` multiplies ``X`` on the left - (``side::left``) or on the right (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::left``) or on the right (``side::right``). See :ref:`onemath_datatypes` for more details. upper_lower - Specifies whether the matrix ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans - Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemkl_datatypes` for more details. + Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemath_datatypes` for more details. unit_diag Specifies whether ``A`` is assumed to be unit triangular (all - diagonal elements are 1). See :ref:`onemkl_datatypes` for more details. + diagonal elements are 1). See :ref:`onemath_datatypes` for more details. m Specifies the number of rows of ``B``. The value of ``m`` must be @@ -184,19 +184,19 @@ trsm (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Out-of-place API** -------------------- @@ -205,12 +205,12 @@ trsm (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void trsm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, T alpha, @@ -225,12 +225,12 @@ trsm (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void trsm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, T alpha, @@ -253,16 +253,16 @@ trsm (Buffer Version) left_right Specifies whether ``A`` is on the left side of the matrix solve - (``side::left``) or on the right side (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::left``) or on the right side (``side::right``). See :ref:`onemath_datatypes` for more details. upper_lower - Specifies whether the matrix ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans - Specifies op(``A``), the transposition operation applied to matrix ``A``. See :ref:`onemkl_datatypes` for more details. + Specifies op(``A``), the transposition operation applied to matrix ``A``. See :ref:`onemath_datatypes` for more details. unit_diag - Specifies whether ``A`` is assumed to be unit triangular (all diagonal elements are 1). See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is assumed to be unit triangular (all diagonal elements are 1). See :ref:`onemath_datatypes` for more details. m Specifices the number of rows of ``B``. The value of ``m`` must be at least zero. @@ -310,22 +310,22 @@ trsm (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_trsm_usm: +.. _onemath_blas_trsm_usm: trsm (USM Version) ------------------ @@ -337,12 +337,12 @@ trsm (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event trsm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose transa, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose transa, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -354,12 +354,12 @@ trsm (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event trsm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose transa, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose transa, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -379,19 +379,19 @@ trsm (USM Version) left_right Specifies whether ``A`` multiplies ``X`` on the left - (``side::left``) or on the right (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::left``) or on the right (``side::right``). See :ref:`onemath_datatypes` for more details. upper_lower Specifies whether the matrix ``A`` is upper or lower - triangular. See :ref:`onemkl_datatypes` for more details. + triangular. See :ref:`onemath_datatypes` for more details. transa Specifies op(``A``), the transposition operation applied to - ``A``. See :ref:`onemkl_datatypes` for more details. + ``A``. See :ref:`onemath_datatypes` for more details. unit_diag Specifies whether ``A`` is assumed to be unit triangular (all - diagonal elements are 1). See :ref:`onemkl_datatypes` for more details. + diagonal elements are 1). See :ref:`onemath_datatypes` for more details. m Specifies the number of rows of ``B``. The value of ``m`` must @@ -458,20 +458,20 @@ trsm (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Out-of-place API** -------------------- @@ -480,12 +480,12 @@ trsm (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void trsm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -501,12 +501,12 @@ trsm (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void trsm(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -530,16 +530,16 @@ trsm (USM Version) left_right Specifies whether ``A`` is on the left side of the matrix solve - (``side::left``) or on the right side (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::left``) or on the right side (``side::right``). See :ref:`onemath_datatypes` for more details. upper_lower - Specifies whether the matrix ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans - Specifies op(``A``), the transposition operation applied to matrix ``A``. See :ref:`onemkl_datatypes` for more details. + Specifies op(``A``), the transposition operation applied to matrix ``A``. See :ref:`onemath_datatypes` for more details. unit_diag - Specifies whether ``A`` is assumed to be unit triangular (all diagonal elements are 1). See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is assumed to be unit triangular (all diagonal elements are 1). See :ref:`onemath_datatypes` for more details. m Specifices the number of rows of ``B``. The value of ``m`` must be at least zero. @@ -591,19 +591,19 @@ trsm (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-3-routines` diff --git a/source/elements/oneMKL/source/domains/blas/trsm_batch.rst b/source/elements/oneMath/source/domains/blas/trsm_batch.rst similarity index 77% rename from source/elements/oneMKL/source/domains/blas/trsm_batch.rst rename to source/elements/oneMath/source/domains/blas/trsm_batch.rst index e31b403f66..941c606f9a 100644 --- a/source/elements/oneMKL/source/domains/blas/trsm_batch.rst +++ b/source/elements/oneMath/source/domains/blas/trsm_batch.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_trsm_batch: +.. _onemath_blas_trsm_batch: trsm_batch ========== Computes a group of ``trsm`` operations. -.. _onemkl_blas_trsm_batch_description: +.. _onemath_blas_trsm_batch_description: .. rubric:: Description -The ``trsm_batch`` routines are batched versions of :ref:`onemkl_blas_trsm`, performing +The ``trsm_batch`` routines are batched versions of :ref:`onemath_blas_trsm`, performing multiple ``trsm`` operations in a single call. Each ``trsm`` solves an equation of the form op(A) \* X = alpha \* B or X \* op(A) = alpha \* B. @@ -28,7 +28,7 @@ solves an equation of the form op(A) \* X = alpha \* B or X \* op(A) = alpha \* * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_trsm_batch_buffer: +.. _onemath_blas_trsm_batch_buffer: trsm_batch (Buffer Version) --------------------------- @@ -42,7 +42,7 @@ The strided API operation is defined as: for i = 0 … batch_size – 1 A and B are matrices at offset i * stridea and i * strideb in a and b. - if (left_right == oneapi::mkl::side::left) then + if (left_right == oneapi::math::side::left) then compute X such that op(A) * X = alpha * B else compute X such that X * op(A) = alpha * B @@ -75,12 +75,12 @@ of matrices in ``a`` and ``b`` buffers are given by the ``batch_size`` parameter .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void trsm_batch(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, T alpha, @@ -94,12 +94,12 @@ of matrices in ``a`` and ``b`` buffers are given by the ``batch_size`` parameter } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void trsm_batch(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, T alpha, @@ -121,19 +121,19 @@ of matrices in ``a`` and ``b`` buffers are given by the ``batch_size`` parameter left_right Specifies whether the matrices ``A`` multiply ``X`` on the left - (``side::left``) or on the right (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::left``) or on the right (``side::right``). See :ref:`onemath_datatypes` for more details. upper_lower Specifies whether the matrices ``A`` are upper or lower - triangular. See :ref:`onemkl_datatypes` for more details. + triangular. See :ref:`onemath_datatypes` for more details. trans Specifies op(``A``), the transposition operation applied to the - matrices ``A``. See :ref:`onemkl_datatypes` for more details. + matrices ``A``. See :ref:`onemath_datatypes` for more details. unit_diag Specifies whether the matrices ``A`` are assumed to be unit - triangular (all diagonal elements are 1). See :ref:`onemkl_datatypes` for more details. + triangular (all diagonal elements are 1). See :ref:`onemath_datatypes` for more details. m Number of rows of the ``B`` matrices. Must be at least zero. @@ -190,19 +190,19 @@ of matrices in ``a`` and ``b`` buffers are given by the ``batch_size`` parameter This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` trsm_batch (USM Version) --------------------------- @@ -218,7 +218,7 @@ The group API operation is defined as: for i = 0 … group_count – 1 for j = 0 … group_size – 1 A and B are matrices in a[idx] and b[idx] - if (left_right == oneapi::mkl::side::left) then + if (left_right == oneapi::math::side::left) then compute X such that op(A) * X = alpha[i] * B else compute X such that X * op(A) = alpha[i] * B @@ -234,7 +234,7 @@ The strided API operation is defined as: for i = 0 … batch_size – 1 A and B are matrices at offset i * stridea and i * strideb in a and b. - if (left_right == oneapi::mkl::side::left) then + if (left_right == oneapi::math::side::left) then compute X such that op(A) * X = alpha * B else compute X such that X * op(A) = alpha * B @@ -273,12 +273,12 @@ in ``a`` and ``b`` are given by the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event trsm_batch(sycl::queue &queue, - const oneapi::mkl::side *left_right, - const oneapi::mkl::uplo *upper_lower, - const oneapi::mkl::transpose *trans, - const oneapi::mkl::diag *unit_diag, + const oneapi::math::side *left_right, + const oneapi::math::uplo *upper_lower, + const oneapi::math::transpose *trans, + const oneapi::math::diag *unit_diag, const std::int64_t *m, const std::int64_t *n, const T *alpha, @@ -292,12 +292,12 @@ in ``a`` and ``b`` are given by the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event trsm_batch(sycl::queue &queue, - const oneapi::mkl::side *left_right, - const oneapi::mkl::uplo *upper_lower, - const oneapi::mkl::transpose *trans, - const oneapi::mkl::diag *unit_diag, + const oneapi::math::side *left_right, + const oneapi::math::uplo *upper_lower, + const oneapi::math::transpose *trans, + const oneapi::math::diag *unit_diag, const std::int64_t *m, const std::int64_t *n, const T *alpha, @@ -318,21 +318,21 @@ in ``a`` and ``b`` are given by the ``batch_size`` parameter. The queue where the routine should be executed. left_right - Array of ``group_count`` ``oneapi::mkl::side`` values. ``left_right[i]`` specifies whether ``A`` multiplies + Array of ``group_count`` ``oneapi::math::side`` values. ``left_right[i]`` specifies whether ``A`` multiplies ``X`` on the left (``side::left``) or on the right - (``side::right``) for every ``trsm`` operation in group ``i``. See :ref:`onemkl_datatypes` for more details. + (``side::right``) for every ``trsm`` operation in group ``i``. See :ref:`onemath_datatypes` for more details. upper_lower - Array of ``group_count`` ``oneapi::mkl::uplo`` values. ``upper_lower[i]`` specifies whether ``A`` is upper or lower - triangular for every matrix in group ``i``. See :ref:`onemkl_datatypes` for more details. + Array of ``group_count`` ``oneapi::math::uplo`` values. ``upper_lower[i]`` specifies whether ``A`` is upper or lower + triangular for every matrix in group ``i``. See :ref:`onemath_datatypes` for more details. trans - Array of ``group_count`` ``oneapi::mkl::transpose`` values. ``trans[i]`` specifies the form of op(``A``) used - for every ``trsm`` operation in group ``i``. See :ref:`onemkl_datatypes` for more details. + Array of ``group_count`` ``oneapi::math::transpose`` values. ``trans[i]`` specifies the form of op(``A``) used + for every ``trsm`` operation in group ``i``. See :ref:`onemath_datatypes` for more details. unit_diag - Array of ``group_count`` ``oneapi::mkl::diag`` values. ``unit_diag[i]`` specifies whether ``A`` is assumed to - be unit triangular (all diagonal elements are 1) for every matrix in group ``i``. See :ref:`onemkl_datatypes` for more details. + Array of ``group_count`` ``oneapi::math::diag`` values. ``unit_diag[i]`` specifies whether ``A`` is assumed to + be unit triangular (all diagonal elements are 1) for every matrix in group ``i``. See :ref:`onemath_datatypes` for more details. m Array of ``group_count`` integers. ``m[i]`` specifies the @@ -402,12 +402,12 @@ in ``a`` and ``b`` are given by the ``batch_size`` parameter. .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event trsm_batch(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -422,12 +422,12 @@ in ``a`` and ``b`` are given by the ``batch_size`` parameter. } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event trsm_batch(sycl::queue &queue, - oneapi::mkl::side left_right, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_diag, + oneapi::math::side left_right, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer alpha, @@ -450,19 +450,19 @@ in ``a`` and ``b`` are given by the ``batch_size`` parameter. left_right Specifies whether the matrices ``A`` multiply ``X`` on the left - (``side::left``) or on the right (``side::right``). See :ref:`onemkl_datatypes` for more details. + (``side::left``) or on the right (``side::right``). See :ref:`onemath_datatypes` for more details. upper_lower Specifies whether the matrices ``A`` are upper or lower - triangular. See :ref:`onemkl_datatypes` for more details. + triangular. See :ref:`onemath_datatypes` for more details. trans Specifies op(``A``), the transposition operation applied to the - matrices ``A``. See :ref:`onemkl_datatypes` for more details. + matrices ``A``. See :ref:`onemath_datatypes` for more details. unit_diag Specifies whether the matrices ``A`` are assumed to be unit - triangular (all diagonal elements are 1). See :ref:`onemkl_datatypes` for more details. + triangular (all diagonal elements are 1). See :ref:`onemath_datatypes` for more details. m Number of rows of the ``B`` matrices. Must be at least zero. @@ -525,20 +525,20 @@ in ``a`` and ``b`` are given by the ``batch_size`` parameter. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-like-extensions` diff --git a/source/elements/oneMKL/source/domains/blas/trsv.rst b/source/elements/oneMath/source/domains/blas/trsv.rst similarity index 72% rename from source/elements/oneMKL/source/domains/blas/trsv.rst rename to source/elements/oneMath/source/domains/blas/trsv.rst index bc72a057dc..c0485e131c 100644 --- a/source/elements/oneMKL/source/domains/blas/trsv.rst +++ b/source/elements/oneMath/source/domains/blas/trsv.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_blas_trsv: +.. _onemath_blas_trsv: trsv ==== @@ -10,7 +10,7 @@ trsv Solves a system of linear equations whose coefficients are in a triangular matrix. -.. _onemkl_blas_trsv_description: +.. _onemath_blas_trsv_description: .. rubric:: Description @@ -42,7 +42,7 @@ triangular matrix, * - ``std::complex`` * - ``std::complex`` -.. _onemkl_blas_trsv_buffer: +.. _onemath_blas_trsv_buffer: trsv (Buffer Version) --------------------- @@ -51,11 +51,11 @@ trsv (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { void trsv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, sycl::buffer &a, std::int64_t lda, @@ -64,11 +64,11 @@ trsv (Buffer Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { void trsv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, sycl::buffer &a, std::int64_t lda, @@ -84,13 +84,13 @@ trsv (Buffer Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans - Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemkl_datatypes` for more details. + Specifies op(``A``), the transposition operation applied to ``A``. See :ref:`onemath_datatypes` for more details. unit_nonunit - Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemath_datatypes` for more details. n Numbers of rows and columns of ``A``. Must be at least zero. @@ -124,22 +124,22 @@ trsv (Buffer Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` -.. _onemkl_blas_trsv_usm: +.. _onemath_blas_trsv_usm: trsv (USM Version) ------------------ @@ -148,11 +148,11 @@ trsv (USM Version) .. code-block:: cpp - namespace oneapi::mkl::blas::column_major { + namespace oneapi::math::blas::column_major { sycl::event trsv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, const T *a, std::int64_t lda, @@ -162,11 +162,11 @@ trsv (USM Version) } .. code-block:: cpp - namespace oneapi::mkl::blas::row_major { + namespace oneapi::math::blas::row_major { sycl::event trsv(sycl::queue &queue, - oneapi::mkl::uplo upper_lower, - oneapi::mkl::transpose trans, - oneapi::mkl::diag unit_nonunit, + oneapi::math::uplo upper_lower, + oneapi::math::transpose trans, + oneapi::math::diag unit_nonunit, std::int64_t n, const T *a, std::int64_t lda, @@ -183,14 +183,14 @@ trsv (USM Version) The queue where the routine should be executed. upper_lower - Specifies whether ``A`` is upper or lower triangular. See :ref:`onemkl_datatypes` for more details. + Specifies whether ``A`` is upper or lower triangular. See :ref:`onemath_datatypes` for more details. trans Specifies op(``A``), the transposition operation applied to - ``A``. See :ref:`onemkl_datatypes` for more details. + ``A``. See :ref:`onemath_datatypes` for more details. unit_nonunit - Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemkl_datatypes` for more details. + Specifies whether the matrix ``A`` is unit triangular or not. See :ref:`onemath_datatypes` for more details. n Numbers of rows and columns of ``A``. Must be at least zero. @@ -236,20 +236,20 @@ trsv (USM Version) This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` - :ref:`oneapi::mkl::unsupported_device` + :ref:`oneapi::math::unsupported_device` - :ref:`oneapi::mkl::host_bad_alloc` + :ref:`oneapi::math::host_bad_alloc` - :ref:`oneapi::mkl::device_bad_alloc` + :ref:`oneapi::math::device_bad_alloc` - :ref:`oneapi::mkl::unimplemented` + :ref:`oneapi::math::unimplemented` **Parent topic:** :ref:`blas-level-2-routines` diff --git a/source/elements/oneMKL/source/domains/dense_linear_algebra.inc.rst b/source/elements/oneMath/source/domains/dense_linear_algebra.inc.rst similarity index 53% rename from source/elements/oneMKL/source/domains/dense_linear_algebra.inc.rst rename to source/elements/oneMath/source/domains/dense_linear_algebra.inc.rst index 517ce35169..98d4eef97e 100644 --- a/source/elements/oneMKL/source/domains/dense_linear_algebra.inc.rst +++ b/source/elements/oneMath/source/domains/dense_linear_algebra.inc.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_dense_linear_algebra: +.. _onemath_dense_linear_algebra: Dense Linear Algebra --------------------- This section contains information about dense linear algebra routines: -:ref:`matrix-storage` provides information about dense matrix and vector storage formats that are used by oneMKL :ref:`onemkl_blas` and :ref:`onemkl_lapack`. +:ref:`matrix-storage` provides information about dense matrix and vector storage formats that are used by oneMath :ref:`onemath_blas` and :ref:`onemath_lapack`. -:ref:`onemkl_blas` provides vector, matrix-vector, and matrix-matrix routines for dense matrices and vector operations. +:ref:`onemath_blas` provides vector, matrix-vector, and matrix-matrix routines for dense matrices and vector operations. :ref:`value_or_pointer` describes some details of how scalar parameters (such as ``alpha`` and ``beta``) are handled so that users may pass either values or pointers for these parameters. -:ref:`onemkl_lapack` provides more complex dense linear algebra routines, e.g., matrix factorization, solving dense systems of linear equations, least square problems, eigenvalue and singular value problems, and performing a number of related computational tasks. +:ref:`onemath_lapack` provides more complex dense linear algebra routines, e.g., matrix factorization, solving dense systems of linear equations, least square problems, eigenvalue and singular value problems, and performing a number of related computational tasks. .. toctree:: :hidden: diff --git a/source/elements/oneMKL/source/domains/dft/compute_backward.rst b/source/elements/oneMath/source/domains/dft/compute_backward.rst similarity index 93% rename from source/elements/oneMKL/source/domains/dft/compute_backward.rst rename to source/elements/oneMath/source/domains/dft/compute_backward.rst index 2065f4a606..b84be05352 100644 --- a/source/elements/oneMKL/source/domains/dft/compute_backward.rst +++ b/source/elements/oneMath/source/domains/dft/compute_backward.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_dft_compute_backward: +.. _onemath_dft_compute_backward: The ``compute_backward`` function templates =========================================== -The ``oneapi::mkl::dft::compute_backward`` function templates enable the +The ``oneapi::math::dft::compute_backward`` function templates enable the computation of backward DFT(s), as defined by a (committed) -``oneapi::mkl::dft::descriptor`` object, on user-provided data. These function -templates are declared in the ``oneapi::mkl::dft`` namespace; the usage of -prepended namespace specifiers ``oneapi::mkl::dft`` is omitted below for conciseness. +``oneapi::math::dft::descriptor`` object, on user-provided data. These function +templates are declared in the ``oneapi::math::dft`` namespace; the usage of +prepended namespace specifiers ``oneapi::math::dft`` is omitted below for conciseness. -.. _onemkl_dft_compute_backward_description: +.. _onemath_dft_compute_backward_description: .. rubric:: Description @@ -34,9 +34,9 @@ progress of the enqueued DFT calculations. The ``compute_backward`` functions may need to access the internals and private/protected members of (some) ``descriptor`` classes. This could be done, for instance, by labeling them as friend functions to the - ``descriptor`` :ref:`class template`. + ``descriptor`` :ref:`class template`. -.. onemkl_dft_compute_backward_buffer: +.. onemath_dft_compute_backward_buffer: ``compute_backward`` (Buffer versions) -------------------------------------- @@ -45,7 +45,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void compute_backward(descriptor_type &desc, @@ -57,7 +57,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void compute_backward(descriptor_type &desc, @@ -70,7 +70,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void compute_backward(descriptor_type &desc, @@ -82,7 +82,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void compute_backward(descriptor_type &desc, @@ -198,16 +198,16 @@ progress of the enqueued DFT calculations. .. rubric:: Throws The ``compute_backward`` functions shall throw the following - :ref:`exception` if the associated condition is + :ref:`exception` if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here: - ``oneapi::mkl::invalid_argument()`` + ``oneapi::math::invalid_argument()`` If ``desc`` is invalid. For instance, if its configuration value associated with configuration parameter ``config_param::COMMIT_STATUS`` is not ``config_param::COMMITTED``. -.. onemkl_dft_compute_backward_usm: +.. onemath_dft_compute_backward_usm: ``compute_backward`` (USM versions) ----------------------------------- @@ -216,7 +216,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template sycl::event compute_backward(descriptor_type &desc, @@ -228,7 +228,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template sycl::event compute_backward(descriptor_type &desc, @@ -241,7 +241,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template sycl::event compute_backward(descriptor_type &desc, @@ -254,7 +254,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template sycl::event compute_backward(descriptor_type &desc, @@ -374,11 +374,11 @@ progress of the enqueued DFT calculations. .. rubric:: Throws The ``compute_backward`` functions shall throw the following - :ref:`exception` if the associated condition is + :ref:`exception` if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here: - ``oneapi::mkl::invalid_argument()`` + ``oneapi::math::invalid_argument()`` If ``desc`` is invalid. For instance, if its configuration value associated with configuration parameter ``config_param::COMMIT_STATUS`` is not ``config_param::COMMITTED``. It will also be thrown if any required @@ -393,4 +393,4 @@ progress of the enqueued DFT calculations. routines, which may depend on the result of the backward transform(s) before proceeding with other operations. -**Parent topic:** :ref:`onemkl_dft` +**Parent topic:** :ref:`onemath_dft` diff --git a/source/elements/oneMKL/source/domains/dft/compute_forward.rst b/source/elements/oneMath/source/domains/dft/compute_forward.rst similarity index 94% rename from source/elements/oneMKL/source/domains/dft/compute_forward.rst rename to source/elements/oneMath/source/domains/dft/compute_forward.rst index 4543b18d5c..6923b5e57c 100644 --- a/source/elements/oneMKL/source/domains/dft/compute_forward.rst +++ b/source/elements/oneMath/source/domains/dft/compute_forward.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_dft_compute_forward: +.. _onemath_dft_compute_forward: The ``compute_forward`` function templates ========================================== -The ``oneapi::mkl::dft::compute_forward`` function templates enable the +The ``oneapi::math::dft::compute_forward`` function templates enable the computation of forward DFT(s), as defined by a (committed) -``oneapi::mkl::dft::descriptor`` object, on user-provided data. These function -templates are declared in the ``oneapi::mkl::dft`` namespace; the usage of -prepended namespace specifiers ``oneapi::mkl::dft`` is omitted below for conciseness. +``oneapi::math::dft::descriptor`` object, on user-provided data. These function +templates are declared in the ``oneapi::math::dft`` namespace; the usage of +prepended namespace specifiers ``oneapi::math::dft`` is omitted below for conciseness. -.. _onemkl_dft_compute_forward_description: +.. _onemath_dft_compute_forward_description: .. rubric:: Description @@ -34,9 +34,9 @@ progress of the enqueued DFT calculations. The ``compute_forward`` functions may need to access the internals and private/protected members of (some) ``descriptor`` classes. This could be done, for instance, by labeling them as friend functions to the - ``descriptor`` :ref:`class template`. + ``descriptor`` :ref:`class template`. -.. onemkl_dft_compute_forward_buffer: +.. onemath_dft_compute_forward_buffer: ``compute_forward`` (Buffer versions) ------------------------------------- @@ -45,7 +45,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void compute_forward(descriptor_type &desc, @@ -57,7 +57,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void compute_forward(descriptor_type &desc, @@ -70,7 +70,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void compute_forward(descriptor_type &desc, @@ -82,7 +82,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void compute_forward(descriptor_type &desc, @@ -199,16 +199,16 @@ progress of the enqueued DFT calculations. .. rubric:: Throws The ``compute_forward`` functions shall throw the following - :ref:`exception` if the associated condition is + :ref:`exception` if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here: - ``oneapi::mkl::invalid_argument()`` + ``oneapi::math::invalid_argument()`` If ``desc`` is invalid. For instance, if its configuration value associated with configuration parameter ``config_param::COMMIT_STATUS`` is not ``config_param::COMMITTED``. -.. onemkl_dft_compute_forward_usm: +.. onemath_dft_compute_forward_usm: ``compute_forward`` (USM versions) ---------------------------------- @@ -217,7 +217,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template sycl::event compute_forward(descriptor_type &desc, @@ -229,7 +229,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template sycl::event compute_forward(descriptor_type &desc, @@ -242,7 +242,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template sycl::event compute_forward(descriptor_type &desc, @@ -255,7 +255,7 @@ progress of the enqueued DFT calculations. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template sycl::event compute_forward(descriptor_type &desc, @@ -375,11 +375,11 @@ progress of the enqueued DFT calculations. .. rubric:: Throws The ``compute_forward`` functions shall throw the following - :ref:`exception` if the associated condition is + :ref:`exception` if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here: - ``oneapi::mkl::invalid_argument()`` + ``oneapi::math::invalid_argument()`` If ``desc`` is invalid. For instance, if its configuration value associated with configuration parameter ``config_param::COMMIT_STATUS`` is not ``config_param::COMMITTED``. It will also be thrown if any required @@ -394,4 +394,4 @@ progress of the enqueued DFT calculations. routines, which may depend on the result of the forward transform(s) before proceeding with other operations. -**Parent topic:** :ref:`onemkl_dft` +**Parent topic:** :ref:`onemath_dft` diff --git a/source/elements/oneMKL/source/domains/dft/config_params/data_layouts.rst b/source/elements/oneMath/source/domains/dft/config_params/data_layouts.rst similarity index 85% rename from source/elements/oneMKL/source/domains/dft/config_params/data_layouts.rst rename to source/elements/oneMath/source/domains/dft/config_params/data_layouts.rst index 9720aea80b..01b5ca8652 100644 --- a/source/elements/oneMKL/source/domains/dft/config_params/data_layouts.rst +++ b/source/elements/oneMath/source/domains/dft/config_params/data_layouts.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_dft_config_data_layouts: +.. _onemath_dft_config_data_layouts: Configuration of data layouts ----------------------------- -The usage of prepended namespace specifiers ``oneapi::mkl::dft`` is +The usage of prepended namespace specifiers ``oneapi::math::dft`` is omitted below for conciseness. The DFT interface provides the configuration parameters @@ -20,11 +20,11 @@ accordingly, ``config_param::FWD_DISTANCE`` (resp. specifying the distances between successive data sequences in the forward (resp. backward) domain. -Using the notations from the :ref:`introduction` and the +Using the notations from the :ref:`introduction` and the superscript :math:`\text{fwd}` (resp. :math:`\text{bwd}`) for data sequences belonging to forward (resp. backward) domain, for any :math:`m` and multi-index :math:`\left(k_1, k_2, \ldots, k_d\right)` within :ref:`valid -range`, the corresponding entry +range`, the corresponding entry :math:`\left(\cdot\right)^{m}_{k_{1}, k_{2}, \dots, k_d }` – or the real or imaginary part thereof – of the relevant data sequence is located at index @@ -35,31 +35,31 @@ imaginary part thereof – of the relevant data sequence is located at index of the corresponding data container (``sycl::buffer`` object or device-accessible USM allocation) provided to the compute function, the base data type of which is (possibly implicitly re-interpreted) as documented in the -:ref:`table` +:ref:`table` below. In the index expression :eq:`eq_idx_data_layout`, :math:`\text{x} = \text{f}` (resp. :math:`\text{x} = \text{b}`) for entries of forward-domain (resp. backward-domain) data sequences and - :math:`s^{\text{xwd}}_j`, :math:`\forall j \in \lbrace 0, \ldots, d\rbrace` represents the :ref:`offset and generalized - strides` defining the locations of entries within + strides` defining the locations of entries within each :math:`d`-dimensional data sequence in the forward (resp. backward) domain if :math:`\text{x} = \text{f}` (resp. if :math:`\text{x} = \text{b}`), counted in number of elements of the relevant :ref:`implicitly-assumed - elementary data type`; + elementary data type`; - :math:`l^{\text{xwd}}` represents the - :ref:`distance` between successive + :ref:`distance` between successive :math:`d`-dimensional data sequences in the forward (resp. backward) domain if :math:`\text{x} = \text{f}` (resp. if :math:`\text{x} = \text{b}`), counted in number of elements of the relevant :ref:`implicitly-assumed elementary data - type`. + type`. .. note:: All data sequences (or respective real and imaginary parts thereof if separately stored) must belong to the same block allocation, as a consequence of the generalized index :eq:`eq_idx_data_layout`. -.. _onemkl_dft_config_data_implicitly_assumed_elementary_data_type: +.. _onemath_dft_config_data_implicitly_assumed_elementary_data_type: .. rubric:: Implicitly-assumed elementary data type @@ -69,7 +69,7 @@ re-interpret the base data type of that data container into an implicitly-assumed elementary data type. That implicitly-assumed data type depends on the object type, *i.e.*, on the specialization values used for the template parameters when instantiating the -``descriptor`` :ref:`class template`, and, in case of +``descriptor`` :ref:`class template`, and, in case of complex descriptors, on the configuration value set for its configuration parameter ``config_param::COMPLEX_STORAGE``. The table below lists the implicitly-assumed data type in either domain (last 2 columns) based on the object type and @@ -108,7 +108,7 @@ its configuration value for ``config_param::COMPLEX_STORAGE`` (first 2 columns). - ``double`` - ``std::complex`` -.. _onemkl_dft_num_dft_data_layouts_batched_dfts: +.. _onemath_dft_num_dft_data_layouts_batched_dfts: .. rubric:: Configuring data layouts for batched transforms @@ -125,9 +125,9 @@ configuration parameter ``config_param::NUMBER_OF_TRANSFORMS``. In that case, the configuration parameters ``config_param::FWD_DISTANCE`` and ``config_param::BWD_DISTANCE`` *must also* be set explicitly since their default configuration values of :math:`0` would break the :ref:`consistency -requirements` for any :math:`M > 1`. +requirements` for any :math:`M > 1`. -.. _onemkl_dft_fwd_bwd_strides: +.. _onemath_dft_fwd_bwd_strides: .. rubric:: Configuring strides in forward and backward domains @@ -145,7 +145,7 @@ The default values set for the forward and backward strides correspond to the data layout configurations for unbatched, in-place transforms using unit stride along the last dimension with no offset (and minimal padding in forward domain in case of real descriptors, aligning with the :ref:`requirements for -in-place transforms`). In other words, the +in-place transforms`). In other words, the default values are :math:`s^{\text{fwd}}_0 = s^{\text{bwd}}_0 = 0`, :math:`s^{\text{fwd}}_d = s^{\text{bwd}}_d = 1` and, for :math:`d`-dimensional DFTs with :math:`d > 1`, @@ -158,7 +158,7 @@ DFTs with :math:`d > 1`, for :math:`k \in \lbrace 1, \ldots, d - 2\rbrace` (for :math:`\text{x} = \text{f}` and :math:`\text{x} = \text{b}`). -.. _onemkl_dft_data_layout_requirements: +.. _onemath_dft_data_layout_requirements: .. rubric:: General consistency requirements @@ -168,7 +168,7 @@ under consideration. In other words, there must not be one index value as expressed in :eq:`eq_idx_data_layout` that corresponds to two different :math:`(d+1)`-tuples :math:`(m, k_{1}, k_{2}, \dots, k_d)` that are both within the :ref:`elementary range of indices considered by -oneMKL`. +oneMath`. Additionally, for in-place transforms (configuration value ``config_value::INPLACE`` associated with configuration parameter @@ -178,14 +178,14 @@ abide by following "*consistency requirement*": the memory address(es) of leading entry(ies) along the last dimension must be identical in forward and backward domains. Specifically, considering any :math:`(d+1)`-tuple :math:`(m, k_{1}, k_{2}, \dots, k_{d-1}, 0)` within :ref:`valid -range`, the memory address of the +range`, the memory address of the element of corresponding index value :eq:`eq_idx_data_layout` in forward domain (considering the :ref:`implicitly assumed -type` in forward +type` in forward domain) must be identical to the memory address of the element of corresponding index value :eq:`eq_idx_data_layout` in backward domain (considering the :ref:`implicitly assumed -type` in +type` in backward domain). Equivalently, - for complex descriptors, the offset, stride(s) (and distances, if relevant) @@ -197,7 +197,7 @@ backward domain). Equivalently, this leads to some data padding being required in forward domain if unit strides are used along the last dimension in forward and backward domains. -.. _onemkl_dft_io_strides_deprecated: +.. _onemath_dft_io_strides_deprecated: .. rubric:: Configuring strides for input and output data [deprecated, **not** recommended] @@ -214,7 +214,7 @@ configuration parameter ``config_param::INPUT_STRIDES`` if :math:`\text{x} = \text{o}`). The values of :math:`s^{\text{i}}_{j}` and :math:`s^{\text{o}}_{j}` are to be -used and considered by oneMKL if and only if +used and considered by oneMath if and only if :math:`s^{\text{fwd}}_{j} = s^{\text{bwd}}_{j} = 0, \forall j \in \lbrace 0, 1, \ldots, d\rbrace`. This will happen automatically if ``config_param::INPUT_STRIDES`` and ``config_param::OUTPUT_STRIDES`` are set and ``config_param::FWD_STRIDES`` and @@ -225,10 +225,10 @@ relevant data sequence entries are accessed as elements of data containers (``sycl::buffer`` objects or device-accessible USM allocations) provided to the compute function, the base data type of which is (possibly implicitly re-interpreted) as documented in the above -:ref:`table`. If +:ref:`table`. If using input and output strides, for any :math:`m` and multi-index :math:`\left(k_1, k_2, \ldots, k_d\right)` within :ref:`valid -range`, the index to be used when +range`, the index to be used when accessing a data sequence entry – or part thereof – in forward domain is .. math:: @@ -248,21 +248,21 @@ As a consequence, configuring ``descriptor`` objects using these deprecated configuration parameters makes their configuration direction-dependent when different stride values are used in forward and backward domains. Since the intended compute direction is unknown to the object when -:ref:`committing` it, every direction that results -in a :ref:`consistent data layout` in +:ref:`committing` it, every direction that results +in a :ref:`consistent data layout` in forward and backward domains must be supported by successfully-committed ``descriptor`` objects. .. note:: For ``descriptor`` objects with strides configured via these deprecated configuration parameters, the - :ref:`consistency requirements` may be + :ref:`consistency requirements` may be satisfied for only one of the two compute directions, *i.e.*, for only one of the forward or backward DFT(s). Such a configuration should not cause an exception to be thrown by the descriptor's ``commit`` - :ref:`member function` but the behavior of - oneMKL is undefined if using that object for the compute direction that does - not align with the :ref:`consistency requirements`. + :ref:`member function` but the behavior of + oneMath is undefined if using that object for the compute direction that does + not align with the :ref:`consistency requirements`. .. note:: Setting either of ``config_param::INPUT_STRIDES`` or @@ -275,7 +275,7 @@ forward and backward domains must be supported by successfully-committed which is **not** to be supported. If such a configuration is attempted, an exception is to be thrown at commit time due to invalid configuration, as the stride values that were implicitly reset surely invalidate the - :ref:`consistency requirements` for any + :ref:`consistency requirements` for any non-trivial DFT. If specifying the data layout strides using these deprecated configuration @@ -285,7 +285,7 @@ the reverse direction as shown below. .. code-block:: cpp - namespace dft = oneapi::mkl::dft; + namespace dft = oneapi::math::dft; // ... desc.set_value(dft::config_param::INPUT_STRIDES, fwd_domain_strides); desc.set_value(dft::config_param::OUTPUT_STRIDES, bwd_domain_strides); @@ -302,4 +302,4 @@ parameters are deprecated. A warning message "{IN,OUT}PUT_STRIDES are deprecated please use {F,B}WD_STRIDES, instead." is to be reported to applications using these configuration parameters. -**Parent topic** :ref:`onemkl_dft_enums` +**Parent topic** :ref:`onemath_dft_enums` diff --git a/source/elements/oneMKL/source/domains/dft/config_params/storage_formats.rst b/source/elements/oneMath/source/domains/dft/config_params/storage_formats.rst similarity index 94% rename from source/elements/oneMKL/source/domains/dft/config_params/storage_formats.rst rename to source/elements/oneMath/source/domains/dft/config_params/storage_formats.rst index 7a8dfcdaea..17d2fc657b 100644 --- a/source/elements/oneMKL/source/domains/dft/config_params/storage_formats.rst +++ b/source/elements/oneMath/source/domains/dft/config_params/storage_formats.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_dft_data_storage: +.. _onemath_dft_data_storage: Data storage ============ -The usage of prepended namespace specifiers ``oneapi::mkl::dft`` is +The usage of prepended namespace specifiers ``oneapi::math::dft`` is omitted below for conciseness. The data storage convention observed by a ``descriptor`` object depends on @@ -15,7 +15,7 @@ whether it is a real or complex descriptor and, in case of complex descriptors, on the configuration value associated with configuration parameter ``config_param::COMPLEX_STORAGE``. -.. _onemkl_dft_complex_storage: +.. _onemath_dft_complex_storage: Complex descriptors ------------------- @@ -36,7 +36,7 @@ and imaginary parts of those entries are accessed and stored as ``float`` (resp. These two behaviors are further specified and illustrated below. -.. _onemkl_dft_complex_storage_complex_complex: +.. _onemath_dft_complex_storage_complex_complex: .. rubric:: ``config_value::COMPLEX_COMPLEX`` for ``config_param::COMPLEX_STORAGE`` @@ -47,7 +47,7 @@ allocation or ``sycl::buffer`` object). Any relevant entry :math:`\left(\cdot\right)^{m}_{k_1, k_2,\dots ,k_d}` is accessed/stored from/in a data container provided at compute time at the index value expressed in eq. :eq:`eq_idx_data_layout` (see the page dedicated to the -:ref:`configuration of data layout`) +:ref:`configuration of data layout`) of that data container, whose elementary data type is (possibly implicitly re-interpreted as) ``std::complex`` (resp. ``std::complex``) for single-precision (resp. double-precision) descriptors. @@ -69,7 +69,7 @@ USM allocations. .. code-block:: cpp - namespace dft = oneapi::mkl::dft; + namespace dft = oneapi::math::dft; dft::descriptor desc({n1, n2, n3}); std::vector strides({0, n2*n3, n3, 1}); std::int64_t dist = n1*n2*n3; @@ -88,7 +88,7 @@ USM allocations. // Upon completion of ev, in backward domain: entry {m;k1,k2,k3} // = Z[ strides[0] + k1*strides[1] + k2*strides[2] + k3*strides[3] + m*dist ] -.. _onemkl_dft_complex_storage_real_real: +.. _onemath_dft_complex_storage_real_real: .. rubric:: ``config_value::REAL_REAL`` for ``config_param::COMPLEX_STORAGE`` @@ -100,7 +100,7 @@ the real and imaginary parts of the relevant entries separately. The real and imaginary parts of any relevant complex entry :math:`\left(\cdot\right)^{m}_{k_1, k_2,\dots ,k_d}` are both stored at the index value expressed in eq. :eq:`eq_idx_data_layout` (see the page dedicated to -the :ref:`configuration of data layout`) of +the :ref:`configuration of data layout`) of their respective data containers, whose elementary data type is (possibly implicitly re-interpreted as) ``float`` (resp. ``double``) for single-precision (resp. double-precision) descriptors. @@ -122,7 +122,7 @@ USM allocations. .. code-block:: cpp - namespace dft = oneapi::mkl::dft; + namespace dft = oneapi::math::dft; dft::descriptor desc({n1, n2, n3}); std::vector strides({0, n2*n3, n3, 1}); std::int64_t dist = n1*n2*n3; @@ -146,7 +146,7 @@ USM allocations. // and the imaginary part of entry {m;k1,k2,k3} // = ZI[ strides[0] + k1*strides[1] + k2*strides[2] + k3*strides[3] + m*dist ] -.. _onemkl_dft_real_storage: +.. _onemath_dft_real_storage: Real descriptors ---------------- @@ -171,7 +171,7 @@ forward and backward domains, with USM allocations. .. code-block:: cpp - namespace dft = oneapi::mkl::dft; + namespace dft = oneapi::math::dft; dft::descriptor desc({n1, n2, n3}); // Note: integer divisions here below std::vector fwd_strides({0, 2*n2*(n3/2 + 1), 2*(n3/2 + 1), 1}); @@ -197,4 +197,4 @@ forward and backward domains, with USM allocations. // Note: if n3/2 < k3 < n3, entry {m;k1,k2,k3} is not stored explicitly // since it is equal to std::conj(entry {m;n1-k1,n2-k2,n3-k3}) -**Parent topic** :ref:`onemkl_dft_enums` +**Parent topic** :ref:`onemath_dft_enums` diff --git a/source/elements/oneMKL/source/domains/dft/config_params/workspace_placement.rst b/source/elements/oneMath/source/domains/dft/config_params/workspace_placement.rst similarity index 86% rename from source/elements/oneMKL/source/domains/dft/config_params/workspace_placement.rst rename to source/elements/oneMath/source/domains/dft/config_params/workspace_placement.rst index d187810fe6..55ffcf94fb 100644 --- a/source/elements/oneMKL/source/domains/dft/config_params/workspace_placement.rst +++ b/source/elements/oneMath/source/domains/dft/config_params/workspace_placement.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_dft_config_workspace_placement: +.. _onemath_dft_config_workspace_placement: Workspace placement ------------------- -The usage of prepended namespace specifiers ``oneapi::mkl::dft`` is +The usage of prepended namespace specifiers ``oneapi::math::dft`` is omitted below for conciseness. DFT implementations often require temporary storage for intermediate data whilst computing DFTs. @@ -25,7 +25,7 @@ For some backends and configurations, externally-managed workspaces may reduce performance. A typical workflow for using externally-managed workspaces is given -:ref:`below`. +:ref:`below`. Automatically- and externally-managed workspaces ++++++++++++++++++++++++++++++++++++++++++++++++ @@ -36,7 +36,7 @@ it manages its workspace automatically (configuration value ``config_value::WORKSPACE_AUTOMATIC``) or if it is to be provided with an external workspace (configuration value ``config_value::WORKSPACE_EXTERNAL``). -.. _onemkl_dft_config_value_workspace_automatic: +.. _onemath_dft_config_value_workspace_automatic: .. rubric:: Automatically-managed workspace @@ -44,7 +44,7 @@ The default value for the ``config_param::WORKSPACE_PLACEMENT`` is ``config_valu When set to ``config_value::WORKSPACE_AUTOMATIC`` the user does not need to provide an external workspace. The workspace will be automatically managed by the backend library. -.. _onemkl_dft_config_value_workspace_external: +.. _onemath_dft_config_value_workspace_external: .. rubric:: Externally-managed workspace @@ -55,10 +55,10 @@ When a descriptor is committed with ``config_value::WORKSPACE_EXTERNAL`` set for ``config_param::WORKSPACE_PLACEMENT``, the user must provide an external workspace before calling any compute function. More details can be found in the section dedicated to the ``set_workspace`` -:ref:`member function` and in the typical -usage illustrated :ref:`below`. +:ref:`member function` and in the typical +usage illustrated :ref:`below`. -.. _onemkl_dft_typical_usage_of_workspace_external: +.. _onemath_dft_typical_usage_of_workspace_external: Typical usage of externally-managed workspaces ++++++++++++++++++++++++++++++++++++++++++++++ @@ -77,7 +77,7 @@ This is shown in the following example code: .. code-block:: cpp - namespace dft = oneapi::mkl::dft; + namespace dft = oneapi::math::dft; // Create a descriptor dft::descriptor desc(n); // 1. Set the workspace placement to WORKSPACE_EXTERNAL @@ -97,5 +97,5 @@ This is shown in the following example code: // 5. Now USM compute functions can be called. -**Parent topic:** :ref:`onemkl_dft_enums` +**Parent topic:** :ref:`onemath_dft_enums` diff --git a/source/elements/oneMKL/source/domains/dft/descriptor.rst b/source/elements/oneMath/source/domains/dft/descriptor.rst similarity index 86% rename from source/elements/oneMKL/source/domains/dft/descriptor.rst rename to source/elements/oneMath/source/domains/dft/descriptor.rst index 2cdd7f8130..0bff502f9a 100644 --- a/source/elements/oneMKL/source/domains/dft/descriptor.rst +++ b/source/elements/oneMath/source/domains/dft/descriptor.rst @@ -2,21 +2,21 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_dft_descriptor: +.. _onemath_dft_descriptor: The ``descriptor`` class template ================================= -Instances of any ``oneapi::mkl::dft::descriptor`` class define DFT(s) to be -computed. The usage of prepended namespace specifiers ``oneapi::mkl::dft`` is +Instances of any ``oneapi::math::dft::descriptor`` class define DFT(s) to be +computed. The usage of prepended namespace specifiers ``oneapi::math::dft`` is omitted below for conciseness. Description +++++++++++ Any desired DFT is fully defined by an instance of a specialization of the -``descriptor`` class template, declared in the ``oneapi::mkl::dft`` namespace. -The :ref:`scoped enumeration types` ``precision``, ``domain``, +``descriptor`` class template, declared in the ``oneapi::math::dft`` namespace. +The :ref:`scoped enumeration types` ``precision``, ``domain``, ``config_param`` and ``config_value`` defined in the same namespace (and the corresponding ranges of values) are relevant to the definition and configurations of such objects. Users can set several (resp. query all) @@ -29,7 +29,7 @@ device encapsulated by the ``sycl::queue`` object required by that function. The desired forward (resp. backward) DFT calculations may then be computed by passing such a committed ``descriptor`` object to a ``compute_forward`` (resp. -``compute_backward``) function (defined in the ``oneapi::mkl::dft`` namespace as +``compute_backward``) function (defined in the ``oneapi::math::dft`` namespace as well), along with the relevant data containers (``sycl::buffer`` object(s) or pointer(s) to a device-accessible USM allocations) for the desired DFT(s). This function makes the ``descriptor`` object enqueue the operations relevant for the @@ -45,7 +45,7 @@ desired calculations to the ``sycl::queue`` object it was given when committing .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template class descriptor { @@ -104,7 +104,7 @@ desired calculations to the ``sycl::queue`` object it was given when committing }; } -.. _onemkl_dft_descriptor_template_parameters: +.. _onemath_dft_descriptor_template_parameters: .. rubric:: Template parameters @@ -126,7 +126,7 @@ desired calculations to the ``sycl::queue`` object it was given when committing ``domain::REAL``) as ``dom`` are referred to as "complex descriptors" (resp. "real descriptors"). -.. _onemkl_dft_descriptor_member_table: +.. _onemath_dft_descriptor_member_table: .. rubric:: Member functions of the ``descriptor`` class template @@ -136,29 +136,29 @@ desired calculations to the ``sycl::queue`` object it was given when committing * - Routines - Description - * - :ref:`constructors` + * - :ref:`constructors` - Create a ``descriptor`` object. The parameterized constructors enable the (one-time) definition of the length(s) :math:`\lbrace n_1, \ldots, n_d\rbrace` (the dimension :math:`d` is deduced accordingly). The parameterized constructors default-initialize the object; copy and move constructors do not. - * - :ref:`assignment operators` + * - :ref:`assignment operators` - Perform a deep copy of or moves the argument. - * - ``set_value`` :ref:`member functions` + * - ``set_value`` :ref:`member functions` - Set a configuration value for a specific configuration parameter. - * - ``get_value`` :ref:`member functions` + * - ``get_value`` :ref:`member functions` - Query the configuration value associated with a particular configuration parameter. - * - ``set_workspace`` :ref:`member function` + * - ``set_workspace`` :ref:`member function` - Equips the ``descriptor`` object with an external workspace. - * - ``commit`` :ref:`member function` + * - ``commit`` :ref:`member function` - Commits the ``descriptor`` object to enqueue the operations relevant to the DFT(s) it determines to a given, user-provided ``sycl::queue`` object; completes all initialization work relevant to and required by the chosen, device-compliant implementation for the particular DFT, as defined by the ``descriptor`` object. -.. _onemkl_dft_descriptor_constructors: +.. _onemath_dft_descriptor_constructors: Constructors ++++++++++++ @@ -168,7 +168,7 @@ all the relevant default configuration settings (which may depend on the specialization values for ``prec`` and ``dom``). The constructors do not perform any significant initialization work as changes in the object's configuration(s) may be operated thereafter (via its ``set_value`` -:ref:`member functions`) and modify +:ref:`member functions`) and modify significantly the nature of that work. The copy constructor performs a deep copy of ``descriptor`` objects. @@ -180,7 +180,7 @@ without copying them. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template descriptor::descriptor(std::int64_t length); @@ -192,7 +192,7 @@ without copying them. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template descriptor::descriptor(std::vector lengths); @@ -203,7 +203,7 @@ without copying them. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template descriptor::descriptor(const descriptor& other); @@ -214,7 +214,7 @@ without copying them. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template descriptor::descriptor(descriptor&& other); @@ -244,23 +244,23 @@ without copying them. .. rubric:: Throws The constructors shall throw the following - :ref:`exceptions` if the associated condition is + :ref:`exceptions` if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here: - ``oneapi::mkl::host_bad_alloc()`` + ``oneapi::math::host_bad_alloc()`` If any memory allocations on host have failed, for instance due to insufficient memory. - ``oneapi::mkl::unimplemented()`` + ``oneapi::math::unimplemented()`` If the dimension :math:`d`, *i.e.*, the size of ``lengths``, is larger than what is supported by the library implementation. -**Descriptor class member table:** :ref:`onemkl_dft_descriptor_member_table` +**Descriptor class member table:** :ref:`onemath_dft_descriptor_member_table` -.. _onemkl_dft_descriptor_assignment_operators: +.. _onemath_dft_descriptor_assignment_operators: Assignment operators ++++++++++++++++++++ @@ -271,7 +271,7 @@ The copy assignment operator results in a deep copy. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template descriptor& descriptor::operator=(const descriptor& other); @@ -282,7 +282,7 @@ The copy assignment operator results in a deep copy. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template descriptor& descriptor::operator=(descriptor&& other); @@ -302,17 +302,17 @@ The copy assignment operator results in a deep copy. .. rubric:: Throws The assignment operators shall throw the following - :ref:`exception` if the associated condition is + :ref:`exception` if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here: - ``oneapi::mkl::host_bad_alloc()`` + ``oneapi::math::host_bad_alloc()`` If any memory allocations on host have failed, for instance due to insufficient memory. -**Descriptor class member table:** :ref:`onemkl_dft_descriptor_member_table` +**Descriptor class member table:** :ref:`onemath_dft_descriptor_member_table` -.. _onemkl_dft_descriptor_set_value: +.. _onemath_dft_descriptor_set_value: ``set_value`` member functions ++++++++++++++++++++++++++++++ @@ -322,14 +322,14 @@ configuration value corresponding to a (read-write) configuration parameter for the DFT(s) that it defines. These functions are to be used as many times as required for all the necessary configuration parameters to be set prior to committing the object (by calling its ``commit`` -:ref:`member function`). +:ref:`member function`). All these functions require and expect exactly **two** arguments: they set the given configuration value (second argument) for a desired configuration parameter (first argument), represented by ``param`` of type ``config_param``. The expected type of the associated configuration value (second argument) depends on ``param`` and is specified in the -:ref:`section` dedicated to the ``config_param`` +:ref:`section` dedicated to the ``config_param`` type and its enumerators (unless a deprecated version is used). The expected type of configuration value determines which of the ``set_value`` overloads is to be used for a specific value of ``param``. @@ -338,7 +338,7 @@ to be used for a specific value of ``param``. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::set_value(config_param param, std::int64_t value); @@ -354,7 +354,7 @@ This version of ``set_value`` supports the following values of ``param``: .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::set_value(config_param param, real_scalar_t value); @@ -370,7 +370,7 @@ This version of ``set_value`` supports the following values of ``param``: .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::set_value(config_param param, const std::vector& value); @@ -385,13 +385,13 @@ This version of ``set_value`` supports the following values of ``param``: ``value`` must be a vector of :math:`\left(d+1\right)` ``std::int64_t`` elements. More information about setting strides may be found in the page dedicated to -the :ref:`configuration of data layouts`. +the :ref:`configuration of data layouts`. .. rubric:: Syntax for parameters associated with non-numeric values .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::set_value(config_param param, config_value value); @@ -407,7 +407,7 @@ This version of ``set_value`` supports the following values of ``param``: .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::set_value(config_param param, const std::int64_t* value); @@ -432,7 +432,7 @@ recommended by the compile-time deprecation warning. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::set_value(config_param param, ...); @@ -442,7 +442,7 @@ recommended by the compile-time deprecation warning. This version supports all values of ``param`` corresponding to a writable configuration parameter. The variadic argument list must contain a unique element. When reading the latter (after default argument promotions of variadic -arguments, if applicable), oneMKL *assumes* that it is +arguments, if applicable), oneMath *assumes* that it is - an ``std::int64_t`` value if ``param`` is any of ``config_param::NUMBER_OF_TRANSFORMS``, ``config_param::FWD_DISTANCE``, or ``config_param::BWD_DISTANCE``; - a ``double`` value if ``param`` is any of ``FORWARD_SCALE``, ``BACKWARD_SCALE``; @@ -467,30 +467,30 @@ to inform about the recommended alternative. ``...`` The value to be set for the targeted configuration parameter, passed as a variadic argument list of **one** element. This usage is deprecated. - Note the type assumed by oneMKL when reading that value (specified above). + Note the type assumed by oneMath when reading that value (specified above). .. container:: section .. rubric:: Throws The ``set_value`` member functions shall throw the following - :ref:`exceptions` if the associated condition is + :ref:`exceptions` if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here: - ``oneapi::mkl::invalid_argument()`` + ``oneapi::math::invalid_argument()`` - If the provided ``param`` corresponds to a read-only configuration parameter; - If the overloaded version being used does not support ``param``; - If the provided ``param`` and/or configuration value are/is not valid. - ``oneapi::mkl::unimplemented()`` + ``oneapi::math::unimplemented()`` If the provided ``param`` and configuration value are valid, but not supported by the library implementation. -**Descriptor class member table:** :ref:`onemkl_dft_descriptor_member_table` +**Descriptor class member table:** :ref:`onemath_dft_descriptor_member_table` -.. _onemkl_dft_descriptor_get_value: +.. _onemath_dft_descriptor_get_value: ``get_value`` member functions ++++++++++++++++++++++++++++++ @@ -504,7 +504,7 @@ configuration value (into the element pointed by the second argument) corresponding to the queried configuration parameter (first argument) ``param`` of type ``config_param``. The second argument is a valid *pointer* to a configuration value whose type corresponds to ``param``, as specified in the -:ref:`section` dedicated to the ``config_param`` +:ref:`section` dedicated to the ``config_param`` type and its enumerators (unless a deprecated version is used). The expected type of configuration value determines which of the ``get_value`` overloads is to be used for a specific value of ``param``. @@ -519,7 +519,7 @@ to be used for a specific value of ``param``. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::get_value(config_param param, domain* value_ptr) const; @@ -532,7 +532,7 @@ This version of ``get_value`` supports only ``config_param::FORWARD_DOMAIN`` for .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::get_value(config_param param, precision* value_ptr) const; @@ -545,7 +545,7 @@ This version of ``get_value`` supports only ``config_param::PRECISION`` for .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::get_value(config_param param, std::int64_t* value_ptr) const; @@ -558,11 +558,11 @@ This version of ``get_value`` supports the following values of ``param``: - ``config_param::BWD_DISTANCE``; - ``config_param::DIMENSION``; - ``config_param::WORKSPACE_EXTERNAL_BYTES`` (requires the calling object to be committed); -- ``config_param::LENGTHS`` (deprecated usage if :math:`d > 1`, :math:`d` contiguous ``std::int64_t`` written by oneMKL) -- ``config_param::INPUT_STRIDES`` (deprecated usage, :math:`\left(d+1\right)` contiguous ``std::int64_t`` written by oneMKL); -- ``config_param::OUTPUT_STRIDES`` (deprecated usage, :math:`\left(d+1\right)` contiguous ``std::int64_t`` written by oneMKL); -- ``config_param::FWD_STRIDES`` (deprecated usage, :math:`\left(d+1\right)` contiguous ``std::int64_t`` written by oneMKL); -- ``config_param::BWD_STRIDES`` (deprecated usage, :math:`\left(d+1\right)` contiguous ``std::int64_t`` written by oneMKL); +- ``config_param::LENGTHS`` (deprecated usage if :math:`d > 1`, :math:`d` contiguous ``std::int64_t`` written by oneMath) +- ``config_param::INPUT_STRIDES`` (deprecated usage, :math:`\left(d+1\right)` contiguous ``std::int64_t`` written by oneMath); +- ``config_param::OUTPUT_STRIDES`` (deprecated usage, :math:`\left(d+1\right)` contiguous ``std::int64_t`` written by oneMath); +- ``config_param::FWD_STRIDES`` (deprecated usage, :math:`\left(d+1\right)` contiguous ``std::int64_t`` written by oneMath); +- ``config_param::BWD_STRIDES`` (deprecated usage, :math:`\left(d+1\right)` contiguous ``std::int64_t`` written by oneMath); Using this version for querying configuration values encapsulating more than one ``std::int64_t`` values is deprecated. A runtime deprecation warning may be @@ -572,7 +572,7 @@ emitted to inform about the recommended alternative in such cases. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::get_value(config_param param, real_scalar_t* value_ptr) const; @@ -590,7 +590,7 @@ single-precision (resp. double-precision) descriptors. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::get_value(config_param param, std::vector* value_ptr) const; @@ -613,7 +613,7 @@ This version of ``get_value`` supports the following values of ``param``: .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::get_value(config_param param, config_value* value_ptr) const; @@ -630,7 +630,7 @@ This version of ``get_value`` supports the following values of ``param``: .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::get_value(config_param param, ...) const; @@ -639,7 +639,7 @@ This version of ``get_value`` supports the following values of ``param``: This version supports all values of ``param``. The variadic argument list must contain a unique element. When reading the latter (after default argument -promotions of variadic arguments, if applicable), oneMKL assumes that it is of +promotions of variadic arguments, if applicable), oneMath assumes that it is of type - ``domain*`` if ``param`` is ``config_param::FORWARD_DOMAIN``; @@ -667,13 +667,13 @@ to inform about the recommended alternative. ``value_ptr`` A valid *pointer* to a configuration value (or configuration values) in - which oneMKL is allowed to write (return) the queried value(s). The type + which oneMath is allowed to write (return) the queried value(s). The type of this input argument depends on ``param`` as specified above. ``...`` A valid *pointer* to a configuration value (or configuration values), passed as a variadic argument list of **one** element. This usage is - deprecated. Note the type assumed by oneMKL when accessing that pointer + deprecated. Note the type assumed by oneMath when accessing that pointer (specified above) .. container:: section @@ -681,26 +681,26 @@ to inform about the recommended alternative. .. rubric:: Throws The ``get_value`` member functions shall throw the following - :ref:`exceptions` if the associated condition is + :ref:`exceptions` if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here: - ``oneapi::mkl::invalid_argument()`` + ``oneapi::math::invalid_argument()`` - If the overloaded version being used does not support ``param``; - If ``value_ptr`` is ``nullptr``; - If ``value_ptr->size()`` is not as expected when querying a vector-valued parameter. - ``oneapi::mkl::uninitialized`` + ``oneapi::math::uninitialized`` If ``param`` is ``config_param::WORKSPACE_EXTERNAL_BYTES`` and the calling object is not committed. - ``oneapi::mkl::unimplemented()`` + ``oneapi::math::unimplemented()`` If the queried ``param`` is valid, but not supported by the library implementation. -**Descriptor class member table:** :ref:`onemkl_dft_descriptor_member_table` +**Descriptor class member table:** :ref:`onemath_dft_descriptor_member_table` -.. _onemkl_dft_descriptor_set_workspace: +.. _onemath_dft_descriptor_set_workspace: ``set_workspace`` member function +++++++++++++++++++++++++++++++++ @@ -736,7 +736,7 @@ be used in compute calls. However, the aforementioned restrictions will still ap .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::set_workspace(sycl::buffer &workspaceBuf); @@ -746,7 +746,7 @@ be used in compute calls. However, the aforementioned restrictions will still ap .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::set_workspace(real_scalar_t* workspaceUSM); @@ -774,24 +774,24 @@ be used in compute calls. However, the aforementioned restrictions will still ap .. rubric:: Throws The ``set_workspace`` member function shall throw the following - :ref:`exceptions` if the associated condition is + :ref:`exceptions` if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here: - ``oneapi::mkl::invalid_argument()`` + ``oneapi::math::invalid_argument()`` If the provided buffer ``workspaceBuf`` is not sufficiently large or is a sub-buffer, or if the provided USM allocation ``workspaceUSM`` is ``nullptr`` when an external workspace of size greater than zero is required, or if the provided USM allocation ``workspaceUSM`` is not accessible by the device. - ``oneapi::mkl::uninitialized()`` + ``oneapi::math::uninitialized()`` If ``set_workspace`` is called before the descriptor is committed. -**Descriptor class member table:** :ref:`onemkl_dft_descriptor_member_table` +**Descriptor class member table:** :ref:`onemath_dft_descriptor_member_table` -.. _onemkl_dft_descriptor_commit: +.. _onemath_dft_descriptor_commit: ``commit`` member function ++++++++++++++++++++++++++ @@ -805,7 +805,7 @@ the targeted device. Objects of any ``descriptor`` class **must** be committed prior to using them in any call to ``compute_forward`` or ``compute_backward`` (which trigger actual DFT calculations). -As specified :ref:`above`, all required +As specified :ref:`above`, all required configuration parameters must be set before this function is called. Any change in configuration operated on a ``descriptor`` object via a call to its ``set_value`` member function *after* it was committed results in an undefined @@ -816,7 +816,7 @@ called again. .. code-block:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { template void descriptor::commit(sycl::queue& queue); @@ -835,22 +835,22 @@ called again. .. rubric:: Throws The ``commit`` member function shall throw the following - :ref:`exceptions` if the associated condition is + :ref:`exceptions` if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here (if the ``descriptor`` object's configuration was found to be inconsistent, for instance): - ``oneapi::mkl::invalid_argument()`` + ``oneapi::math::invalid_argument()`` If ``queue`` is found to be invalid in any way. - ``oneapi::mkl::host_bad_alloc()`` + ``oneapi::math::host_bad_alloc()`` If any host side only memory allocations fail, for instance due to lack of memory. - ``oneapi::mkl::device_bad_alloc()`` + ``oneapi::math::device_bad_alloc()`` If any device or shared memory allocation fail. -**Descriptor class member table:** :ref:`onemkl_dft_descriptor_member_table` +**Descriptor class member table:** :ref:`onemath_dft_descriptor_member_table` -**Parent topic:** :ref:`onemkl_dft` +**Parent topic:** :ref:`onemath_dft` diff --git a/source/elements/oneMKL/source/domains/dft/dft.rst b/source/elements/oneMath/source/domains/dft/dft.rst similarity index 82% rename from source/elements/oneMKL/source/domains/dft/dft.rst rename to source/elements/oneMath/source/domains/dft/dft.rst index 7268c7cf76..31a8591420 100644 --- a/source/elements/oneMKL/source/domains/dft/dft.rst +++ b/source/elements/oneMath/source/domains/dft/dft.rst @@ -2,15 +2,15 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_dft: +.. _onemath_dft: Discrete Fourier Transform Functions ------------------------------------ -oneMKL provides a DPC++ interface to :math:`d`-dimensional :math:`\left(d \in +oneMath provides a DPC++ interface to :math:`d`-dimensional :math:`\left(d \in \mathbb{Z}_{>0}\right)` Discrete Fourier Transforms (DFTs). -.. _onemkl_dft_definitions: +.. _onemath_dft_definitions: Definitions +++++++++++ @@ -29,7 +29,7 @@ For every :math:`m \in \lbrace 0, 1, \ldots, M - 1 \rbrace`, the DFT of sequence :math:`w^{m}` is the :math:`d`-dimensional discrete sequence :math:`z^{m}` of length(s) :math:`n_1 \times n_2 \times \dots \times n_d` whose entries are defined as -.. _onemkl_dft_formula: +.. _onemath_dft_formula: .. math:: z^{m}_{k_1, k_2,\ldots, k_d} = \sigma_{\delta} \displaystyle\sum_{j_d=0}^{n_d-1}\dots\displaystyle\sum_{j_2=0}^{n_2-1}\displaystyle\sum_{j_1=0}^{n_1-1} w^{m}_{j_1, j_2,\dots,j_d} \exp \left[ \delta 2\pi \imath \left( \sum_{\ell=1}^{d} \frac{j_{\ell}k_{\ell}}{n_{\ell}} \right) \right], @@ -45,7 +45,7 @@ backward) DFT is referred to as "forward domain". Conversely, the domain of output (resp. input) discrete sequences for forward (resp. backward) DFT is referred to as "backward domain". -oneMKL supports single-precision (fp32) and double-precision (fp64) +oneMath supports single-precision (fp32) and double-precision (fp64) floating-point arithmetic for the calculation of DFTs, using two kinds of forward domains: @@ -62,7 +62,7 @@ The calculation of the same DFT for several, *i.e.*, :math:`M > 1`, data sets of the same kind of forward domain, using the same precision is referred to as a "batched DFT". -.. _onemkl_dft_elementary_range_of_indices: +.. _onemath_dft_elementary_range_of_indices: Elementary range of indices +++++++++++++++++++++++++++ @@ -82,12 +82,12 @@ and :math:`\lambda^{*}` represents the conjugate of complex number redundant in backward domain: in case of real DFTs, the data sequences in backward domain can be fully determined even if one of the :math:`d` indices :math:`k_{\ell}` is limited to the range -:math:`0\leq k_{\ell} \leq \lfloor \frac{n_{\ell}}{2}\rfloor`. In oneMKL, the +:math:`0\leq k_{\ell} \leq \lfloor \frac{n_{\ell}}{2}\rfloor`. In oneMath, the index :math:`k_d`, *i.e.*, the last dimension's index, is restricted as such to capture an elementary set of non-redundant entries for data sequences belonging to the backward domain of real DFTs. -In other words, oneMKL expects and produces a set of :math:`M` +In other words, oneMath expects and produces a set of :math:`M` :math:`d`-dimensional data sequences :math:`\left(\cdot \right)^{m}_{k_1, k_2,\ldots, k_d}` with integer indices :math:`m` and @@ -99,7 +99,7 @@ elementary range - :math:`0 \leq k_d < n_d`, except for backward domain's data sequences of real DFTs; - :math:`0 \leq k_d \leq \lfloor\frac{n_d}{2}\rfloor`, for backward domain's data sequences of real DFTs. -.. _onemkl_dft_additional_constraints_in_bwd_domain_for_real_dft: +.. _onemath_dft_additional_constraints_in_bwd_domain_for_real_dft: Additional constraints for data in backward domain of real DFTs ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -121,42 +121,42 @@ DFTs. Specifically, for any of the :math:`M` sequences, that this case falls back to the above constraint if :math:`n_1 = 2`). .. note:: - The behavior of oneMKL is undefined for real backward DFT if the input data - does not satisfy those constraints. oneMKL considers it the user's + The behavior of oneMath is undefined for real backward DFT if the input data + does not satisfy those constraints. oneMath considers it the user's responsibility to guarantee that these constraints are satisfied by the input data for real backward DFTs. -.. _onemkl_dft_recommended_usage: +.. _onemath_dft_recommended_usage: Recommended usage +++++++++++++++++ The desired DFT to be computed is entirely defined by an object ``desc`` of a -specialization of the ``oneapi::mkl::dft::descriptor`` -:ref:`class template`. +specialization of the ``oneapi::math::dft::descriptor`` +:ref:`class template`. The desired floating-point format and kind of forward domain are determined by ``desc``'s particular class, *i.e.*, by the specialization values of the -:ref:`template parameters` ``prec`` +:ref:`template parameters` ``prec`` and ``dom`` of the ``descriptor`` class template, respectively. Once ``desc`` is created, the length(s) :math:`\lbrace n_1, n_2, \ldots, n_d\rbrace` (and the dimension :math:`d`) cannot be changed, as they are read-only parameters. Other configuration details for the DFT under consideration may be specified by invoking the appropriate -:ref:`configuration-setting member function(s)` +:ref:`configuration-setting member function(s)` of ``desc`` for every relevant configuration parameter (*e.g.*, the number :math:`M` of sequences to consider in case of a batched DFT). Once configured as desired, ``desc`` must be initialized for computation by using its -:ref:`committing member function`, which requires +:ref:`committing member function`, which requires a ``sycl::queue`` object. The successful completion of that operation makes ``desc`` ready to compute the desired DFT *as configured*, for the particular device and context encapsulated by the latter. ``desc`` may then be used with user-provided, device-accessible data, in a -``oneapi::mkl::dft::compute_forward`` (resp. -``oneapi::mkl::dft::compute_backward``) function to enqueue operations relevant +``oneapi::math::dft::compute_forward`` (resp. +``oneapi::math::dft::compute_backward``) function to enqueue operations relevant to the desired forward (resp. backward) DFT calculations. .. note:: - Objects of any ``oneapi::mkl::dft::descriptor`` class + Objects of any ``oneapi::math::dft::descriptor`` class - must be successfully committed prior to providing them to any compute function; @@ -164,17 +164,17 @@ to the desired forward (resp. backward) DFT calculations. after they were already successfully committed; - deliver best performance for DFT calculations when created, configured and committed outside applications' hotpath(s) that use them multiple times for - identically-configured DFTs. ``oneapi::mkl::dft::compute_forward`` and/or - ``oneapi::mkl::dft::compute_backward`` should be the only oneMKL DFT-related + identically-configured DFTs. ``oneapi::math::dft::compute_forward`` and/or + ``oneapi::math::dft::compute_backward`` should be the only oneMath DFT-related routines invoked in programs' hotpaths. Summary table ~~~~~~~~~~~~~ -The table below summarizes the identifiers of the ``oneapi::mkl::dft`` namespace +The table below summarizes the identifiers of the ``oneapi::math::dft`` namespace relevant to computing DFTs. -.. _onemkl_dft_summary_table: +.. _onemath_dft_summary_table: .. container:: @@ -186,50 +186,50 @@ relevant to computing DFTs. :header-rows: 1 :widths: 33 64 - * - Identifier in ``oneapi::mkl::dft`` + * - Identifier in ``oneapi::math::dft`` - Description * - ``descriptor`` - A template for classes whose instances define a specific DFT to be calculated and its configuration. Template parameters are omitted in this table for conciseness (more details are available in the page dedicated to - :ref:`the descriptor class template`). + :ref:`the descriptor class template`). * - ``domain``, ``precision``, ``config_param`` and ``config_value`` - - :ref:`Scoped enumerations` pertaining to the + - :ref:`Scoped enumerations` pertaining to the definition of any configuration parameter or its associated value, for any instance of a ``descriptor`` class. * - ``descriptor::set_value`` - Member functions to - :ref:`set (writable) configuration parameters` + :ref:`set (writable) configuration parameters` for any instance of a ``descriptor`` class. * - ``descriptor::get_value`` - Member functions to - :ref:`query configuration parameters` + :ref:`query configuration parameters` from any instance of a ``descriptor`` class. * - ``descriptor::commit`` - A member function to - :ref:`commit` any instance + :ref:`commit` any instance of a ``descriptor`` class to the DFT calculations it defines, on a given queue. * - ``descriptor::set_workspace`` - A member function to equip any instance of a ``descriptor`` class with an - :ref:`externally-allocated workspace`. + :ref:`externally-allocated workspace`. * - ``compute_forward`` - Function templates for computing a forward DFT, as defined by a (successfully-committed) instance of a ``descriptor`` class (required argument). Template parameters are omitted in this table for conciseness (more details are available in the - :ref:`dedicated page`). + :ref:`dedicated page`). * - ``compute_backward`` - Function templates for computing a backward DFT, as defined by a (successfully-committed) instance of a ``descriptor`` class (required argument). Template parameters are omitted in this table for conciseness (more details are available in the - :ref:`dedicated page`). + :ref:`dedicated page`). -**Parent topic:** :ref:`onemkl_domains` +**Parent topic:** :ref:`onemath_domains` .. toctree:: :hidden: diff --git a/source/elements/oneMKL/source/domains/dft/enums_and_config_params.rst b/source/elements/oneMath/source/domains/dft/enums_and_config_params.rst similarity index 81% rename from source/elements/oneMKL/source/domains/dft/enums_and_config_params.rst rename to source/elements/oneMath/source/domains/dft/enums_and_config_params.rst index 6c86a0e9b8..7554aa27b9 100644 --- a/source/elements/oneMKL/source/domains/dft/enums_and_config_params.rst +++ b/source/elements/oneMath/source/domains/dft/enums_and_config_params.rst @@ -2,15 +2,15 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_dft_enums: +.. _onemath_dft_enums: DFT-related scoped enumeration types ------------------------------------ -The following scoped enumeration types, defined in the ``oneapi::mkl::dft`` +The following scoped enumeration types, defined in the ``oneapi::math::dft`` namespace, are used for constructing and configuring ``descriptor`` objects consistently with the DFT(s) they are meant to define. The usage of prepended -namespace specifiers ``oneapi::mkl::dft`` is omitted below for conciseness. +namespace specifiers ``oneapi::math::dft`` is omitted below for conciseness. .. list-table:: :header-rows: 1 @@ -22,25 +22,25 @@ namespace specifiers ``oneapi::mkl::dft`` is omitted below for conciseness. - Type for the floating-point format to be used in the desired DFT calculations (for arithmetic operations and data representation). A template parameter ``prec`` of this type is used for the - ``descriptor`` :ref:`class template`. + ``descriptor`` :ref:`class template`. * - ``domain`` - Type for the kind of forward domain for the desired DFT calculations. A template parameter ``dom`` of this type is used for the - ``descriptor`` :ref:`class template`. + ``descriptor`` :ref:`class template`. * - ``config_param`` - Type for configuration parameters of ``descriptor`` objects. * - ``config_value`` - Type for non-numeric configuration values corresponding to some of - the :ref:`configuration parameters`. + the :ref:`configuration parameters`. -.. _onemkl_dft_enum_precision: +.. _onemath_dft_enum_precision: ``precision`` +++++++++++++ Values in this scoped enumeration type represent the floating-point format to be used for the desired DFT(s). The same format is to be used for the user-provided -data, the computation being carried out by oneMKL and the delivered results. +data, the computation being carried out by oneMath and the delivered results. .. container:: section @@ -48,7 +48,7 @@ data, the computation being carried out by oneMKL and the delivered results. .. code:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { enum class precision { SINGLE, DOUBLE @@ -68,13 +68,13 @@ data, the computation being carried out by oneMKL and the delivered results. - Double-precision floating-point format (FP64) is used for data representation and arithmetic operations. -.. _onemkl_dft_enum_domain: +.. _onemath_dft_enum_domain: ``domain`` ++++++++++ Values in this scoped enumeration type represent the kind of forward domain for -the desired DFT(s). As explained in the :ref:`introduction`, +the desired DFT(s). As explained in the :ref:`introduction`, the backward domain type is always complex. .. container:: section @@ -83,7 +83,7 @@ the backward domain type is always complex. .. code:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { enum class domain { REAL, COMPLEX @@ -102,7 +102,7 @@ the backward domain type is always complex. - The forward domain is the set of complex :math:`d`-dimensional sequences. -.. _onemkl_dft_enum_config_param: +.. _onemath_dft_enum_config_param: ``config_param`` ++++++++++++++++ @@ -114,7 +114,7 @@ Values in this scoped enumeration type represent configuration parameters for .. code:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { enum class config_param { // read-only parameters: FORWARD_DOMAIN, @@ -164,7 +164,7 @@ Values in this scoped enumeration type represent configuration parameters for - Kind of forward domain for the DFT. This parameter is read-only. - | ``domain`` | [specialization value used for template parameter ``dom`` of the - ``descriptor`` :ref:`class template`] + ``descriptor`` :ref:`class template`] * - ``DIMENSION`` - Dimension :math:`d` of the DFT. This parameter is read-only. - | ``std::int64_t`` @@ -172,7 +172,7 @@ Values in this scoped enumeration type represent configuration parameters for * - ``LENGTHS`` - Lengths :math:`\lbrace n_1, \ldots, n_d\rbrace` of the DFT. This parameter is read-only and can only be set via the - :ref:`parameterized constructors`. + :ref:`parameterized constructors`. - | ``std::vector`` of size :math:`d` or, if :math:`d = 1`, ``std::int64_t`` | [``std::vector({n_1,...,n_d})``] * - ``PRECISION`` @@ -180,11 +180,11 @@ Values in this scoped enumeration type represent configuration parameters for parameter is read-only. - | ``precision`` | [specialization value used for template parameter ``prec`` of the - ``descriptor`` :ref:`class template`] + ``descriptor`` :ref:`class template`] * - ``COMMIT_STATUS`` - Status flag indicating whether the object is ready for computations after a successful call to its ``commit`` - :ref:`member function`. This parameter + :ref:`member function`. This parameter is read-only. - | ``config_value`` (possible values are ``config_value::COMMITTED`` or ``config_value::UNCOMMITTED``). | [``config_value::UNCOMMITTED``] @@ -202,7 +202,7 @@ Values in this scoped enumeration type represent configuration parameters for - | ``std::int64_t`` | [:math:`1`] * - ``COMPLEX_STORAGE`` - - :ref:`Data storage` type used (relevant + - :ref:`Data storage` type used (relevant for complex descriptors only). - | ``config_value`` (possible values are ``config_value::COMPLEX_COMPLEX`` or ``config_value::REAL_REAL``) | [``config_value::COMPLEX_COMPLEX``] @@ -212,82 +212,82 @@ Values in this scoped enumeration type represent configuration parameters for - | ``config_value`` (possible values are ``config_value::INPLACE`` or ``config_value::NOT_INPLACE``) | [``config_value::INPLACE``] * - ``FWD_STRIDES`` - - Offset and strides :ref:`defining the layout` + - Offset and strides :ref:`defining the layout` within a given data sequence in the forward domain. - | ``std::vector`` of size :math:`(d+1)` - | [see the :ref:`dedicated section`] + | [see the :ref:`dedicated section`] * - ``BWD_STRIDES`` - - Offset and strides :ref:`defining the layout` + - Offset and strides :ref:`defining the layout` within a given data sequence in the backward domain. - | ``std::vector`` of size :math:`(d+1)` - | [see the :ref:`dedicated section`] + | [see the :ref:`dedicated section`] * - ``INPUT_STRIDES`` (deprecated) - - Offset and strides :ref:`defining the layout` + - Offset and strides :ref:`defining the layout` within a given *input* data sequence. - | ``std::vector`` of size :math:`(d+1)` | [``std::vector(d+1, 0)``] * - ``OUTPUT_STRIDES`` (deprecated) - - Offset and strides :ref:`defining the layout` + - Offset and strides :ref:`defining the layout` within a given *output* data sequence. - | ``std::vector`` of size :math:`(d+1)` | [``std::vector(d+1, 0)``] * - ``FWD_DISTANCE`` - - :ref:`Distance` in + - :ref:`Distance` in number of elements of - :ref:`implicitly-assumed data type` + :ref:`implicitly-assumed data type` between forward-domain entries :math:`\left(\cdot\right)^{m}_{k_1, k_2, \ldots, k_d}` and :math:`\left(\cdot\right)^{m + 1}_{k_1, k_2, \ldots, k_d}` for all :math:`0\leq m < M - 1` and :math:`\left(k_1, k_2, \ldots, k_d\right)` in - :ref:`valid range`. This is + :ref:`valid range`. This is relevant (and *must* be set) for batched DFT(s), *i.e.*, if :math:`M > 1`. - | ``std::int64_t`` | [:math:`0`] * - ``BWD_DISTANCE`` - - :ref:`Distance` in + - :ref:`Distance` in number of elements of - :ref:`implicitly-assumed data type` + :ref:`implicitly-assumed data type` between backward-domain entries :math:`\left(\cdot\right)^{m}_{k_1, k_2, \ldots, k_d}` and :math:`\left(\cdot\right)^{m + 1}_{k_1, k_2, \ldots, k_d}` for all :math:`0\leq m < M - 1` and :math:`\left(k_1, k_2, \ldots, k_d\right)` in - :ref:`valid range`. This is + :ref:`valid range`. This is relevant (and *must* be set) for batched DFT(s), *i.e.*, if :math:`M > 1`. - | ``std::int64_t`` | [:math:`0`] * - ``WORKSPACE_PLACEMENT`` - Some FFT algorithm computation steps require a - :ref:`scratch space` for + :ref:`scratch space` for permutations or other purposes. This parameter controls whether this scratch space is automatically allocated or provided by the user. - | ``config_value`` (possible values are ``config_value::WORKSPACE_AUTOMATIC`` or ``config_value::WORKSPACE_EXTERNAL``). | [``config_value::WORKSPACE_AUTOMATIC``] * - ``WORKSPACE_EXTERNAL_BYTES`` - The required minimum external workspace size for use by the - ``set_workspace`` :ref:`member function`. + ``set_workspace`` :ref:`member function`. This parameter is read-only and can be queried only if the ``descriptor`` object is committed. - | ``std::int64_t`` | [N/A] -.. _onemkl_dft_enum_config_value: +.. _onemath_dft_enum_config_value: ``config_value`` ++++++++++++++++ Values in this scoped enumeration type represent possible non-numeric configuration values associated with some -:ref:`configuration parameters`. +:ref:`configuration parameters`. .. container:: section .. code:: cpp - namespace oneapi::mkl::dft { + namespace oneapi::math::dft { enum class config_value { // for config_param::COMMIT_STATUS COMMITTED, @@ -327,7 +327,7 @@ configuration values associated with some and imaginary parts of complex entries are stored separately (``config_value::REAL_REAL``) or not (``config_value::COMPLEX_COMPLEX``). More details are available in the page dedicated to - :ref:`data storage`. + :ref:`data storage`. * - | ``INPLACE`` | ``NOT_INPLACE`` - Possible configuration values associated with the configuration @@ -339,9 +339,9 @@ configuration values associated with some - Possible configuration values associated with the configuration parameter ``config_param::WORKSPACE_PLACEMENT``. More details are available in the page dedicated to - :ref:`workspace placement`. + :ref:`workspace placement`. -**Parent topic:** :ref:`onemkl_dft` +**Parent topic:** :ref:`onemath_dft` .. toctree:: :hidden: diff --git a/source/elements/oneMKL/source/domains/discrete_fourier_transforms.inc.rst b/source/elements/oneMath/source/domains/discrete_fourier_transforms.inc.rst similarity index 60% rename from source/elements/oneMKL/source/domains/discrete_fourier_transforms.inc.rst rename to source/elements/oneMath/source/domains/discrete_fourier_transforms.inc.rst index 7bb406723d..bde4870a58 100644 --- a/source/elements/oneMKL/source/domains/discrete_fourier_transforms.inc.rst +++ b/source/elements/oneMath/source/domains/discrete_fourier_transforms.inc.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_discrete_fourier_transforms: +.. _onemath_discrete_fourier_transforms: Discrete Fourier Transforms ---------------------------------- -The :ref:`onemkl_dft` offer several options for computing Discrete Fourier Transforms (DFTs). +The :ref:`onemath_dft` offer several options for computing Discrete Fourier Transforms (DFTs). .. toctree:: :hidden: diff --git a/source/elements/oneMKL/source/domains/domains.rst b/source/elements/oneMath/source/domains/domains.rst similarity index 91% rename from source/elements/oneMKL/source/domains/domains.rst rename to source/elements/oneMath/source/domains/domains.rst index a243598ae9..741761db8a 100644 --- a/source/elements/oneMKL/source/domains/domains.rst +++ b/source/elements/oneMath/source/domains/domains.rst @@ -2,9 +2,9 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_domains: +.. _onemath_domains: -oneMKL Domains +oneMath Domains ================ This section describes the Data Parallel C++ (DPC++) interface. diff --git a/source/elements/oneMKL/source/domains/equations/error_functions_plot.jpg b/source/elements/oneMath/source/domains/equations/error_functions_plot.jpg similarity index 100% rename from source/elements/oneMKL/source/domains/equations/error_functions_plot.jpg rename to source/elements/oneMath/source/domains/equations/error_functions_plot.jpg diff --git a/source/elements/oneMKL/source/domains/equations/inverse_error_functions_plot.jpg b/source/elements/oneMath/source/domains/equations/inverse_error_functions_plot.jpg similarity index 100% rename from source/elements/oneMKL/source/domains/equations/inverse_error_functions_plot.jpg rename to source/elements/oneMath/source/domains/equations/inverse_error_functions_plot.jpg diff --git a/source/elements/oneMKL/source/domains/equations/rng-leapfrog.png b/source/elements/oneMath/source/domains/equations/rng-leapfrog.png similarity index 100% rename from source/elements/oneMKL/source/domains/equations/rng-leapfrog.png rename to source/elements/oneMath/source/domains/equations/rng-leapfrog.png diff --git a/source/elements/oneMKL/source/domains/equations/rng-skip-ahead.png b/source/elements/oneMath/source/domains/equations/rng-skip-ahead.png similarity index 100% rename from source/elements/oneMKL/source/domains/equations/rng-skip-ahead.png rename to source/elements/oneMath/source/domains/equations/rng-skip-ahead.png diff --git a/source/elements/oneMKL/source/domains/lapack/gebrd.rst b/source/elements/oneMath/source/domains/lapack/gebrd.rst similarity index 87% rename from source/elements/oneMKL/source/domains/lapack/gebrd.rst rename to source/elements/oneMath/source/domains/lapack/gebrd.rst index 7ff12129c1..90d723d4cb 100644 --- a/source/elements/oneMKL/source/domains/lapack/gebrd.rst +++ b/source/elements/oneMath/source/domains/lapack/gebrd.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_gebrd: +.. _onemath_lapack_gebrd: gebrd ===== @@ -52,12 +52,12 @@ representation: If the matrix :math:`A` is real, - to compute :math:`Q` and :math:`P` explicitly, call - :ref:`onemkl_lapack_orgbr`. + :ref:`onemath_lapack_orgbr`. If the matrix :math:`A` is complex, - to compute :math:`Q` and :math:`P` explicitly, call - :ref:`onemkl_lapack_ungbr` + :ref:`onemath_lapack_ungbr` gebrd (Buffer Version) ---------------------- @@ -68,7 +68,7 @@ gebrd (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { void gebrd(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &d, cl::sycl::buffer &e, cl::sycl::buffer &tauq, cl::sycl::buffer &taup, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } @@ -95,7 +95,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_gebrd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_gebrd_scratchpad_size` function. .. container:: section @@ -144,17 +144,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -171,7 +171,7 @@ gebrd (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event gebrd(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, T *a, std::int64_t lda, RealT *d, RealT *e, T *tauq, T *taup, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } @@ -197,7 +197,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type T. - Size should not be less than the value returned by :ref:`onemkl_lapack_gebrd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_gebrd_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -249,17 +249,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -273,6 +273,6 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/gebrd_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/gebrd_scratchpad_size.rst similarity index 67% rename from source/elements/oneMKL/source/domains/lapack/gebrd_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/gebrd_scratchpad_size.rst index 264e76cbb1..9c1cc18ac1 100644 --- a/source/elements/oneMKL/source/domains/lapack/gebrd_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/gebrd_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_gebrd_scratchpad_size: +.. _onemath_lapack_gebrd_scratchpad_size: gebrd_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_gebrd` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_gebrd` function. .. rubric:: Description @@ -22,14 +22,14 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_gebrd` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_gebrd` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_gebrd` function should be able to hold. Calls to this routine must specify the template parameter explicitly. .. rubric:: Syntax .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t gebrd_scratchpad_size(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t lda) } @@ -39,7 +39,7 @@ Calls to this routine must specify the template parameter explicitly. .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_gebrd` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_gebrd` function will be performed. m The number of rows in the matrix :math:`A` (:math:`0 \le m`). @@ -56,11 +56,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -69,8 +69,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_gebrd` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_gebrd` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/geqrf.rst b/source/elements/oneMath/source/domains/lapack/geqrf.rst similarity index 82% rename from source/elements/oneMKL/source/domains/lapack/geqrf.rst rename to source/elements/oneMath/source/domains/lapack/geqrf.rst index f9c436ce31..18f2772f90 100644 --- a/source/elements/oneMKL/source/domains/lapack/geqrf.rst +++ b/source/elements/oneMath/source/domains/lapack/geqrf.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_geqrf: +.. _onemath_lapack_geqrf: geqrf ===== @@ -37,7 +37,7 @@ geqrf (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { void geqrf(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } @@ -63,7 +63,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_geqrf_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_geqrf_scratchpad_size` function. .. container:: section @@ -92,17 +92,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -117,7 +117,7 @@ geqrf (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event geqrf(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, T *a, std::int64_t lda, T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } @@ -143,7 +143,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_geqrf_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_geqrf_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -176,17 +176,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -200,6 +200,6 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/geqrf_batch.rst b/source/elements/oneMath/source/domains/lapack/geqrf_batch.rst similarity index 88% rename from source/elements/oneMKL/source/domains/lapack/geqrf_batch.rst rename to source/elements/oneMath/source/domains/lapack/geqrf_batch.rst index 7c5ffb2112..7a140918d7 100644 --- a/source/elements/oneMKL/source/domains/lapack/geqrf_batch.rst +++ b/source/elements/oneMath/source/domains/lapack/geqrf_batch.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_geqrf_batch: +.. _onemath_lapack_geqrf_batch: geqrf_batch =========== @@ -24,7 +24,7 @@ Computes the QR factorizations of a batch of general matrices. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_lapack_geqrf_batch_buffer: +.. _onemath_lapack_geqrf_batch_buffer: geqrf_batch (Buffer Version) ---------------------------- @@ -43,7 +43,7 @@ The buffer version of ``geqrf_batch`` supports only the strided API. .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { void geqrf_batch(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, std::int64_t stride_a, cl::sycl::buffer &tau, std::int64_t stride_tau, std::int64_t batch_size, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } @@ -79,7 +79,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as the number of floating point elements of type ``T``. Size should not be less than the value returned by the Strided API of the :ref:`onemkl_lapack_geqrf_batch_scratchpad_size` function. + Size of scratchpad memory as the number of floating point elements of type ``T``. Size should not be less than the value returned by the Strided API of the :ref:`onemath_lapack_geqrf_batch_scratchpad_size` function. .. container:: section @@ -97,13 +97,13 @@ tau This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -113,7 +113,7 @@ This routine shall throw the following exceptions if the associated condition is If ``info`` is not zero and `detail()` returns zero, then there were some errors for some of the problems in the supplied batch and ``info`` code contains the number of failed calculations in a batch. -.. _onemkl_lapack_geqrf_batch_usm: +.. _onemath_lapack_geqrf_batch_usm: geqrf_batch (USM Version) ------------------------- @@ -137,7 +137,7 @@ The total number of problems to solve, ``batch_size``, is a sum of sizes of all .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event geqrf_batch(cl::sycl::queue &queue, std::int64_t *m, std::int64_t *n, T **a, std::int64_t *lda, T **tau, std::int64_t group_count, std::int64_t *group_sizes, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } @@ -171,7 +171,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as the number of floating point elements of type ``T``. Size should not be less than the value returned by the Group API of the :ref:`onemkl_lapack_geqrf_batch_scratchpad_size` function. + Size of scratchpad memory as the number of floating point elements of type ``T``. Size should not be less than the value returned by the Group API of the :ref:`onemath_lapack_geqrf_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -198,13 +198,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -225,7 +225,7 @@ The routine does not form the matrices :math:`Q_i` explicitly. Instead, :math:`Q .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { sycl::event geqrf_batch(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, T *a, std::int64_t lda, std::int64_t stride_a, T *tau, std::int64_t stride_tau, std::int64_t batch_size, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } @@ -261,7 +261,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as the number of floating point elements of type ``T``. Size should not be less than the value returned by the Strided API of the :ref:`onemkl_lapack_geqrf_batch_scratchpad_size` function. + Size of scratchpad memory as the number of floating point elements of type ``T``. Size should not be less than the value returned by the Strided API of the :ref:`onemath_lapack_geqrf_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -288,13 +288,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -304,4 +304,4 @@ This routine shall throw the following exceptions if the associated condition is If ``info`` is not zero and `detail()` returns zero, then there were some errors for some of the problems in the supplied batch and ``info`` code contains the number of failed calculations in a batch. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/geqrf_batch_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/geqrf_batch_scratchpad_size.rst similarity index 78% rename from source/elements/oneMKL/source/domains/lapack/geqrf_batch_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/geqrf_batch_scratchpad_size.rst index beae625251..8cf5d36563 100644 --- a/source/elements/oneMKL/source/domains/lapack/geqrf_batch_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/geqrf_batch_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_geqrf_batch_scratchpad_size: +.. _onemath_lapack_geqrf_batch_scratchpad_size: geqrf_batch_scratchpad_size =========================== -Computes size of scratchpad memory required for the :ref:`onemkl_lapack_geqrf_batch` function. +Computes size of scratchpad memory required for the :ref:`onemath_lapack_geqrf_batch` function. .. rubric:: Description @@ -24,13 +24,13 @@ Computes size of scratchpad memory required for the :ref:`onemkl_lapack_geqrf_ba **Group API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_geqrf_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_geqrf_batch` function. .. rubric:: Syntax .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t geqrf_batch_scratchpad_size(cl::sycl::queue &queue, std::int64_t *m, std::int64_t *n, std::int64_t *lda, std::int64_t group_count, std::int64_t *group_sizes) } @@ -62,7 +62,7 @@ group_sizes .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_geqrf_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_geqrf_batch` function. .. container:: section @@ -70,24 +70,24 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. **Strided API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_geqrf_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_geqrf_batch` function. .. rubric:: Syntax .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t geqrf_batch_scratchpad_size(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t lda, std::int64_t stride_a, std::int64_t stride_tau, std::int64_t batch_size) }; @@ -121,7 +121,7 @@ batch_size .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_geqrf_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_geqrf_batch` function. .. container:: section @@ -129,13 +129,13 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/geqrf_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/geqrf_scratchpad_size.rst similarity index 68% rename from source/elements/oneMKL/source/domains/lapack/geqrf_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/geqrf_scratchpad_size.rst index 882fd2419b..5473128843 100644 --- a/source/elements/oneMKL/source/domains/lapack/geqrf_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/geqrf_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_geqrf_scratchpad_size: +.. _onemath_lapack_geqrf_scratchpad_size: geqrf_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_geqrf` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_geqrf` function. .. container:: section @@ -24,7 +24,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_geqrf` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_geqrf` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_geqrf` function should be able to hold. Calls to this routine must specify the template parameter explicitly. .. container:: section @@ -33,7 +33,7 @@ Calls to this routine must specify the template parameter explicitly. .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t geqrf_scratchpad_size(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t lda) } @@ -43,7 +43,7 @@ Calls to this routine must specify the template parameter explicitly. .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_geqrf` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_geqrf` function will be performed. m The number of rows in the matrix :math:`A` (:math:`0 \le m`). @@ -60,11 +60,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -73,7 +73,7 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_geqrf` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_geqrf` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/gerqf.rst b/source/elements/oneMath/source/domains/lapack/gerqf.rst similarity index 83% rename from source/elements/oneMKL/source/domains/lapack/gerqf.rst rename to source/elements/oneMath/source/domains/lapack/gerqf.rst index ff13d24462..f4712a84ac 100644 --- a/source/elements/oneMKL/source/domains/lapack/gerqf.rst +++ b/source/elements/oneMath/source/domains/lapack/gerqf.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_gerqf: +.. _onemath_lapack_gerqf: gerqf ===== @@ -36,7 +36,7 @@ gerqf (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { void gerqf(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } @@ -63,7 +63,7 @@ scratchpad Buffer holding scratchpad memory to be used by the routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the :ref:`onemkl_lapack_gerqf_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the :ref:`onemath_lapack_gerqf_scratchpad_size` function. .. container:: section @@ -87,17 +87,17 @@ tau This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -114,7 +114,7 @@ gerqf (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event gerqf(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, T *a, std::int64_t lda, T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } @@ -141,7 +141,7 @@ scratchpad Buffer holding scratchpad memory to be used by the routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the :ref:`onemkl_lapack_gerqf_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the :ref:`onemath_lapack_gerqf_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -168,17 +168,17 @@ tau This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -192,5 +192,5 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/gerqf_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/gerqf_scratchpad_size.rst similarity index 74% rename from source/elements/oneMKL/source/domains/lapack/gerqf_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/gerqf_scratchpad_size.rst index 7970047d65..276bf686b2 100644 --- a/source/elements/oneMKL/source/domains/lapack/gerqf_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/gerqf_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_gerqf_scratchpad_size: +.. _onemath_lapack_gerqf_scratchpad_size: gerqf_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_gerqf` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_gerqf` function. .. container:: section @@ -24,7 +24,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_gerqf` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_gerqf` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_gerqf` function should be able to hold. Calls to this routine must specify the template parameter explicitly. @@ -37,7 +37,7 @@ gerqf_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t gerqf_scratchpad_size(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t lda) } @@ -64,11 +64,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -77,7 +77,7 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_gerqf` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_gerqf` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/gesvd.rst b/source/elements/oneMath/source/domains/lapack/gesvd.rst similarity index 87% rename from source/elements/oneMKL/source/domains/lapack/gesvd.rst rename to source/elements/oneMath/source/domains/lapack/gesvd.rst index c314fd3087..bbf7451c58 100644 --- a/source/elements/oneMKL/source/domains/lapack/gesvd.rst +++ b/source/elements/oneMath/source/domains/lapack/gesvd.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_gesvd: +.. _onemath_lapack_gesvd: gesvd ===== @@ -24,7 +24,7 @@ Computes the singular value decomposition of a general rectangular matrix. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_lapack_gesvd_batch_buffer: +.. _onemath_lapack_gesvd_batch_buffer: gesvd (Buffer Version) ---------------------- @@ -54,8 +54,8 @@ are returned in descending order. The first :math:`\min(m, n)` columns of .. code-block:: cpp - namespace oneapi::mkl::lapack { - void gesvd(cl::sycl::queue &queue, oneapi::mkl::job jobu, oneapi::mkl::job jobvt, std::int64_t m, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &s, cl::sycl::buffer &u, std::int64_t ldu, cl::sycl::buffer &vt, std::int64_t ldvt, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void gesvd(cl::sycl::queue &queue, oneapi::math::job jobu, oneapi::math::job jobvt, std::int64_t m, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &s, cl::sycl::buffer &u, std::int64_t ldu, cl::sycl::buffer &vt, std::int64_t ldvt, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -123,7 +123,7 @@ ldvt scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_gesvd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_gesvd_scratchpad_size` function. .. container:: section @@ -185,17 +185,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -239,8 +239,8 @@ are returned in descending order. The first :math:`\min(m, n)` columns of .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event gesvd(cl::sycl::queue &queue, oneapi::mkl::job jobu, oneapi::mkl::job jobvt, std::int64_t m, std::int64_t n, T *a, std::int64_t lda, RealT *s, T *u, std::int64_t ldu, T *vt, std::int64_t ldvt, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event gesvd(cl::sycl::queue &queue, oneapi::math::job jobu, oneapi::math::job jobvt, std::int64_t m, std::int64_t n, T *a, std::int64_t lda, RealT *s, T *u, std::int64_t ldu, T *vt, std::int64_t ldvt, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -308,7 +308,7 @@ ldvt scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_gesvd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_gesvd_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -373,17 +373,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -405,4 +405,4 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/gesvd_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/gesvd_scratchpad_size.rst similarity index 78% rename from source/elements/oneMKL/source/domains/lapack/gesvd_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/gesvd_scratchpad_size.rst index 275a448fa3..1bb1f16cb0 100644 --- a/source/elements/oneMKL/source/domains/lapack/gesvd_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/gesvd_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_gesvd_scratchpad_size: +.. _onemath_lapack_gesvd_scratchpad_size: gesvd_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_gesvd` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_gesvd` function. .. container:: section @@ -24,7 +24,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_gesvd` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_gesvd` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_gesvd` function should be able to hold. Calls to this routine must specify the template parameter explicitly. gesvd_scratchpad_size @@ -36,9 +36,9 @@ gesvd_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t gesvd_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::job jobu, oneapi::mkl::job jobvt, std::int64_t m, std::int64_t n, std::int64_t lda, std::int64_t ldu, std::int64_t ldvt) + std::int64_t gesvd_scratchpad_size(cl::sycl::queue &queue, oneapi::math::job jobu, oneapi::math::job jobvt, std::int64_t m, std::int64_t n, std::int64_t lda, std::int64_t ldu, std::int64_t ldvt) } .. container:: section @@ -46,7 +46,7 @@ gesvd_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_gesvd` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_gesvd` function will be performed. jobu Must be ``job::allvec``, ``job::somevec``, @@ -106,11 +106,11 @@ ldvt This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -119,8 +119,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_gesvd` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_gesvd` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/getrf.rst b/source/elements/oneMath/source/domains/lapack/getrf.rst similarity index 82% rename from source/elements/oneMKL/source/domains/lapack/getrf.rst rename to source/elements/oneMath/source/domains/lapack/getrf.rst index 7027641266..e4ae05ef2a 100644 --- a/source/elements/oneMKL/source/domains/lapack/getrf.rst +++ b/source/elements/oneMath/source/domains/lapack/getrf.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_getrf: +.. _onemath_lapack_getrf: getrf ===== @@ -41,7 +41,7 @@ getrf (BUFFER Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { void getrf(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &ipiv, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } @@ -66,7 +66,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_getrf_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_getrf_scratchpad_size` function. .. container:: section @@ -87,17 +87,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -116,7 +116,7 @@ getrf (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event getrf(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, T *a, std::int64_t lda, std::int64_t *ipiv, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } @@ -141,7 +141,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_getrf_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_getrf_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -165,17 +165,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -191,6 +191,6 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/getrf_batch.rst b/source/elements/oneMath/source/domains/lapack/getrf_batch.rst similarity index 88% rename from source/elements/oneMKL/source/domains/lapack/getrf_batch.rst rename to source/elements/oneMath/source/domains/lapack/getrf_batch.rst index 6dc2e2f9aa..c6e6879788 100644 --- a/source/elements/oneMKL/source/domains/lapack/getrf_batch.rst +++ b/source/elements/oneMath/source/domains/lapack/getrf_batch.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_getrf_batch: +.. _onemath_lapack_getrf_batch: getrf_batch =========== @@ -22,7 +22,7 @@ Computes the LU factorizations of a batch of general matrices. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_lapack_getrf_batch_buffer: +.. _onemath_lapack_getrf_batch_buffer: getrf_batch (Buffer Version) ---------------------------- @@ -39,7 +39,7 @@ The routine computes the LU factorizations of general :math:`m \times n` matrice .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { void getrf_batch(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, std::int64_t stride_a, cl::sycl::buffer &ipiv, std::int64_t stride_ipiv, std::int64_t batch_size, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } @@ -75,7 +75,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the Strided API of the :ref:`onemkl_lapack_getrf_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the Strided API of the :ref:`onemath_lapack_getrf_batch_scratchpad_size` function. .. container:: section @@ -93,13 +93,13 @@ ipiv This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -113,7 +113,7 @@ This routine shall throw the following exceptions if the associated condition is The indices of such matrices in the batch can be obtained with `ids()` method of the exception object. The indices of first zero diagonal elements in these :math:`U_i` matrices can be obtained by `exceptions()` method of exception object. -.. _onemkl_lapack_getrf_batch_usm: +.. _onemath_lapack_getrf_batch_usm: getrf_batch (USM Version) ------------------------- @@ -130,7 +130,7 @@ The routine computes the batch of LU factorizations of general :math:`m \times n .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event getrf_batch(cl::sycl::queue &queue, std::int64_t *m, std::int64_t *n, T **a, std::int64_t *lda, std::int64_t **ipiv, std::int64_t group_count, std::int64_t *group_sizes, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } @@ -163,7 +163,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Group API of the :ref:`onemkl_lapack_getrf_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Group API of the :ref:`onemath_lapack_getrf_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -190,13 +190,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -218,7 +218,7 @@ The routine computes the LU factorizations of general :math:`m \times n` matrice .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event getrf_batch(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, T *a, std::int64_t lda, std::int64_t stride_a, std::int64_t *ipiv, std::int64_t stride_ipiv, std::int64_t batch_size, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) }; @@ -254,7 +254,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemkl_lapack_getrf_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemath_lapack_getrf_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -281,13 +281,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -301,4 +301,4 @@ This routine shall throw the following exceptions if the associated condition is The indices of such matrices in the batch can be obtained with `ids()` method of the exception object. The indices of first zero diagonal elements in these :math:`U_i` matrices can be obtained by `exceptions()` method of exception object. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/getrf_batch_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/getrf_batch_scratchpad_size.rst similarity index 78% rename from source/elements/oneMKL/source/domains/lapack/getrf_batch_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/getrf_batch_scratchpad_size.rst index 0d422cda00..e79fe6198c 100644 --- a/source/elements/oneMKL/source/domains/lapack/getrf_batch_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/getrf_batch_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_getrf_batch_scratchpad_size: +.. _onemath_lapack_getrf_batch_scratchpad_size: getrf_batch_scratchpad_size =========================== -Computes size of scratchpad memory required for the :ref:`onemkl_lapack_getrf_batch` function. +Computes size of scratchpad memory required for the :ref:`onemath_lapack_getrf_batch` function. .. container:: section @@ -26,7 +26,7 @@ Computes size of scratchpad memory required for the :ref:`onemkl_lapack_getrf_ba **Group API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_getrf_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_getrf_batch` function. .. container:: section @@ -34,7 +34,7 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t getrf_batch_scratchpad_size(cl::sycl::queue &queue, std::int64_t *m, std::int64_t *n, std::int64_t *lda, std::int64_t group_count, std::int64_t *group_sizes) } @@ -65,7 +65,7 @@ group_sizes .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_getrf_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_getrf_batch` function. .. container:: section @@ -73,18 +73,18 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. **Strided API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_getrf_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_getrf_batch` function. .. container:: section @@ -92,7 +92,7 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t getrf_batch_scratchpad_size(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t lda, std::int64_t stride_a, std::int64_t stride_ipiv, std::int64_t batch_size) }; @@ -126,7 +126,7 @@ batch_size .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_getrf_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_getrf_batch` function. .. container:: section @@ -134,14 +134,14 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/getrf_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/getrf_scratchpad_size.rst similarity index 69% rename from source/elements/oneMKL/source/domains/lapack/getrf_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/getrf_scratchpad_size.rst index 7b5591ee8a..706669e670 100644 --- a/source/elements/oneMKL/source/domains/lapack/getrf_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/getrf_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_getrf_scratchpad_size: +.. _onemath_lapack_getrf_scratchpad_size: getrf_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_getrf` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_getrf` function. .. container:: section @@ -24,7 +24,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_getrf` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_getrf` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_getrf` function should be able to hold. Calls to this routine must specify the template parameter explicitly. getrf_scratchpad_size @@ -36,7 +36,7 @@ getrf_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t getrf_scratchpad_size(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t lda) } @@ -46,7 +46,7 @@ getrf_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_getrf` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_getrf` function will be performed. m The number of rows in the matrix :math:`A` (:math:`0 \le m`). @@ -63,11 +63,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -76,7 +76,7 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_getrf` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_getrf` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/getri.rst b/source/elements/oneMath/source/domains/lapack/getri.rst similarity index 74% rename from source/elements/oneMKL/source/domains/lapack/getri.rst rename to source/elements/oneMath/source/domains/lapack/getri.rst index 46c3075e21..8d8f11db29 100644 --- a/source/elements/oneMKL/source/domains/lapack/getri.rst +++ b/source/elements/oneMath/source/domains/lapack/getri.rst @@ -2,13 +2,13 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_getri: +.. _onemath_lapack_getri: getri ===== Computes the inverse of an LU-factored general matrix determined by -:ref:`onemkl_lapack_getrf`. +:ref:`onemath_lapack_getrf`. .. container:: section @@ -26,7 +26,7 @@ Computes the inverse of an LU-factored general matrix determined by * - ``std::complex`` The routine computes the inverse :math:`A^{-1}` of a general matrix -:math:`A`. Before calling this routine, call :ref:`onemkl_lapack_getrf` +:math:`A`. Before calling this routine, call :ref:`onemath_lapack_getrf` to factorize :math:`A`. getri (BUFFER Version) @@ -38,7 +38,7 @@ getri (BUFFER Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { void getri(cl::sycl::queue &queue, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &ipiv, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } @@ -53,19 +53,19 @@ n The order of the matrix :math:`A` :math:`(0 \le n)`. a - The buffer ``a`` as returned by :ref:`onemkl_lapack_getrf`. Must + The buffer ``a`` as returned by :ref:`onemath_lapack_getrf`. Must be of size at least :math:`\text{lda} \cdot \max(1,n)`. lda The leading dimension of ``a`` :math:`(n \le \text{lda})`. ipiv - The buffer as returned by :ref:`onemkl_lapack_getrf`. The + The buffer as returned by :ref:`onemath_lapack_getrf`. The dimension of ``ipiv`` must be at least :math:`\max(1, n)`. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_getri_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_getri_scratchpad_size` function. .. container:: section @@ -83,17 +83,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -110,7 +110,7 @@ getri (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event getri(cl::sycl::queue &queue, std::int64_t n, T *a, std::int64_t lda, const std::int64_t *ipiv, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } @@ -125,19 +125,19 @@ n The order of the matrix :math:`A` :math:`(0 \le n)`. a - The array as returned by :ref:`onemkl_lapack_getrf`. Must + The array as returned by :ref:`onemath_lapack_getrf`. Must be of size at least :math:`\text{lda} \cdot \max(1,n)`. lda The leading dimension of ``a`` :math:`(n \le \text{lda})`. ipiv - The array as returned by :ref:`onemkl_lapack_getrf`. The + The array as returned by :ref:`onemath_lapack_getrf`. The dimension of ``ipiv`` must be at least :math:`\max(1, n)`. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_getri_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_getri_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -158,17 +158,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -182,5 +182,5 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/getri_batch.rst b/source/elements/oneMath/source/domains/lapack/getri_batch.rst similarity index 78% rename from source/elements/oneMKL/source/domains/lapack/getri_batch.rst rename to source/elements/oneMath/source/domains/lapack/getri_batch.rst index 7aeee349cd..e3dd03f4e8 100644 --- a/source/elements/oneMKL/source/domains/lapack/getri_batch.rst +++ b/source/elements/oneMath/source/domains/lapack/getri_batch.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_getri_batch: +.. _onemath_lapack_getri_batch: getri_batch =========== -Computes the inverses of a batch of LU-factored matrices determined by :ref:`onemkl_lapack_getrf_batch`. +Computes the inverses of a batch of LU-factored matrices determined by :ref:`onemath_lapack_getrf_batch`. .. container:: section @@ -24,7 +24,7 @@ Computes the inverses of a batch of LU-factored matrices determined by :ref:`one * - ``std::complex`` * - ``std::complex`` -.. _onemkl_lapack_getri_batch_buffer: +.. _onemath_lapack_getri_batch_buffer: getri_batch (Buffer Version) ---------------------------- @@ -37,7 +37,7 @@ The buffer version of ``getri_batch`` supports only the strided API. **Strided API** -The routine computes the inverses :math:`A_i^{-1}` of general matrices :math:`A_i`. Before calling this routine, call the Strided API of the :ref:`onemkl_lapack_getrf_batch_buffer` function to factorize :math:`A_i`. +The routine computes the inverses :math:`A_i^{-1}` of general matrices :math:`A_i`. Before calling this routine, call the Strided API of the :ref:`onemath_lapack_getrf_batch_buffer` function to factorize :math:`A_i`. .. container:: section @@ -45,7 +45,7 @@ The routine computes the inverses :math:`A_i^{-1}` of general matrices :math:`A_ .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { void getri_batch(cl::sycl::queue &queue, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, std::int64_t stride_a, cl::sycl::buffer &ipiv, std::int64_t stride_ipiv, std::int64_t batch_size, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } @@ -60,7 +60,7 @@ n Order of the matrices :math:`A_i` (:math:`0 \le n`). a - Result of the Strided API of the :ref:`onemkl_lapack_getrf_batch_buffer` function. + Result of the Strided API of the :ref:`onemath_lapack_getrf_batch_buffer` function. lda Leading dimension of :math:`A_i` (:math:`n\le \text{lda}`). @@ -69,7 +69,7 @@ stride_a Stride between the beginnings of matrices :math:`A_i` inside the batch array ``a``. ipiv - Arrays returned by the Strided API of the :ref:`onemkl_lapack_getrf_batch_buffer` function. + Arrays returned by the Strided API of the :ref:`onemath_lapack_getrf_batch_buffer` function. stride_ipiv Stride between the beginnings of arrays :math:`\text{ipiv}_i` inside the array ``ipiv``. @@ -81,7 +81,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the Strided API of the :ref:`onemkl_lapack_getri_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the Strided API of the :ref:`onemath_lapack_getri_batch_scratchpad_size` function. .. container:: section @@ -96,13 +96,13 @@ a This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -124,7 +124,7 @@ The USM version of ``getri_batch`` supports the group API and strided API. **Group API** -The routine computes the inverses :math:`A_i^{-1}` of general matrices :math:`A_i`, :math:`i \in \{1...batch\_size\}`. Before calling this routine, call the Group API of the :ref:`onemkl_lapack_getrf_batch_usm` function to factorize :math:`A_i`. +The routine computes the inverses :math:`A_i^{-1}` of general matrices :math:`A_i`, :math:`i \in \{1...batch\_size\}`. Before calling this routine, call the Group API of the :ref:`onemath_lapack_getrf_batch_usm` function to factorize :math:`A_i`. Total number of problems to solve, ``batch_size``, is a sum of sizes of all of the groups of parameters as provided by ``group_sizes`` array. .. container:: section @@ -133,7 +133,7 @@ Total number of problems to solve, ``batch_size``, is a sum of sizes of all of t .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event getri_batch(cl::sycl::queue &queue, std::int64_t *n, T **a, std::int64_t *lda, const std::int64_t * const *ipiv, std::int64_t group_count, std::int64_t *group_sizes, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } @@ -148,13 +148,13 @@ n Array of ``group_count`` :math:`n_g` parameters specifying the order of the matrices :math:`A_i` (:math:`0 \le n_g`) belonging to group :math:`g`. a - Result of the Group API of the :ref:`onemkl_lapack_getrf_batch_usm` function. + Result of the Group API of the :ref:`onemath_lapack_getrf_batch_usm` function. lda Array of ``group_count`` :math:`\text{lda}_g` parameters specifying the leading dimensions of the matrices :math:`A_i` (:math:`n_g \le \text{lda}_g`) belonging to group :math:`g`. ipiv - Arrays returned by the Group API of the :ref:`onemkl_lapack_getrf_batch_usm` function. + Arrays returned by the Group API of the :ref:`onemath_lapack_getrf_batch_usm` function. group_count Number of groups of parameters. Must be at least 0. @@ -166,7 +166,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the Group API of the :ref:`onemkl_lapack_getri_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the Group API of the :ref:`onemath_lapack_getri_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -190,13 +190,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -208,7 +208,7 @@ This routine shall throw the following exceptions if the associated condition is **Strided API** -The routine computes the inverses :math:`A_i^{-1}` of general matrices :math:`A_i`. Before calling this routine, call the Strided API of the :ref:`onemkl_lapack_getrf_batch_usm` function to factorize :math:`A_i`. +The routine computes the inverses :math:`A_i^{-1}` of general matrices :math:`A_i`. Before calling this routine, call the Strided API of the :ref:`onemath_lapack_getrf_batch_usm` function to factorize :math:`A_i`. .. container:: section @@ -216,7 +216,7 @@ The routine computes the inverses :math:`A_i^{-1}` of general matrices :math:`A_ .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event getri_batch(cl::sycl::queue &queue, std::int64_t n, T *a, std::int64_t lda, std::int64_t stride_a, const std::int64_t *ipiv, std::int64_t stride_ipiv, std::int64_t batch_size, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) }; @@ -231,7 +231,7 @@ n Order of the matrices :math:`A_i` (:math:`0 \le n`). a - Result of the Strided API of the :ref:`onemkl_lapack_getrf_batch_usm` function. + Result of the Strided API of the :ref:`onemath_lapack_getrf_batch_usm` function. lda Leading dimension of :math:`A_i` (:math:`n \le \text{lda}`). @@ -240,7 +240,7 @@ stride_a Stride between the beginnings of matrices :math:`A_i` inside the batch array ``a``. ipiv - Arrays returned by the Strided API of the :ref:`onemkl_lapack_getrf_batch_usm` function. + Arrays returned by the Strided API of the :ref:`onemath_lapack_getrf_batch_usm` function. stride_ipiv Stride between the beginnings of arrays :math:`\text{ipiv}_i` inside the array ``ipiv``. @@ -252,7 +252,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the Strided API of the :ref:`onemkl_lapack_getri_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the Strided API of the :ref:`onemath_lapack_getri_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -276,13 +276,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -292,5 +292,5 @@ This routine shall throw the following exceptions if the associated condition is If ``info`` is not zero and `detail()` returns zero, then there were some errors for some of the problems in the supplied batch and ``info`` code contains the number of failed calculations in a batch. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/getri_batch_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/getri_batch_scratchpad_size.rst similarity index 77% rename from source/elements/oneMKL/source/domains/lapack/getri_batch_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/getri_batch_scratchpad_size.rst index 954f645544..2bcd9b1a72 100644 --- a/source/elements/oneMKL/source/domains/lapack/getri_batch_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/getri_batch_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_getri_batch_scratchpad_size: +.. _onemath_lapack_getri_batch_scratchpad_size: getri_batch_scratchpad_size =========================== -Computed size of scratchpad memory required for the :ref:`onemkl_lapack_getri_batch` function. +Computed size of scratchpad memory required for the :ref:`onemath_lapack_getri_batch` function. .. container:: section @@ -26,7 +26,7 @@ Computed size of scratchpad memory required for the :ref:`onemkl_lapack_getri_ba **Group API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_getri_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_getri_batch` function. .. container:: section @@ -34,7 +34,7 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t getri_batch_scratchpad_size(cl::sycl::queue &queue, std::int64_t *n, std::int64_t *lda, std::int64_t group_count, std::int64_t *group_sizes) } @@ -62,7 +62,7 @@ group_sizes .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_getri_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_getri_batch` function. .. container:: section @@ -70,18 +70,18 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. **Strided API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_getri_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_getri_batch` function. .. container:: section @@ -89,7 +89,7 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t getri_batch_scratchpad_size(cl::sycl::queue &queue, std::int64_t n, std::int64_t lda, std::int64_t stride_a, std::int64_t stride_ipiv, std::int64_t batch_size) }; @@ -120,7 +120,7 @@ batch_size .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_getri_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_getri_batch` function. .. container:: section @@ -128,14 +128,14 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/getri_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/getri_scratchpad_size.rst similarity index 68% rename from source/elements/oneMKL/source/domains/lapack/getri_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/getri_scratchpad_size.rst index 2be911c9f0..a37584e111 100644 --- a/source/elements/oneMKL/source/domains/lapack/getri_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/getri_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_getri_scratchpad_size: +.. _onemath_lapack_getri_scratchpad_size: getri_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_getri` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_getri` function. .. container:: section @@ -24,7 +24,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_getri` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_getri` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_getri` function should be able to hold. Calls to this routine must specify the template parameter explicitly. @@ -37,7 +37,7 @@ getri_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t getri_scratchpad_size(cl::sycl::queue &queue, std::int64_t n, std::int64_t lda) } @@ -47,7 +47,7 @@ getri_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_getri` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_getri` function will be performed. n The order of the matrix :math:`A` :math:`(0 \le n)`. @@ -61,11 +61,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -74,8 +74,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_getri` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_getri` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines`  +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines`  diff --git a/source/elements/oneMKL/source/domains/lapack/getrs.rst b/source/elements/oneMath/source/domains/lapack/getrs.rst similarity index 67% rename from source/elements/oneMKL/source/domains/lapack/getrs.rst rename to source/elements/oneMath/source/domains/lapack/getrs.rst index 857c3edf99..aa963e17c9 100644 --- a/source/elements/oneMKL/source/domains/lapack/getrs.rst +++ b/source/elements/oneMath/source/domains/lapack/getrs.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_getrs: +.. _onemath_lapack_getrs: getrs ===== @@ -32,14 +32,14 @@ equations: :header-rows: 1 * - \ :math:`AX = B`\ - - if ``trans``\ =\ ``oneapi::mkl::transpose::nontrans``\ + - if ``trans``\ =\ ``oneapi::math::transpose::nontrans``\ * - \ :math:`A^TX = B`\ - - if ``trans``\ =\ ``oneapi::mkl::transpose::trans``\ + - if ``trans``\ =\ ``oneapi::math::transpose::trans``\ * - \ :math:`A^HX = B`\ - - if ``trans``\ =\ ``oneapi::mkl::transpose::conjtrans``\ + - if ``trans``\ =\ ``oneapi::math::transpose::conjtrans``\ Before calling this routine, you must call -:ref:`onemkl_lapack_getrf` +:ref:`onemath_lapack_getrf` to compute the LU factorization of :math:`A`. getrs (Buffer Version) @@ -51,8 +51,8 @@ getrs (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void getrs(cl::sycl::queue &queue, oneapi::mkl::transpose trans, std::int64_t n, std::int64_t nrhs, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &ipiv, cl::sycl::buffer &b, std::int64_t ldb, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void getrs(cl::sycl::queue &queue, oneapi::math::transpose trans, std::int64_t n, std::int64_t nrhs, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &ipiv, cl::sycl::buffer &b, std::int64_t ldb, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -65,13 +65,13 @@ queue trans Indicates the form of the equations: - If ``trans=oneapi::mkl::transpose::nontrans``, then :math:`AX = B` is solved + If ``trans=oneapi::math::transpose::nontrans``, then :math:`AX = B` is solved for :math:`X`. - If ``trans=oneapi::mkl::transpose::trans``, then :math:`A^TX = B` is solved + If ``trans=oneapi::math::transpose::trans``, then :math:`A^TX = B` is solved for :math:`X`. - If ``trans=oneapi::mkl::transpose::conjtrans``, then :math:`A^HX = B` is + If ``trans=oneapi::math::transpose::conjtrans``, then :math:`A^HX = B` is solved for :math:`X`. n @@ -83,7 +83,7 @@ nrhs a Buffer containing the factorization of the matrix :math:`A`, as - returned by :ref:`onemkl_lapack_getrf`. The second dimension of ``a`` must be at least + returned by :ref:`onemath_lapack_getrf`. The second dimension of ``a`` must be at least :math:`\max(1, n)`. lda @@ -91,7 +91,7 @@ lda ipiv Array, size at least :math:`\max(1, n)`. The ``ipiv`` array, as returned by - :ref:`onemkl_lapack_getrf`. + :ref:`onemath_lapack_getrf`. b The array ``b`` contains the matrix :math:`B` whose columns are the @@ -103,7 +103,7 @@ ldb scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_getrs_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_getrs_scratchpad_size` function. .. container:: section @@ -121,17 +121,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -151,8 +151,8 @@ getrs (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event getrs(cl::sycl::queue &queue, oneapi::mkl::transpose trans, std::int64_t n, std::int64_t nrhs, const T *a, std::int64_t lda, const std::int64_t *ipiv, T *b, std::int64_t ldb, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event getrs(cl::sycl::queue &queue, oneapi::math::transpose trans, std::int64_t n, std::int64_t nrhs, const T *a, std::int64_t lda, const std::int64_t *ipiv, T *b, std::int64_t ldb, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -165,13 +165,13 @@ queue trans Indicates the form of the equations: - If ``trans=oneapi::mkl::transpose::nontrans``, then :math:`AX = B` is solved + If ``trans=oneapi::math::transpose::nontrans``, then :math:`AX = B` is solved for :math:`X`. - If ``trans=oneapi::mkl::transpose::trans``, then :math:`A^TX = B` is solved + If ``trans=oneapi::math::transpose::trans``, then :math:`A^TX = B` is solved for :math:`X`. - If ``trans=oneapi::mkl::transpose::conjtrans``, then :math:`A^HX = B` is + If ``trans=oneapi::math::transpose::conjtrans``, then :math:`A^HX = B` is solved for :math:`X`. n @@ -183,7 +183,7 @@ nrhs a Pointer to array containing the factorization of the matrix :math:`A`, as - returned by :ref:`onemkl_lapack_getrf`. The second dimension of ``a`` must be at least + returned by :ref:`onemath_lapack_getrf`. The second dimension of ``a`` must be at least :math:`\max(1, n)`. lda @@ -191,7 +191,7 @@ lda ipiv Array, size at least :math:`\max(1, n)`. The ``ipiv`` array, as returned by - :ref:`onemkl_lapack_getrf`. + :ref:`onemath_lapack_getrf`. b The array ``b`` contains the matrix :math:`B` whose columns are the @@ -203,7 +203,7 @@ ldb scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_getrs_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_getrs_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -224,17 +224,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -251,4 +251,4 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/getrs_batch.rst b/source/elements/oneMath/source/domains/lapack/getrs_batch.rst similarity index 69% rename from source/elements/oneMKL/source/domains/lapack/getrs_batch.rst rename to source/elements/oneMath/source/domains/lapack/getrs_batch.rst index 7b24fc4a02..50a55b7b38 100644 --- a/source/elements/oneMKL/source/domains/lapack/getrs_batch.rst +++ b/source/elements/oneMath/source/domains/lapack/getrs_batch.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_getrs_batch: +.. _onemath_lapack_getrs_batch: getrs_batch =========== @@ -24,7 +24,7 @@ Solves a system of linear equations with a batch of LU-factored square coefficie * - ``std::complex`` * - ``std::complex`` -.. _onemkl_lapack_getrs_batch_buffer: +.. _onemath_lapack_getrs_batch_buffer: getrs_batch (Buffer Version) ---------------------------- @@ -38,10 +38,10 @@ The buffer version of ``getrs_batch`` supports only the strided API. **Strided API** | The routine solves for the following systems of linear equations :math:`X_i`: - | :math:`A_iX_i = B_i`, if ``trans=mkl::transpose::nontrans`` - | :math:`A_i^TX_i = B_i`, if ``trans=mkl::transpose::trans`` - | :math:`A_i^HX_i = B_i`, if ``trans=mkl::transpose::conjtrans`` - | Before calling this routine, the Strided API of the :ref:`onemkl_lapack_getrf_batch_buffer` function should be called to compute the LU factorizations of :math:`A_i`. + | :math:`A_iX_i = B_i`, if ``trans=math::transpose::nontrans`` + | :math:`A_i^TX_i = B_i`, if ``trans=math::transpose::trans`` + | :math:`A_i^HX_i = B_i`, if ``trans=math::transpose::conjtrans`` + | Before calling this routine, the Strided API of the :ref:`onemath_lapack_getrf_batch_buffer` function should be called to compute the LU factorizations of :math:`A_i`. .. container:: section @@ -49,8 +49,8 @@ The buffer version of ``getrs_batch`` supports only the strided API. .. code-block:: cpp - namespace oneapi::mkl::lapack { - void getrs_batch(cl::sycl::queue &queue, mkl::transpose trans, std::int64_t n, std::int64_t nrhs, cl::sycl::buffer &a, std::int64_t lda, std::int64_t stride_a, cl::sycl::buffer &ipiv, std::int64_t stride_ipiv, cl::sycl::buffer &b, std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void getrs_batch(cl::sycl::queue &queue, math::transpose trans, std::int64_t n, std::int64_t nrhs, cl::sycl::buffer &a, std::int64_t lda, std::int64_t stride_a, cl::sycl::buffer &ipiv, std::int64_t stride_ipiv, cl::sycl::buffer &b, std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -62,9 +62,9 @@ queue trans | Form of the equations: - | If ``trans = mkl::transpose::nontrans``, then :math:`A_iX_i = B_i` is solved for :math:`Xi`. - | If ``trans = mkl::transpose::trans``, then :math:`A_i^TX_i = B_i` is solved for :math:`X_i`. - | If ``trans = mkl::transpose::conjtrans``, then :math:`A_i^HX_i = B_i` is solved for :math:`X_i`. + | If ``trans = math::transpose::nontrans``, then :math:`A_iX_i = B_i` is solved for :math:`Xi`. + | If ``trans = math::transpose::trans``, then :math:`A_i^TX_i = B_i` is solved for :math:`X_i`. + | If ``trans = math::transpose::conjtrans``, then :math:`A_i^HX_i = B_i` is solved for :math:`X_i`. n Order of the matrices :math:`A_i` and the number of rows in matrices :math:`B_i` (:math:`0 \le n`). @@ -73,7 +73,7 @@ nrhs Number of right-hand sides (:math:`0 \le \text{nrhs}`). a - Array containing the factorizations of the matrices :math:`A_i`, as returned the Strided API of the :ref:`onemkl_lapack_getrf_batch_buffer` function. + Array containing the factorizations of the matrices :math:`A_i`, as returned the Strided API of the :ref:`onemath_lapack_getrf_batch_buffer` function. lda Leading dimension of :math:`A_i`. @@ -82,7 +82,7 @@ stride_a Stride between the beginnings of matrices :math:`A_i` inside the batch array ``a``. ipiv - ``ipiv`` array, as returned by the Strided API of the :ref:`onemkl_lapack_getrf_batch_buffer` function. + ``ipiv`` array, as returned by the Strided API of the :ref:`onemath_lapack_getrf_batch_buffer` function. stride_ipiv Stride between the beginnings of arrays :math:`\text{ipiv}_i` inside the array ``ipiv``. @@ -103,7 +103,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemkl_lapack_getrs_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemath_lapack_getrs_batch_scratchpad_size` function. .. container:: section @@ -118,13 +118,13 @@ b This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -136,7 +136,7 @@ This routine shall throw the following exceptions if the associated condition is If ``info`` is zero, then diagonal element of some of :math:`U_i` is zero, and the solve could not be completed. The indices of such matrices in the batch can be obtained with `ids()` method of the exception object. The indices of first zero diagonal elements in these :math:`U_i` matrices can be obtained by `exceptions()` method of exception object. -.. _onemkl_lapack_getrs_batch_usm: +.. _onemath_lapack_getrs_batch_usm: getrs_batch (USM Version) ------------------------- @@ -150,18 +150,18 @@ The USM version of ``getrs_batch`` supports the group API and strided API. **Group API** | The routine solves the following systems of linear equations for :math:`X_i` (:math:`i \in \{1...batch\_size\}`): - | :math:`A_iX_i = B_i`, if ``trans=mkl::transpose::nontrans`` - | :math:`A_i^TX_i = B_i`, if ``trans=mkl::transpose::trans`` - | :math:`A_i^HX_i = B_i`, if ``trans=mkl::transpose::conjtrans`` - | Before calling this routine, call the Group API of the :ref:`onemkl_lapack_getrf_batch_usm` function to compute the LU factorizations of :math:`A_i`. + | :math:`A_iX_i = B_i`, if ``trans=math::transpose::nontrans`` + | :math:`A_i^TX_i = B_i`, if ``trans=math::transpose::trans`` + | :math:`A_i^HX_i = B_i`, if ``trans=math::transpose::conjtrans`` + | Before calling this routine, call the Group API of the :ref:`onemath_lapack_getrf_batch_usm` function to compute the LU factorizations of :math:`A_i`. | Total number of problems to solve, ``batch_size``, is a sum of sizes of all of the groups of parameters as provided by ``group_sizes`` array. .. rubric:: Syntax .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event getrs_batch(cl::sycl::queue &queue, mkl::transpose *trans, std::int64_t *n, std::int64_t *nrhs, const T * const *a, std::int64_t *lda, const std::int64_t * const *ipiv, T **b, std::int64_t *ldb, std::int64_t group_count, std::int64_t *group_sizes, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event getrs_batch(cl::sycl::queue &queue, math::transpose *trans, std::int64_t *n, std::int64_t *nrhs, const T * const *a, std::int64_t *lda, const std::int64_t * const *ipiv, T **b, std::int64_t *ldb, std::int64_t group_count, std::int64_t *group_sizes, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -173,9 +173,9 @@ queue trans | Array of ``group_count`` parameters :math:`trans_g` indicating the form of the equations for the group :math:`g`: - | If ``trans = mkl::transpose::nontrans``, then :math:`A_iX_i = B_i` is solved for :math:`X_i`. - | If ``trans = mkl::transpose::trans``, then :math:`A_i^TX_i = B_i` is solved for :math:`X_i`. - | If ``trans = mkl::transpose::conjtrans``, then :math:`A_i^HX_i = B_i` is solved for :math:`X_i`. + | If ``trans = math::transpose::nontrans``, then :math:`A_iX_i = B_i` is solved for :math:`X_i`. + | If ``trans = math::transpose::trans``, then :math:`A_i^TX_i = B_i` is solved for :math:`X_i`. + | If ``trans = math::transpose::conjtrans``, then :math:`A_i^HX_i = B_i` is solved for :math:`X_i`. n Array of ``group_count`` parameters :math:`n_g` specifying the order of the matrices :math:`A_i` and the number of rows in matrices :math:`B_i` (:math:`0 \le n_g`) belonging to group :math:`g`. @@ -184,13 +184,13 @@ nrhs Array of ``group_count`` parameters :math:`\text{nrhs}_g` specifying the number of right-hand sides (:math:`0 \le \text{nrhs}_g`) for group :math:`g`. a - Array of ``batch_size`` pointers to factorizations of the matrices :math:`A_i`, as returned by the Group API of the:ref:`onemkl_lapack_getrf_batch_usm` function. + Array of ``batch_size`` pointers to factorizations of the matrices :math:`A_i`, as returned by the Group API of the:ref:`onemath_lapack_getrf_batch_usm` function. lda Array of ``group_count`` parameters :math:`\text{lda}_g` specifying the leading dimensions of :math:`A_i` from group :math:`g`. ipiv - ``ipiv`` array, as returned by the Group API of the :ref:`onemkl_lapack_getrf_batch_usm` function. + ``ipiv`` array, as returned by the Group API of the :ref:`onemath_lapack_getrf_batch_usm` function. b The array containing ``batch_size`` pointers to the matrices :math:`B_i` whose columns are the right-hand sides for the systems of equations. @@ -208,7 +208,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Group API of the :ref:`onemkl_lapack_getrs_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Group API of the :ref:`onemath_lapack_getrs_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -232,13 +232,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of problems during calculations. The info code of the problem can be obtained by info() method of exception object: @@ -253,10 +253,10 @@ This routine shall throw the following exceptions if the associated condition is **Strided API** | The routine solves the following systems of linear equations for :math:`X_i`: - | :math:`A_iX_i = B_i`, if ``trans=mkl::transpose::nontrans`` - | :math:`A_i^TX_i = B_i`, if ``trans=mkl::transpose::trans`` - | :math:`A_i^HX_i = B_i`, if ``trans=mkl::transpose::conjtrans`` - | Before calling this routine, the Strided API of the :ref:`onemkl_lapack_getrf_batch` function should be called to compute the LU factorizations of :math:`A_i`. + | :math:`A_iX_i = B_i`, if ``trans=math::transpose::nontrans`` + | :math:`A_i^TX_i = B_i`, if ``trans=math::transpose::trans`` + | :math:`A_i^HX_i = B_i`, if ``trans=math::transpose::conjtrans`` + | Before calling this routine, the Strided API of the :ref:`onemath_lapack_getrf_batch` function should be called to compute the LU factorizations of :math:`A_i`. .. container:: section @@ -264,8 +264,8 @@ This routine shall throw the following exceptions if the associated condition is .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event getrs_batch(cl::sycl::queue &queue, mkl::transpose trans, std::int64_t n, std::int64_t nrhs, const T *a, std::int64_t lda, std::int64_t stride_a, const std::int64_t *ipiv, std::int64_t stride_ipiv, T *b, std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event getrs_batch(cl::sycl::queue &queue, math::transpose trans, std::int64_t n, std::int64_t nrhs, const T *a, std::int64_t lda, std::int64_t stride_a, const std::int64_t *ipiv, std::int64_t stride_ipiv, T *b, std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) }; .. container:: section @@ -277,9 +277,9 @@ queue trans | Form of the equations: - | If ``trans = mkl::transpose::nontrans``, then :math:`A_iX_i = B_i` is solved for :math:`X_i`. - | If ``trans = mkl::transpose::trans``, then :math:`A_i^TX_i = B_i` is solved for :math:`X_i`. - | If ``trans = mkl::transpose::conjtrans``, then :math:`A_i^HX_i = B_i` is solved for :math:`X_i`. + | If ``trans = math::transpose::nontrans``, then :math:`A_iX_i = B_i` is solved for :math:`X_i`. + | If ``trans = math::transpose::trans``, then :math:`A_i^TX_i = B_i` is solved for :math:`X_i`. + | If ``trans = math::transpose::conjtrans``, then :math:`A_i^HX_i = B_i` is solved for :math:`X_i`. n Order of the matrices :math:`A_i` and the number of rows in matrices :math:`B_i` (:math:`0 \le n`). @@ -288,7 +288,7 @@ nrhs Number of right-hand sides (:math:`0 \le \text{nrhs}`). a - Array containing the factorizations of the matrices :math:`A_i`, as returned by the Strided API of the:ref:`onemkl_lapack_getrf_batch_usm` function. + Array containing the factorizations of the matrices :math:`A_i`, as returned by the Strided API of the:ref:`onemath_lapack_getrf_batch_usm` function. lda Leading dimension of :math:`A_i`. @@ -318,7 +318,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemkl_lapack_getrs_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemath_lapack_getrs_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -342,13 +342,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -361,5 +361,5 @@ This routine shall throw the following exceptions if the associated condition is If ``info`` is zero, then diagonal element of some of :math:`U_i` is zero, and the solve could not be completed. The indices of such matrices in the batch can be obtained with `ids()` method of the exception object. The indices of first zero diagonal elements in these :math:`U_i` matrices can be obtained by `exceptions()` method of exception object. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/getrs_batch_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/getrs_batch_scratchpad_size.rst similarity index 69% rename from source/elements/oneMKL/source/domains/lapack/getrs_batch_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/getrs_batch_scratchpad_size.rst index 14d36d9223..879b197065 100644 --- a/source/elements/oneMKL/source/domains/lapack/getrs_batch_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/getrs_batch_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_getrs_batch_scratchpad_size: +.. _onemath_lapack_getrs_batch_scratchpad_size: getrs_batch_scratchpad_size =========================== -Computes size of scratchpad memory required for the :ref:`onemkl_lapack_getrs_batch` function. +Computes size of scratchpad memory required for the :ref:`onemath_lapack_getrs_batch` function. .. container:: section @@ -26,7 +26,7 @@ Computes size of scratchpad memory required for the :ref:`onemkl_lapack_getrs_ba **Group API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_getrs_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_getrs_batch` function. .. container:: section @@ -34,9 +34,9 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t getrs_batch_scratchpad_size(cl::sycl::queue &queue, mkl::transpose *trans, std::int64_t *n, std::int64_t *nrhs, std::int64_t *lda, std::int64_t *ldb, std::int64_t group_count, std::int64_t *group_sizes) + std::int64_t getrs_batch_scratchpad_size(cl::sycl::queue &queue, math::transpose *trans, std::int64_t *n, std::int64_t *nrhs, std::int64_t *lda, std::int64_t *ldb, std::int64_t group_count, std::int64_t *group_sizes) } .. container:: section @@ -48,9 +48,9 @@ queue trans | Array of ``group_count`` parameters :math:`\text{trans}_g` indicating the form of the equations for the group :math:`g`: - | If ``trans = mkl::transpose::nontrans``, then :math:`A_iX_i = B_i` is solved for :math:`X_i`. - | If ``trans = mkl::transpose::trans``, then :math:`A_i^TX_i = B_i` is solved for :math:`X_i`. - | If ``trans = mkl::transpose::conjtrans``, then :math:`A_iHX_i = B_i` is solved for :math:`X_i`. + | If ``trans = math::transpose::nontrans``, then :math:`A_iX_i = B_i` is solved for :math:`X_i`. + | If ``trans = math::transpose::trans``, then :math:`A_i^TX_i = B_i` is solved for :math:`X_i`. + | If ``trans = math::transpose::conjtrans``, then :math:`A_iHX_i = B_i` is solved for :math:`X_i`. n Array of ``group_count`` parameters :math:`n_g` specifying the order of the matrices :math:`A_i` and the number of rows in matrices :math:`B_i` (:math:`0 \le n_g`) belonging to group :math:`g`. @@ -74,7 +74,7 @@ group_sizes .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_getrs_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_getrs_batch` function. .. container:: section @@ -82,18 +82,18 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. **Strided API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_getrs_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_getrs_batch` function. .. container:: section @@ -101,9 +101,9 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t getrs_batch_scratchpad_size(cl::sycl::queue &queue, mkl::transpose trans, std::int64_t n, std::int64_t nrhs, std::int64_t lda, std::int64_t stride_a, std::int64_t stride_ipiv, std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size) + std::int64_t getrs_batch_scratchpad_size(cl::sycl::queue &queue, math::transpose trans, std::int64_t n, std::int64_t nrhs, std::int64_t lda, std::int64_t stride_a, std::int64_t stride_ipiv, std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size) }; .. container:: section @@ -115,9 +115,9 @@ queue trans | Indicates the form of the equations: - | ``If trans = mkl::transpose::nontrans``, then :math:`A_iX_i = B_i` is solved for :math:`X_i`. - | If ``trans = mkl::transpose::trans``, then :math:`A_i^TX_i = B_i` is solved for :math:`X_i`. - | If ``trans = mkl::transpose::conjtrans``, then :math:`A_i^HX_i = B_i` is solved for :math:`X_i`. + | ``If trans = math::transpose::nontrans``, then :math:`A_iX_i = B_i` is solved for :math:`X_i`. + | If ``trans = math::transpose::trans``, then :math:`A_i^TX_i = B_i` is solved for :math:`X_i`. + | If ``trans = math::transpose::conjtrans``, then :math:`A_i^HX_i = B_i` is solved for :math:`X_i`. n Order of the matrices :math:`A_i` and the number of rows in matrices :math:`B_i` (:math:`0 \le n`). @@ -147,7 +147,7 @@ batch_size .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_getrs_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_getrs_batch` function. .. container:: section @@ -155,14 +155,14 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/getrs_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/getrs_scratchpad_size.rst similarity index 63% rename from source/elements/oneMKL/source/domains/lapack/getrs_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/getrs_scratchpad_size.rst index ec3484716d..164c37642a 100644 --- a/source/elements/oneMKL/source/domains/lapack/getrs_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/getrs_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_getrs_scratchpad_size: +.. _onemath_lapack_getrs_scratchpad_size: getrs_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_getrs` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_getrs` function. .. container:: section @@ -24,7 +24,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_getrs` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_getrs` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_getrs` function should be able to hold. Calls to this routine must specify the template parameter explicitly. @@ -37,9 +37,9 @@ getrs_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t getrs_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::transpose trans, std::int64_t n, std::int64_t nrhs, std::int64_t lda, std::int64_t ldb) + std::int64_t getrs_scratchpad_size(cl::sycl::queue &queue, oneapi::math::transpose trans, std::int64_t n, std::int64_t nrhs, std::int64_t lda, std::int64_t ldb) } .. container:: section @@ -47,18 +47,18 @@ getrs_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_getrs` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_getrs` function will be performed. trans Indicates the form of the equations: - If ``trans=oneapi::mkl::transpose::nontrans``, then :math:`AX = B` is solved + If ``trans=oneapi::math::transpose::nontrans``, then :math:`AX = B` is solved for :math:`X`. - If ``trans=oneapi::mkl::transpose::trans``, then :math:`A^TX = B` is solved + If ``trans=oneapi::math::transpose::trans``, then :math:`A^TX = B` is solved for :math:`X`. - If ``trans=oneapi::mkl::transpose::conjtrans``, then :math:`A^HX = B` is + If ``trans=oneapi::math::transpose::conjtrans``, then :math:`A^HX = B` is solved for :math:`X`. n @@ -80,11 +80,11 @@ ldb This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -93,8 +93,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_getrs` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_getrs` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines`  +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines`  diff --git a/source/elements/oneMKL/source/domains/lapack/heevd.rst b/source/elements/oneMath/source/domains/lapack/heevd.rst similarity index 76% rename from source/elements/oneMKL/source/domains/lapack/heevd.rst rename to source/elements/oneMath/source/domains/lapack/heevd.rst index 411505a1f2..b8b6b1d0a5 100644 --- a/source/elements/oneMKL/source/domains/lapack/heevd.rst +++ b/source/elements/oneMath/source/domains/lapack/heevd.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_heevd: +.. _onemath_lapack_heevd: heevd ===== @@ -47,8 +47,8 @@ heevd (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void heevd(cl::sycl::queue &queue, oneapi::mkl::job jobz, oneapi::mkl::uplo upper_lower, std::int64_t n, butter &a, std::int64_t lda, cl::sycl::buffer &w, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void heevd(cl::sycl::queue &queue, oneapi::math::job jobz, oneapi::math::uplo upper_lower, std::int64_t n, butter &a, std::int64_t lda, cl::sycl::buffer &w, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -87,7 +87,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_heevd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_heevd_scratchpad_size` function. .. container:: section @@ -111,28 +111,28 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: If ``info=-i``, the :math:`i`-th parameter had an illegal value. - If ``info=i``, and ``jobz = oneapi::mkl::job::novec``, then the algorithm + If ``info=i``, and ``jobz = oneapi::math::job::novec``, then the algorithm failed to converge; :math:`i` indicates the number of off-diagonal elements of an intermediate tridiagonal form which did not converge to zero. - If ``info=i``, and ``jobz = oneapi::mkl::job::vec``, then the algorithm failed + If ``info=i``, and ``jobz = oneapi::math::job::vec``, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns :math:`\text{info}/(n+1)` through :math:`\text{mod}(\text{info},n+1)`. @@ -147,8 +147,8 @@ heevd (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event heevd(cl::sycl::queue &queue, oneapi::mkl::job jobz, oneapi::mkl::uplo upper_lower, std::int64_t n, butter &a, std::int64_t lda, RealT *w, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event heevd(cl::sycl::queue &queue, oneapi::math::job jobz, oneapi::math::uplo upper_lower, std::int64_t n, butter &a, std::int64_t lda, RealT *w, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -186,7 +186,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_heevd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_heevd_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -212,28 +212,28 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: If ``info=-i``, the :math:`i`-th parameter had an illegal value. - If ``info=i``, and ``jobz = oneapi::mkl::job::novec``, then the algorithm + If ``info=i``, and ``jobz = oneapi::math::job::novec``, then the algorithm failed to converge; :math:`i` indicates the number of off-diagonal elements of an intermediate tridiagonal form which did not converge to zero. - If ``info=i``, and ``jobz = oneapi::mkl::job::vec``, then the algorithm failed + If ``info=i``, and ``jobz = oneapi::math::job::vec``, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns :math:`\text{info}/(n+1)` through :math:`\text{mod}(\text{info},n+1)`. @@ -245,5 +245,5 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/heevd_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/heevd_scratchpad_size.rst similarity index 69% rename from source/elements/oneMKL/source/domains/lapack/heevd_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/heevd_scratchpad_size.rst index 4773f2bcba..b7a09272e4 100644 --- a/source/elements/oneMKL/source/domains/lapack/heevd_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/heevd_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_heevd_scratchpad_size: +.. _onemath_lapack_heevd_scratchpad_size: heevd_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_heevd` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_heevd` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_heevd` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_heevd` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_heevd` function should be able to hold. Calls to this routine must specify the template parameter explicitly. @@ -35,9 +35,9 @@ heevd_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t heevd_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::job jobz, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t lda) + std::int64_t heevd_scratchpad_size(cl::sycl::queue &queue, oneapi::math::job jobz, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t lda) } .. container:: section @@ -45,7 +45,7 @@ heevd_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_heevd` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_heevd` function will be performed. jobz Must be ``job::novec`` or ``job::vec``. @@ -76,11 +76,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -89,8 +89,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_heevd` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_heevd` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/hegvd.rst b/source/elements/oneMath/source/domains/lapack/hegvd.rst similarity index 82% rename from source/elements/oneMKL/source/domains/lapack/hegvd.rst rename to source/elements/oneMath/source/domains/lapack/hegvd.rst index f30af5811a..e5fb9535de 100644 --- a/source/elements/oneMKL/source/domains/lapack/hegvd.rst +++ b/source/elements/oneMath/source/domains/lapack/hegvd.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_hegvd: +.. _onemath_lapack_hegvd: hegvd ===== @@ -44,8 +44,8 @@ hegvd (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void hegvd(cl::sycl::queue &queue, std::int64_t itype, oneapi::mkl::job jobz, oneapi::mkl::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &b, std::int64_t ldb, cl::sycl::buffer &w, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void hegvd(cl::sycl::queue &queue, std::int64_t itype, oneapi::math::job jobz, oneapi::math::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &b, std::int64_t ldb, cl::sycl::buffer &w, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -104,7 +104,7 @@ ldb scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_hegvd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_hegvd_scratchpad_size` function. .. container:: section @@ -142,17 +142,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -160,11 +160,11 @@ This routine shall throw the following exceptions if the associated condition is For :math:`\text{info} \le n`: - If :math:`\text{info}=i`, and ``jobz = oneapi::mkl::job::novec``, then the algorithm + If :math:`\text{info}=i`, and ``jobz = oneapi::math::job::novec``, then the algorithm failed to converge; :math:`i` indicates the number of off-diagonal elements of an intermediate tridiagonal form which did not converge to zero; - If :math:`\text{info}=i`, and ``jobz = oneapi::mkl::job::vec``, then the algorithm + If :math:`\text{info}=i`, and ``jobz = oneapi::math::job::vec``, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns :math:`\text{info}/(n+1)`` through :math:`\text{mod}(\text{info}, n+1)`. @@ -187,8 +187,8 @@ hegvd (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event hegvd(cl::sycl::queue &queue, std::int64_t itype, oneapi::mkl::job jobz, oneapi::mkl::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, T *b, std::int64_t ldb, RealT *w, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event hegvd(cl::sycl::queue &queue, std::int64_t itype, oneapi::math::job jobz, oneapi::math::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, T *b, std::int64_t ldb, RealT *w, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -245,7 +245,7 @@ ldb scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_hegvd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_hegvd_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -287,17 +287,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -305,11 +305,11 @@ This routine shall throw the following exceptions if the associated condition is For :math:`\text{info} \le n`: - If :math:`\text{info}=i`, and ``jobz = oneapi::mkl::job::novec``, then the algorithm + If :math:`\text{info}=i`, and ``jobz = oneapi::math::job::novec``, then the algorithm failed to converge; :math:`i` indicates the number of off-diagonal elements of an intermediate tridiagonal form which did not converge to zero; - If :math:`\text{info}=i`, and ``jobz = oneapi::mkl::job::vec``, then the algorithm + If :math:`\text{info}=i`, and ``jobz = oneapi::math::job::vec``, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns :math:`\text{info}/(n+1)` through :math:`\text{mod}(\text{info},n+1)`. @@ -329,5 +329,5 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/hegvd_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/hegvd_scratchpad_size.rst similarity index 73% rename from source/elements/oneMKL/source/domains/lapack/hegvd_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/hegvd_scratchpad_size.rst index bbf2646982..b9230486b2 100644 --- a/source/elements/oneMKL/source/domains/lapack/hegvd_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/hegvd_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_hegvd_scratchpad_size: +.. _onemath_lapack_hegvd_scratchpad_size: hegvd_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_hegvd` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_hegvd` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_hegvd` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_hegvd` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_hegvd` function should be able to hold. Calls to this routine must specify the template parameter explicitly. @@ -35,9 +35,9 @@ hegvd_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t hegvd_scratchpad_size(cl::sycl::queue &queue, std::int64_t itype, oneapi::mkl::job jobz, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t lda, std::int64_t ldb) + std::int64_t hegvd_scratchpad_size(cl::sycl::queue &queue, std::int64_t itype, oneapi::math::job jobz, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t lda, std::int64_t ldb) } .. container:: section @@ -45,7 +45,7 @@ hegvd_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_hegvd` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_hegvd` function will be performed. itype Must be 1 or 2 or 3. Specifies the problem type to be solved: @@ -90,11 +90,11 @@ ldb This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -103,8 +103,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_hegvd` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_hegvd` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/hetrd.rst b/source/elements/oneMath/source/domains/lapack/hetrd.rst similarity index 80% rename from source/elements/oneMKL/source/domains/lapack/hetrd.rst rename to source/elements/oneMath/source/domains/lapack/hetrd.rst index 71c3541986..d9beeef6e5 100644 --- a/source/elements/oneMKL/source/domains/lapack/hetrd.rst +++ b/source/elements/oneMath/source/domains/lapack/hetrd.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_hetrd: +.. _onemath_lapack_hetrd: hetrd ===== @@ -40,8 +40,8 @@ hetrd (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void hetrd(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &d, cl::sycl::buffer &e, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void hetrd(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &d, cl::sycl::buffer &e, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -75,7 +75,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_hetrd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_hetrd_scratchpad_size` function. .. container:: section @@ -118,17 +118,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -145,8 +145,8 @@ hetrd (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event hetrd(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, RealT *d, RealT *e, T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event hetrd(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, RealT *d, RealT *e, T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -179,7 +179,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_hetrd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_hetrd_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -225,17 +225,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -249,6 +249,6 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/hetrd_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/hetrd_scratchpad_size.rst similarity index 69% rename from source/elements/oneMKL/source/domains/lapack/hetrd_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/hetrd_scratchpad_size.rst index e44ca1813a..c32398c0d9 100644 --- a/source/elements/oneMKL/source/domains/lapack/hetrd_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/hetrd_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_hetrd_scratchpad_size: +.. _onemath_lapack_hetrd_scratchpad_size: hetrd_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_hetrd` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_hetrd` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_hetrd` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_hetrd` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_hetrd` function should be able to hold. Calls to this routine must specify the template parameter explicitly. @@ -35,9 +35,9 @@ hetrd_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t hetrd_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t lda) + std::int64_t hetrd_scratchpad_size(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t lda) } .. container:: section @@ -45,7 +45,7 @@ hetrd_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_hetrd` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_hetrd` function will be performed. upper_lower Must be ``uplo::upper`` or ``uplo::lower``. @@ -69,11 +69,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -82,8 +82,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_hetrd` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_hetrd` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/hetrf.rst b/source/elements/oneMath/source/domains/lapack/hetrf.rst similarity index 71% rename from source/elements/oneMKL/source/domains/lapack/hetrf.rst rename to source/elements/oneMath/source/domains/lapack/hetrf.rst index 62ee3a399b..b49f0cad58 100644 --- a/source/elements/oneMKL/source/domains/lapack/hetrf.rst +++ b/source/elements/oneMath/source/domains/lapack/hetrf.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_hetrf: +.. _onemath_lapack_hetrf: hetrf ===== @@ -46,8 +46,8 @@ hetrf (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void hetrf(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &ipiv, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void hetrf(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &ipiv, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -78,7 +78,7 @@ scratchpad scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_hetrf_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_hetrf_scratchpad_size` function. .. container:: section @@ -90,9 +90,9 @@ a ipiv Buffer, size at least :math:`\max(1, n)`. Contains details of the interchanges and the block structure of :math:`D`. If :math:`\text{ipiv}(i)=k>0`, then :math:`d_{ii}` is a :math:`1 \times 1` block, and the :math:`i`-th row and column of :math:`A` was interchanged with the :math:`k`-th row and column. - If ``upper_lower=oneapi::mkl::uplo::upper`` and :math:`\text{ipiv}(i)=\text{ipiv}(i-1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i`-1, and (:math:`i-1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. + If ``upper_lower=oneapi::math::uplo::upper`` and :math:`\text{ipiv}(i)=\text{ipiv}(i-1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i`-1, and (:math:`i-1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. - If ``upper_lower=oneapi::mkl::uplo::lower`` and :math:`\text{ipiv}(i)=\text{ipiv}(i+1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i+1`, and (:math:`i+1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. + If ``upper_lower=oneapi::math::uplo::lower`` and :math:`\text{ipiv}(i)=\text{ipiv}(i+1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i+1`, and (:math:`i+1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. .. container:: section @@ -100,17 +100,17 @@ ipiv This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -129,8 +129,8 @@ hetrf (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event hetrf(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, int_64 *ipiv, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event hetrf(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, int_64 *ipiv, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -161,7 +161,7 @@ scratchpad scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_hetrf_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_hetrf_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -176,9 +176,9 @@ a ipiv Pointer to array of size at least :math:`\max(1, n)`. Contains details of the interchanges and the block structure of :math:`D`. If :math:`\text{ipiv}(i)=k>0`, then :math:`d_{ii}` is a :math:`1 \times 1` block, and the :math:`i`-th row and column of :math:`A` was interchanged with the :math:`k`-th row and column. - If ``upper_lower=oneapi::mkl::uplo::upper`` and :math:`\text{ipiv}(i)=\text{ipiv}(i-1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i-1`, and (:math:`i-1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. + If ``upper_lower=oneapi::math::uplo::upper`` and :math:`\text{ipiv}(i)=\text{ipiv}(i-1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i-1`, and (:math:`i-1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. - If ``upper_lower=oneapi::mkl::uplo::lower`` and :math:`\text{ipiv}(i)=\text{ipiv}(i+1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i+1`, and (:math:`i+1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. + If ``upper_lower=oneapi::math::uplo::lower`` and :math:`\text{ipiv}(i)=\text{ipiv}(i+1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i+1`, and (:math:`i+1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. .. container:: section @@ -186,17 +186,17 @@ ipiv This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -212,5 +212,5 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/hetrf_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/hetrf_scratchpad_size.rst similarity index 71% rename from source/elements/oneMKL/source/domains/lapack/hetrf_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/hetrf_scratchpad_size.rst index 67ec1edbb2..f0cf4baf4a 100644 --- a/source/elements/oneMKL/source/domains/lapack/hetrf_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/hetrf_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_hetrf_scratchpad_size: +.. _onemath_lapack_hetrf_scratchpad_size: hetrf_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_hetrf` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_hetrf` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_hetrf` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_hetrf` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_hetrf` function should be able to hold. Calls to this routine must specify the template parameter explicitly. hetrf_scratchpad_size @@ -34,9 +34,9 @@ hetrf_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t hetrf_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t lda) + std::int64_t hetrf_scratchpad_size(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t lda) } .. container:: section @@ -44,7 +44,7 @@ hetrf_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_hetrf` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_hetrf` function will be performed. upper_lower Indicates whether the upper or lower triangular part of :math:`A` is @@ -70,11 +70,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -83,7 +83,7 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_hetrf` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_hetrf` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/lapack-like-extensions.inc.rst b/source/elements/oneMath/source/domains/lapack/lapack-like-extensions.inc.rst similarity index 62% rename from source/elements/oneMKL/source/domains/lapack/lapack-like-extensions.inc.rst rename to source/elements/oneMath/source/domains/lapack/lapack-like-extensions.inc.rst index b3378b25b5..df72edcbff 100644 --- a/source/elements/oneMKL/source/domains/lapack/lapack-like-extensions.inc.rst +++ b/source/elements/oneMath/source/domains/lapack/lapack-like-extensions.inc.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack-like-extensions-routines: +.. _onemath_lapack-like-extensions-routines: LAPACK-like Extensions Routines =============================== @@ -11,8 +11,8 @@ LAPACK-like Extensions Routines .. container:: - oneAPI Math Kernel Library DPC++ provides additional routines to - extend the functionality of the LAPACK routines. These include routines + |onemath_full_name| DPC++ provides additional routines to extend + the functionality of the LAPACK routines. These include routines to compute many independent factorizations, linear equation solutions, and similar. The following table lists the LAPACK-like Extensions routine groups. @@ -26,29 +26,29 @@ LAPACK-like Extensions Routines * - Routines - Scratchpad Size Routines - Description - * - :ref:`onemkl_lapack_geqrf_batch` - - :ref:`onemkl_lapack_geqrf_batch_scratchpad_size` + * - :ref:`onemath_lapack_geqrf_batch` + - :ref:`onemath_lapack_geqrf_batch_scratchpad_size` - Computes the QR factorizations of a batch of general matrices. - * - :ref:`onemkl_lapack_getrf_batch` - - :ref:`onemkl_lapack_getrf_batch_scratchpad_size` + * - :ref:`onemath_lapack_getrf_batch` + - :ref:`onemath_lapack_getrf_batch_scratchpad_size` - Computes the LU factorizations of a batch of general matrices. - * - :ref:`onemkl_lapack_getri_batch` - - :ref:`onemkl_lapack_getri_batch_scratchpad_size` + * - :ref:`onemath_lapack_getri_batch` + - :ref:`onemath_lapack_getri_batch_scratchpad_size` - Computes the inverses of a batch of LU-factored general matrices. - * - :ref:`onemkl_lapack_getrs_batch` - - :ref:`onemkl_lapack_getrs_batch_scratchpad_size` + * - :ref:`onemath_lapack_getrs_batch` + - :ref:`onemath_lapack_getrs_batch_scratchpad_size` - Solves systems of linear equations with a batch of LU-factored square coefficient matrices, with multiple right-hand sides. - * - :ref:`onemkl_lapack_orgqr_batch` - - :ref:`onemkl_lapack_orgqr_batch_scratchpad_size` + * - :ref:`onemath_lapack_orgqr_batch` + - :ref:`onemath_lapack_orgqr_batch_scratchpad_size` - Generates the real orthogonal/complex unitary matrix :math:`Q_i` of the QR factorization formed by geqrf_batch. - * - :ref:`onemkl_lapack_potrf_batch` - - :ref:`onemkl_lapack_potrf_batch_scratchpad_size` + * - :ref:`onemath_lapack_potrf_batch` + - :ref:`onemath_lapack_potrf_batch_scratchpad_size` - Computes the Cholesky factorization of a batch of symmetric (Hermitian) positive-definite matrices. - * - :ref:`onemkl_lapack_potrs_batch` - - :ref:`onemkl_lapack_potrs_batch_scratchpad_size` + * - :ref:`onemath_lapack_potrs_batch` + - :ref:`onemath_lapack_potrs_batch_scratchpad_size` - Solves systems of linear equations with a batch of Cholesky-factored symmetric (Hermitian) positive-definite coefficient matrices, with multiple right-hand sides. - * - :ref:`onemkl_lapack_ungqr_batch` - - :ref:`onemkl_lapack_ungqr_batch_scratchpad_size` + * - :ref:`onemath_lapack_ungqr_batch` + - :ref:`onemath_lapack_ungqr_batch_scratchpad_size` - Generates the complex unitary matrix :math:`Q_i` with the QR factorization formed by geqrf_batch. diff --git a/source/elements/oneMKL/source/domains/lapack/lapack-linear-equation-routines.inc.rst b/source/elements/oneMath/source/domains/lapack/lapack-linear-equation-routines.inc.rst similarity index 62% rename from source/elements/oneMKL/source/domains/lapack/lapack-linear-equation-routines.inc.rst rename to source/elements/oneMath/source/domains/lapack/lapack-linear-equation-routines.inc.rst index 6e6c25574e..7d34886ad2 100644 --- a/source/elements/oneMKL/source/domains/lapack/lapack-linear-equation-routines.inc.rst +++ b/source/elements/oneMath/source/domains/lapack/lapack-linear-equation-routines.inc.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack-linear-equation-routines: +.. _onemath_lapack-linear-equation-routines: LAPACK Linear Equation Routines =============================== @@ -26,56 +26,56 @@ LAPACK Linear Equation Routines * - Routines - Scratchpad Size Routines - Description - * - :ref:`onemkl_lapack_geqrf` - - :ref:`onemkl_lapack_geqrf_scratchpad_size` + * - :ref:`onemath_lapack_geqrf` + - :ref:`onemath_lapack_geqrf_scratchpad_size` - Computes the QR factorization of a general m-by-n matrix. - * - :ref:`onemkl_lapack_gerqf` - - :ref:`onemkl_lapack_gerqf_scratchpad_size` + * - :ref:`onemath_lapack_gerqf` + - :ref:`onemath_lapack_gerqf_scratchpad_size` - Computes the RQ factorization of a general m-by-n matrix. - * - :ref:`onemkl_lapack_getrf` - - :ref:`onemkl_lapack_getrf_scratchpad_size` + * - :ref:`onemath_lapack_getrf` + - :ref:`onemath_lapack_getrf_scratchpad_size` - Computes the LU factorization of a general m-by-n matrix. - * - :ref:`onemkl_lapack_getri` - - :ref:`onemkl_lapack_getri_scratchpad_size` + * - :ref:`onemath_lapack_getri` + - :ref:`onemath_lapack_getri_scratchpad_size` - Computes the inverse of an LU-factored general matrix. - * - :ref:`onemkl_lapack_getrs` - - :ref:`onemkl_lapack_getrs_scratchpad_size` + * - :ref:`onemath_lapack_getrs` + - :ref:`onemath_lapack_getrs_scratchpad_size` - Solves a system of linear equations with an LU-factored square coefficient matrix, with multiple right-hand sides. - * - :ref:`onemkl_lapack_hetrf` - - :ref:`onemkl_lapack_hetrf_scratchpad_size` + * - :ref:`onemath_lapack_hetrf` + - :ref:`onemath_lapack_hetrf_scratchpad_size` - Computes the Bunch-Kaufman factorization of a complex Hermitian matrix. - * - :ref:`onemkl_lapack_orgqr` - - :ref:`onemkl_lapack_orgqr_scratchpad_size` + * - :ref:`onemath_lapack_orgqr` + - :ref:`onemath_lapack_orgqr_scratchpad_size` - Generates the real orthogonal matrix :math:`Q` of the QR factorization formed by geqrf. - * - :ref:`onemkl_lapack_ormqr` - - :ref:`onemkl_lapack_ormqr_scratchpad_size` + * - :ref:`onemath_lapack_ormqr` + - :ref:`onemath_lapack_ormqr_scratchpad_size` - Multiplies a real matrix by the orthogonal matrix :math:`Q` of the QR factorization formed by geqrf. - * - :ref:`onemkl_lapack_ormrq` - - :ref:`onemkl_lapack_ormrq_scratchpad_size` + * - :ref:`onemath_lapack_ormrq` + - :ref:`onemath_lapack_ormrq_scratchpad_size` - Multiplies a real matrix by the orthogonal matrix :math:`Q` of the RQ factorization formed by gerqf. - * - :ref:`onemkl_lapack_potrf` - - :ref:`onemkl_lapack_potrf_scratchpad_size` + * - :ref:`onemath_lapack_potrf` + - :ref:`onemath_lapack_potrf_scratchpad_size` - Computes the Cholesky factorization of a symmetric (Hermitian) positive-definite matrix. - * - :ref:`onemkl_lapack_potri` - - :ref:`onemkl_lapack_potri_scratchpad_size` + * - :ref:`onemath_lapack_potri` + - :ref:`onemath_lapack_potri_scratchpad_size` - Computes the inverse of a Cholesky-factored symmetric (Hermitian) positive-definite matrix. - * - :ref:`onemkl_lapack_potrs` - - :ref:`onemkl_lapack_potrs_scratchpad_size` + * - :ref:`onemath_lapack_potrs` + - :ref:`onemath_lapack_potrs_scratchpad_size` - Solves a system of linear equations with a Cholesky-factored symmetric (Hermitian) positive-definite coefficient matrix, with multiple right-hand sides. - * - :ref:`onemkl_lapack_sytrf` - - :ref:`onemkl_lapack_sytrf_scratchpad_size` + * - :ref:`onemath_lapack_sytrf` + - :ref:`onemath_lapack_sytrf_scratchpad_size` - Computes the Bunch-Kaufman factorization of a symmetric matrix. - * - :ref:`onemkl_lapack_trtrs` - - :ref:`onemkl_lapack_trtrs_scratchpad_size` + * - :ref:`onemath_lapack_trtrs` + - :ref:`onemath_lapack_trtrs_scratchpad_size` - Solves a system of linear equations with a triangular coefficient matrix, with multiple right-hand sides. - * - :ref:`onemkl_lapack_ungqr` - - :ref:`onemkl_lapack_ungqr_scratchpad_size` + * - :ref:`onemath_lapack_ungqr` + - :ref:`onemath_lapack_ungqr_scratchpad_size` - Generates the complex unitary matrix :math:`Q` of the QR factorization formed by geqrf. - * - :ref:`onemkl_lapack_unmqr` - - :ref:`onemkl_lapack_unmqr_scratchpad_size` + * - :ref:`onemath_lapack_unmqr` + - :ref:`onemath_lapack_unmqr_scratchpad_size` - Multiplies a complex matrix by the unitary matrix :math:`Q` of the QR factorization formed by geqrf. - * - :ref:`onemkl_lapack_unmrq` - - :ref:`onemkl_lapack_unmrq_scratchpad_size` + * - :ref:`onemath_lapack_unmrq` + - :ref:`onemath_lapack_unmrq_scratchpad_size` - Multiplies a complex matrix by the unitary matrix :math:`Q` of the RQ factorization formed by gerqf. diff --git a/source/elements/oneMKL/source/domains/lapack/lapack-singular-value-eigenvalue-routines.inc.rst b/source/elements/oneMath/source/domains/lapack/lapack-singular-value-eigenvalue-routines.inc.rst similarity index 63% rename from source/elements/oneMKL/source/domains/lapack/lapack-singular-value-eigenvalue-routines.inc.rst rename to source/elements/oneMath/source/domains/lapack/lapack-singular-value-eigenvalue-routines.inc.rst index bcf8c1af3f..5e4a1e800f 100644 --- a/source/elements/oneMKL/source/domains/lapack/lapack-singular-value-eigenvalue-routines.inc.rst +++ b/source/elements/oneMath/source/domains/lapack/lapack-singular-value-eigenvalue-routines.inc.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack-singular-value-eigenvalue-routines: +.. _onemath_lapack-singular-value-eigenvalue-routines: LAPACK Singular Value and Eigenvalue Problem Routines ===================================================== @@ -26,47 +26,47 @@ LAPACK Singular Value and Eigenvalue Problem Routines * - Routines - Scratchpad Size Routines - Description - * - :ref:`onemkl_lapack_gebrd` - - :ref:`onemkl_lapack_gebrd_scratchpad_size` + * - :ref:`onemath_lapack_gebrd` + - :ref:`onemath_lapack_gebrd_scratchpad_size` - Reduces a general matrix to bidiagonal form. - * - :ref:`onemkl_lapack_gesvd` - - :ref:`onemkl_lapack_gesvd_scratchpad_size` + * - :ref:`onemath_lapack_gesvd` + - :ref:`onemath_lapack_gesvd_scratchpad_size` - Computes the singular value decomposition of a general rectangular matrix. - * - :ref:`onemkl_lapack_heevd` - - :ref:`onemkl_lapack_heevd_scratchpad_size` + * - :ref:`onemath_lapack_heevd` + - :ref:`onemath_lapack_heevd_scratchpad_size` - Computes all eigenvalues and, optionally, all eigenvectors of a complex Hermitian matrix using divide and conquer algorithm. - * - :ref:`onemkl_lapack_hegvd` - - :ref:`onemkl_lapack_hegvd_scratchpad_size` + * - :ref:`onemath_lapack_hegvd` + - :ref:`onemath_lapack_hegvd_scratchpad_size` - Computes all eigenvalues and, optionally, all eigenvectors of a complex generalized Hermitian definite eigenproblem using divide and conquer algorithm. - * - :ref:`onemkl_lapack_hetrd` - - :ref:`onemkl_lapack_hetrd_scratchpad_size` + * - :ref:`onemath_lapack_hetrd` + - :ref:`onemath_lapack_hetrd_scratchpad_size` - Reduces a complex Hermitian matrix to tridiagonal form. - * - :ref:`onemkl_lapack_orgbr` - - :ref:`onemkl_lapack_orgbr_scratchpad_size` + * - :ref:`onemath_lapack_orgbr` + - :ref:`onemath_lapack_orgbr_scratchpad_size` - Generates the real orthogonal matrix :math:`Q` or :math:`P^T` determined by gebrd. - * - :ref:`onemkl_lapack_orgtr` - - :ref:`onemkl_lapack_orgtr_scratchpad_size` + * - :ref:`onemath_lapack_orgtr` + - :ref:`onemath_lapack_orgtr_scratchpad_size` - Generates the real orthogonal matrix :math:`Q` determined by sytrd. - * - :ref:`onemkl_lapack_ormtr` - - :ref:`onemkl_lapack_ormtr_scratchpad_size` + * - :ref:`onemath_lapack_ormtr` + - :ref:`onemath_lapack_ormtr_scratchpad_size` - Multiplies a real matrix by the orthogonal matrix :math:`Q` determined by sytrd. - * - :ref:`onemkl_lapack_syevd` - - :ref:`onemkl_lapack_syevd_scratchpad_size` + * - :ref:`onemath_lapack_syevd` + - :ref:`onemath_lapack_syevd_scratchpad_size` - Computes all eigenvalues and, optionally, all eigenvectors of a real symmetric matrix using divide and conquer algorithm. - * - :ref:`onemkl_lapack_sygvd` - - :ref:`onemkl_lapack_sygvd_scratchpad_size` + * - :ref:`onemath_lapack_sygvd` + - :ref:`onemath_lapack_sygvd_scratchpad_size` - Computes all eigenvalues and, optionally, all eigenvectors of a real generalized symmetric definite eigenproblem using divide and conquer algorithm. - * - :ref:`onemkl_lapack_sytrd` - - :ref:`onemkl_lapack_sytrd_scratchpad_size` + * - :ref:`onemath_lapack_sytrd` + - :ref:`onemath_lapack_sytrd_scratchpad_size` - Reduces a real symmetric matrix to tridiagonal form. - * - :ref:`onemkl_lapack_ungbr` - - :ref:`onemkl_lapack_ungbr_scratchpad_size` + * - :ref:`onemath_lapack_ungbr` + - :ref:`onemath_lapack_ungbr_scratchpad_size` - Generates the complex unitary matrix :math:`Q` or :math:`P^T` determined by gebrd. - * - :ref:`onemkl_lapack_ungtr` - - :ref:`onemkl_lapack_ungtr_scratchpad_size` + * - :ref:`onemath_lapack_ungtr` + - :ref:`onemath_lapack_ungtr_scratchpad_size` - Generates the complex unitary matrix :math:`Q` determined by hetrd. - * - :ref:`onemkl_lapack_unmtr` - - :ref:`onemkl_lapack_unmtr_scratchpad_size` + * - :ref:`onemath_lapack_unmtr` + - :ref:`onemath_lapack_unmtr_scratchpad_size` - Multiplies a complex matrix by the unitary matrix :math:`Q` determined by hetrd. diff --git a/source/elements/oneMKL/source/domains/lapack/lapack.rst b/source/elements/oneMath/source/domains/lapack/lapack.rst similarity index 73% rename from source/elements/oneMKL/source/domains/lapack/lapack.rst rename to source/elements/oneMath/source/domains/lapack/lapack.rst index 77c7300101..0e869da37f 100644 --- a/source/elements/oneMKL/source/domains/lapack/lapack.rst +++ b/source/elements/oneMath/source/domains/lapack/lapack.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack: +.. _onemath_lapack: LAPACK Routines +++++++++++++++ -oneMKL provides a DPC++ interface to select routines from the Linear Algebra PACKage (LAPACK), as well as several LAPACK-like extension routines. +oneMath provides a DPC++ interface to select routines from the Linear Algebra PACKage (LAPACK), as well as several LAPACK-like extension routines. LAPACK routines require column major layout of matrices. .. include:: lapack-linear-equation-routines.inc.rst @@ -24,7 +24,7 @@ LAPACK routines require column major layout of matrices. :class: NoteTipHead - Different arrays used as parameters to oneMKL LAPACK routines must + Different arrays used as parameters to oneMath LAPACK routines must not overlap. @@ -41,4 +41,4 @@ LAPACK routines require column major layout of matrices. values may cause LAPACK to return unexpected results or become unstable. -**Parent topic:** :ref:`onemkl_dense_linear_algebra` +**Parent topic:** :ref:`onemath_dense_linear_algebra` diff --git a/source/elements/oneMKL/source/domains/lapack/orgbr.rst b/source/elements/oneMath/source/domains/lapack/orgbr.rst similarity index 74% rename from source/elements/oneMKL/source/domains/lapack/orgbr.rst rename to source/elements/oneMath/source/domains/lapack/orgbr.rst index f759704037..10d05ac308 100644 --- a/source/elements/oneMKL/source/domains/lapack/orgbr.rst +++ b/source/elements/oneMath/source/domains/lapack/orgbr.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_orgbr: +.. _onemath_lapack_orgbr: orgbr ===== Generates the real orthogonal matrix :math:`Q` or :math:`P^{T}` determined by -:ref:`onemkl_lapack_gebrd`. +:ref:`onemath_lapack_gebrd`. ``orgbr`` supports the following precisions. @@ -25,7 +25,7 @@ determined by .. rubric:: Description The routine generates the whole or part of the orthogonal matrices -:math:`Q` and :math:`P^{T}` formed by the routines :ref:`onemkl_lapack_gebrd`. +:math:`Q` and :math:`P^{T}` formed by the routines :ref:`onemath_lapack_gebrd`. All valid combinations of arguments are described in *Input parameters*. In most cases you need the following: @@ -66,8 +66,8 @@ orgbr (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void orgbr(cl::sycl::queue &queue, oneapi::mkl::generate gen, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void orgbr(cl::sycl::queue &queue, oneapi::math::generate gen, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -100,15 +100,15 @@ n k If ``gen = generate::q``, the number of columns in the original :math:`m \times k` matrix reduced by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. If ``gen = generate::p``, the number of rows in the original :math:`k \times n` matrix reduced by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. a The buffer ``a`` as returned by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. lda The leading dimension of ``a``. @@ -116,12 +116,12 @@ lda tau Buffer, size :math:`\min(m,k)` if ``gen = generate::q``, size :math:`\min(n,k)` if ``gen = generate::p``. Scalar factor of the - elementary reflectors, as returned by :ref:`onemkl_lapack_gebrd` in the array tauq + elementary reflectors, as returned by :ref:`onemath_lapack_gebrd` in the array tauq or taup. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_orgbr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_orgbr_scratchpad_size` function. .. container:: section @@ -141,17 +141,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -168,8 +168,8 @@ orgbr (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event orgbr(cl::sycl::queue &queue, oneapi::mkl::generate gen, std::int64_t m, std::int64_t n, std::int64_t k, T *a, std::int64_t lda, const T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event orgbr(cl::sycl::queue &queue, oneapi::math::generate gen, std::int64_t m, std::int64_t n, std::int64_t k, T *a, std::int64_t lda, const T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -202,15 +202,15 @@ n k If ``gen = generate::q``, the number of columns in the original :math:`m \times k` matrix reduced by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. If ``gen = generate::p``, the number of rows in the original :math:`k \times n` matrix reduced by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. a Pointer to array ``a`` as returned by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. lda The leading dimension of ``a``. @@ -218,12 +218,12 @@ lda tau Pointer to array of size :math:`\min(m,k)` if ``gen = generate::q``, size :math:`\min(n,k)` if ``gen = generate::p``. Scalar factor of the - elementary reflectors, as returned by :ref:`onemkl_lapack_gebrd` in the array tauq + elementary reflectors, as returned by :ref:`onemath_lapack_gebrd` in the array tauq or taup. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_orgbr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_orgbr_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -246,17 +246,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -270,5 +270,5 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/orgbr_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/orgbr_scratchpad_size.rst similarity index 70% rename from source/elements/oneMKL/source/domains/lapack/orgbr_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/orgbr_scratchpad_size.rst index 8acc30c79d..a6156e5a49 100644 --- a/source/elements/oneMKL/source/domains/lapack/orgbr_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/orgbr_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_orgbr_scratchpad_size: +.. _onemath_lapack_orgbr_scratchpad_size: orgbr_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_orgbr` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_orgbr` function. ``orgbr_scratchpad_size`` supports the following precisions. @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_orgbr` funct .. rubric:: Description -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_orgbr` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_orgbr` function should be able to hold. Calls to this routine must specify the template parameter explicitly. orgbr_scratchpad_size @@ -34,9 +34,9 @@ orgbr_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t orgbr_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::generate gen, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t &scratchpad_size) + std::int64_t orgbr_scratchpad_size(cl::sycl::queue &queue, oneapi::math::generate gen, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t &scratchpad_size) } .. container:: section @@ -44,7 +44,7 @@ orgbr_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_orgbr` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_orgbr` function will be performed. gen Must be ``generate::q`` or ``generate::p``. @@ -70,11 +70,11 @@ n k If ``gen = generate::q``, the number of columns in the original :math:`m \times k` matrix returned by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. If ``gen = generate::p``, the number of rows in the original :math:`k \times n` matrix returned by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. lda The leading dimension of ``a``. @@ -85,11 +85,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -98,8 +98,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_orgbr` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_orgbr` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines`  +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines`  diff --git a/source/elements/oneMKL/source/domains/lapack/orgqr.rst b/source/elements/oneMath/source/domains/lapack/orgqr.rst similarity index 75% rename from source/elements/oneMKL/source/domains/lapack/orgqr.rst rename to source/elements/oneMath/source/domains/lapack/orgqr.rst index b3fa0283e3..c5d2be04ee 100644 --- a/source/elements/oneMKL/source/domains/lapack/orgqr.rst +++ b/source/elements/oneMath/source/domains/lapack/orgqr.rst @@ -2,13 +2,13 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_orgqr: +.. _onemath_lapack_orgqr: orgqr ===== Generates the real orthogonal matrix :math:`Q` of the QR factorization formed -by :ref:`onemkl_lapack_geqrf`. +by :ref:`onemath_lapack_geqrf`. .. container:: section @@ -25,7 +25,7 @@ by :ref:`onemkl_lapack_geqrf`. The routine generates the whole or part of :math:`m \times m` orthogonal matrix :math:`Q` of the QR factorization formed by the routine -:ref:`onemkl_lapack_geqrf`. +:ref:`onemath_lapack_geqrf`. Usually :math:`Q` is determined from the QR factorization of an ``m`` by ``p`` matrix :math:`A` with :math:`m \ge p`. To compute the whole matrix @@ -33,21 +33,21 @@ by ``p`` matrix :math:`A` with :math:`m \ge p`. To compute the whole matrix :: - oneapi::mkl::lapack::orgqr(queue, m, m, p, a, lda, tau, scratchpad, scratchpad_size) + oneapi::math::lapack::orgqr(queue, m, m, p, a, lda, tau, scratchpad, scratchpad_size) To compute the leading :math:`p` columns of :math:`Q` (which form an orthonormal basis in the space spanned by the columns of :math:`A`): :: - oneapi::mkl::lapack::orgqr(queue, m, p, p, a, lda, tau, scratchpad, scratchpad_size) + oneapi::math::lapack::orgqr(queue, m, p, p, a, lda, tau, scratchpad, scratchpad_size) To compute the matrix :math:`Q^{k}` of the QR factorization of leading :math:`k` columns of the matrix :math:`A`: :: - oneapi::mkl::lapack::orgqr(queue, m, m, k, a, lda, tau, scratchpad, scratchpad_size) + oneapi::math::lapack::orgqr(queue, m, m, k, a, lda, tau, scratchpad, scratchpad_size) To compute the leading :math:`k` columns of :math:`Q^{k}` (which form an orthonormal basis in the space spanned by leading :math:`k` columns of @@ -55,7 +55,7 @@ the matrix :math:`A`): :: - oneapi::mkl::lapack::orgqr(queue, m, k, k, a, lda, tau, scratchpad, scratchpad_size) + oneapi::math::lapack::orgqr(queue, m, k, k, a, lda, tau, scratchpad, scratchpad_size) orgqr (Buffer Version) ---------------------- @@ -66,7 +66,7 @@ orgqr (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { void orgqr(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } @@ -89,18 +89,18 @@ k a The buffer ``a`` as returned by - :ref:`onemkl_lapack_geqrf`. + :ref:`onemath_lapack_geqrf`. lda The leading dimension of ``a`` (:math:`\text{lda} \le m`). tau The buffer ``tau`` as returned by - :ref:`onemkl_lapack_geqrf`. + :ref:`onemath_lapack_geqrf`. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_orgqr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_orgqr_scratchpad_size` function. .. container:: section @@ -119,17 +119,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -146,7 +146,7 @@ orgqr (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event orgqr(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t k, T *a, std::int64_t lda, const T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } @@ -169,18 +169,18 @@ k a The pointer to ``a`` as returned by - :ref:`onemkl_lapack_geqrf`. + :ref:`onemath_lapack_geqrf`. lda The leading dimension of ``a`` (:math:`\text{lda} \le m`). tau The pointer to ``tau`` as returned by - :ref:`onemkl_lapack_geqrf`. + :ref:`onemath_lapack_geqrf`. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_orgqr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_orgqr_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -202,17 +202,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -226,6 +226,6 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/orgqr_batch.rst b/source/elements/oneMath/source/domains/lapack/orgqr_batch.rst similarity index 82% rename from source/elements/oneMKL/source/domains/lapack/orgqr_batch.rst rename to source/elements/oneMath/source/domains/lapack/orgqr_batch.rst index de902e801f..ba55b8c22c 100644 --- a/source/elements/oneMKL/source/domains/lapack/orgqr_batch.rst +++ b/source/elements/oneMath/source/domains/lapack/orgqr_batch.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_orgqr_batch: +.. _onemath_lapack_orgqr_batch: orgqr_batch =========== @@ -20,7 +20,7 @@ Generates the orthogonal/unitary matrix :math:`Q_i` of the QR factorizations for * - ``float`` * - ``double`` -.. _onemkl_lapack_orgqr_batch_buffer: +.. _onemath_lapack_orgqr_batch_buffer: orgqr_batch (Buffer Version) ---------------------------- @@ -31,7 +31,7 @@ The buffer version of ``orgqr_batch`` supports only the strided API. **Strided API** - | The routine generates the wholes or parts of :math:`m \times n` orthogonal matrices :math:`Q_i` of the batch of QR factorizations formed by the Strided API of the :ref:`onemkl_lapack_geqrf_batch_buffer` function. + | The routine generates the wholes or parts of :math:`m \times n` orthogonal matrices :math:`Q_i` of the batch of QR factorizations formed by the Strided API of the :ref:`onemath_lapack_geqrf_batch_buffer` function. | Usually :math:`Q_i` is determined from the QR factorization of an :math:`m \times p` matrix :math:`A_i` with :math:`m \ge p`. | To compute the whole matrices :math:`Q_i`, use: | ``orgqr_batch(queue, m, m, p, a, ...)`` @@ -46,7 +46,7 @@ The buffer version of ``orgqr_batch`` supports only the strided API. .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { void orgqr_batch(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, std::int64_t stride_a, cl::sycl::buffer &tau, std::int64_t stride_tau, std::int64_t batch_size, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } @@ -67,7 +67,7 @@ k Number of elementary reflectors whose product defines the matrices :math:`Q_i` (:math:`0 \le k \le n`). a - Array resulting after call to the Strided API of the :ref:`onemkl_lapack_geqrf_batch_buffer` function. + Array resulting after call to the Strided API of the :ref:`onemath_lapack_geqrf_batch_buffer` function. lda Leading dimension of :math:`A_i` (:math:`\text{lda} \le m`). @@ -76,7 +76,7 @@ stride_a The stride between the beginnings of matrices :math:`A_i` inside the batch array ``a``. tau - Array resulting from call to the Strided API of the :ref:`onemkl_lapack_geqrf_batch_buffer` function. + Array resulting from call to the Strided API of the :ref:`onemath_lapack_geqrf_batch_buffer` function. stride_tau Stride between the beginnings of arrays :math:`\tau_i` inside the array ``tau``. @@ -88,7 +88,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemkl_lapack_orgqr_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemath_lapack_orgqr_batch_scratchpad_size` function. .. container:: section @@ -103,13 +103,13 @@ a This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -119,7 +119,7 @@ This routine shall throw the following exceptions if the associated condition is If ``info`` is not zero and `detail()` returns zero, then there were some errors for some of the problems in the supplied batch and ``info`` code contains the number of failed calculations in a batch. -.. _onemkl_lapack_orgqr_batch_usm: +.. _onemath_lapack_orgqr_batch_usm: orgqr_batch (USM Version) ------------------------- @@ -130,7 +130,7 @@ The USM version of ``orgqr_batch`` supports the group API and strided API. **Group API** - | The routine generates the wholes or parts of :math:`m \times n` orthogonal matrices :math:`Q_i` of the batch of QR factorizations formed by the Group API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + | The routine generates the wholes or parts of :math:`m \times n` orthogonal matrices :math:`Q_i` of the batch of QR factorizations formed by the Group API of the :ref:`onemath_lapack_geqrf_batch_usm` function. | Usually :math:`Q_i` is determined from the QR factorization of an :math:`m \times p` matrix :math:`A_i` with :math:`m \ge p`. | To compute the whole matrices :math:`Q_i`, use: | ``orgqr_batch(queue, m, m, p, a, ...)`` @@ -145,7 +145,7 @@ The USM version of ``orgqr_batch`` supports the group API and strided API. .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event orgqr_batch(cl::sycl::queue &queue, std::int64_t *m, std::int64_t *n, std::int64_t *k, T **a, std::int64_t *lda, const T * const *tau, std::int64_t group_count, std::int64_t *group_sizes, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } @@ -164,16 +164,16 @@ n Array of ``group_count`` :math:`n_g` parameters as previously supplied to group version of geqrf_batch function. k - Array of ``group_count`` :math:`k_g` parameters as previously supplied to the Group API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. The number of elementary reflectors whose product defines the matrices :math:`Q_i` (:math:`0 \le k_g \le n_g`). + Array of ``group_count`` :math:`k_g` parameters as previously supplied to the Group API of the :ref:`onemath_lapack_geqrf_batch_usm` function. The number of elementary reflectors whose product defines the matrices :math:`Q_i` (:math:`0 \le k_g \le n_g`). a - Array resulting after call to the Group API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array resulting after call to the Group API of the :ref:`onemath_lapack_geqrf_batch_usm` function. lda - Array of leading dimensions of :math:`A_i` as previously supplied to the Group API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array of leading dimensions of :math:`A_i` as previously supplied to the Group API of the :ref:`onemath_lapack_geqrf_batch_usm` function. tau - Array resulting after call to the Group API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array resulting after call to the Group API of the :ref:`onemath_lapack_geqrf_batch_usm` function. group_count Number of groups of parameters. Must be at least 0. @@ -185,7 +185,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by Group API of the :ref:`onemkl_lapack_orgqr_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by Group API of the :ref:`onemath_lapack_orgqr_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -209,13 +209,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -228,7 +228,7 @@ This routine shall throw the following exceptions if the associated condition is **Strided API** - | The routine generates the wholes or parts of :math:`m \times n` orthogonal matrices :math:`Q_i` of the batch of QR factorizations formed by the Strided API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + | The routine generates the wholes or parts of :math:`m \times n` orthogonal matrices :math:`Q_i` of the batch of QR factorizations formed by the Strided API of the :ref:`onemath_lapack_geqrf_batch_usm` function. | Usually :math:`Q_i` is determined from the QR factorization of an :math:`m \times p` matrix :math:`A_i` with :math:`m \ge p`. | To compute the whole matrices :math:`Q_i`, use: | ``orgqr_batch(queue, m, m, p, a, ...)`` @@ -243,7 +243,7 @@ This routine shall throw the following exceptions if the associated condition is .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event orgqr_batch(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t k, T *a, std::int64_t lda, std::int64_t stride_a, const T *tau, std::int64_t stride_tau, std::int64_t batch_size, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) }; @@ -264,7 +264,7 @@ k Number of elementary reflectors whose product defines the matrices :math:`Q_i` (:math:`0 \le k \le n`). a - Array resulting after call to the Strided API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array resulting after call to the Strided API of the :ref:`onemath_lapack_geqrf_batch_usm` function. lda Leading dimension of :math:`A_i` (:math:`\text{lda} \le m`). @@ -273,7 +273,7 @@ stride_a The stride between the beginnings of matrices :math:`A_i` inside the batch array ``a``. tau - Array resulting from call to the Strided API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array resulting from call to the Strided API of the :ref:`onemath_lapack_geqrf_batch_usm` function. stride_tau Stride between the beginnings of arrays :math:`\tau_i` inside the array ``tau``. @@ -285,7 +285,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemkl_lapack_orgqr_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemath_lapack_orgqr_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -309,13 +309,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -325,5 +325,5 @@ This routine shall throw the following exceptions if the associated condition is If ``info`` is not zero and `detail()` returns zero, then there were some errors for some of the problems in the supplied batch and ``info`` code contains the number of failed calculations in a batch. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/orgqr_batch_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/orgqr_batch_scratchpad_size.rst similarity index 78% rename from source/elements/oneMKL/source/domains/lapack/orgqr_batch_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/orgqr_batch_scratchpad_size.rst index 0cde70684b..0a122e4592 100644 --- a/source/elements/oneMKL/source/domains/lapack/orgqr_batch_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/orgqr_batch_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_orgqr_batch_scratchpad_size: +.. _onemath_lapack_orgqr_batch_scratchpad_size: orgqr_batch_scratchpad_size =========================== -Computes size of scratchpad memory required for the :ref:`onemkl_lapack_orgqr_batch` function. +Computes size of scratchpad memory required for the :ref:`onemath_lapack_orgqr_batch` function. .. container:: section @@ -24,7 +24,7 @@ Computes size of scratchpad memory required for the :ref:`onemkl_lapack_orgqr_ba **Group API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_orgqr_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_orgqr_batch` function. .. container:: section @@ -32,7 +32,7 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t orgqr_batch_scratchpad_size(cl::sycl::queue &queue, std::int64_t *m, std::int64_t *n, std::int64_t *k, std::int64_t *lda, std::int64_t group_count, std::int64_t *group_sizes) } @@ -66,7 +66,7 @@ group_sizes .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_orgqr_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_orgqr_batch` function. .. container:: section @@ -74,17 +74,17 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. **Strided API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_orgqr_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_orgqr_batch` function. .. container:: section @@ -92,7 +92,7 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t orgqr_batch_scratchpad_size(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t stride_a, std::int64_t stride_tau, std::int64_t batch_size) }; @@ -129,7 +129,7 @@ batch_size .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_orgqr_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_orgqr_batch` function. .. container:: section @@ -137,13 +137,13 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/orgqr_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/orgqr_scratchpad_size.rst similarity index 70% rename from source/elements/oneMKL/source/domains/lapack/orgqr_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/orgqr_scratchpad_size.rst index e62f4d4ebc..20c61bdc1f 100644 --- a/source/elements/oneMKL/source/domains/lapack/orgqr_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/orgqr_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_orgqr_scratchpad_size: +.. _onemath_lapack_orgqr_scratchpad_size: orgqr_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_orgqr` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_orgqr` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_orgqr` funct * - ``float`` * - ``double`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_orgqr` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_orgqr` function should be able to hold. Calls to this routine must specify the template parameter explicitly. orgqr_scratchpad_size @@ -34,7 +34,7 @@ orgqr_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t orgqr_scratchpad_size(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda) } @@ -44,7 +44,7 @@ orgqr_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_orgqr` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_orgqr` function will be performed. m The number of rows in the matrix :math:`A` (:math:`0 \le m`). @@ -65,11 +65,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -78,8 +78,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_orgqr` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_orgqr` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/orgtr.rst b/source/elements/oneMath/source/domains/lapack/orgtr.rst similarity index 66% rename from source/elements/oneMKL/source/domains/lapack/orgtr.rst rename to source/elements/oneMath/source/domains/lapack/orgtr.rst index 365625d5b9..a09d3fe2a0 100644 --- a/source/elements/oneMKL/source/domains/lapack/orgtr.rst +++ b/source/elements/oneMath/source/domains/lapack/orgtr.rst @@ -2,13 +2,13 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_orgtr: +.. _onemath_lapack_orgtr: orgtr ===== Generates the real orthogonal matrix :math:`Q` determined by -:ref:`onemkl_lapack_sytrd`. +:ref:`onemath_lapack_sytrd`. .. container:: section @@ -24,10 +24,10 @@ Generates the real orthogonal matrix :math:`Q` determined by * - ``double`` The routine explicitly generates the :math:`n \times n` orthogonal matrix -:math:`Q` formed by :ref:`onemkl_lapack_sytrd` when +:math:`Q` formed by :ref:`onemath_lapack_sytrd` when reducing a real symmetric matrix :math:`A` to tridiagonal form: :math:`A = QTQ^T`. Use this routine after a call to -:ref:`onemkl_lapack_sytrd`. +:ref:`onemath_lapack_sytrd`. orgtr (Buffer Version) ---------------------- @@ -38,8 +38,8 @@ orgtr (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void orgtr(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void orgtr(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -51,25 +51,25 @@ queue upper_lower Must be ``uplo::upper`` or ``uplo::lower``. Uses the same - ``upper_lower`` as supplied to :ref:`onemkl_lapack_sytrd`. + ``upper_lower`` as supplied to :ref:`onemath_lapack_sytrd`. n The order of the matrix :math:`Q` :math:`(0 \le n)`. a - The buffer ``a`` as returned by :ref:`onemkl_lapack_sytrd`. The + The buffer ``a`` as returned by :ref:`onemath_lapack_sytrd`. The second dimension of ``a`` must be at least :math:`\max(1,n)`. lda The leading dimension of ``a`` :math:`(n \le \text{lda})`. tau - The buffer ``tau`` as returned by :ref:`onemkl_lapack_sytrd`. The + The buffer ``tau`` as returned by :ref:`onemath_lapack_sytrd`. The dimension of ``tau`` must be at least :math:`\max(1, n-1)`. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_orgtr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_orgtr_scratchpad_size` function. .. container:: section @@ -87,17 +87,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -114,8 +114,8 @@ orgtr (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event orgtr(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, const T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event orgtr(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, const T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -128,26 +128,26 @@ queue upper_lower Must be ``uplo::upper`` or ``uplo::lower``. Uses the same ``upper_lower`` as supplied - to :ref:`onemkl_lapack_sytrd`. + to :ref:`onemath_lapack_sytrd`. n The order of the matrix :math:`Q` :math:`(0 \le n)`. a The pointer to ``a`` as returned by - :ref:`onemkl_lapack_sytrd`. The + :ref:`onemath_lapack_sytrd`. The second dimension of ``a`` must be at least :math:`\max(1,n)`. lda The leading dimension of ``a`` :math:`(n \le \text{lda})`. tau - The pointer to ``tau`` as returned by :ref:`onemkl_lapack_sytrd`. The + The pointer to ``tau`` as returned by :ref:`onemath_lapack_sytrd`. The dimension of ``tau`` must be at least :math:`\max(1, n-1)`. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_orgtr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_orgtr_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -168,17 +168,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -192,5 +192,5 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/orgtr_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/orgtr_scratchpad_size.rst similarity index 64% rename from source/elements/oneMKL/source/domains/lapack/orgtr_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/orgtr_scratchpad_size.rst index c2b238062d..8b60493472 100644 --- a/source/elements/oneMKL/source/domains/lapack/orgtr_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/orgtr_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_orgtr_scratchpad_size: +.. _onemath_lapack_orgtr_scratchpad_size: orgtr_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_orgtr` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_orgtr` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_orgtr` funct * - ``float`` * - ``double`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_orgtr` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_orgtr` function should be able to hold. Calls to this routine must specify the template parameter explicitly. orgtr_scratchpad_size @@ -34,9 +34,9 @@ orgtr_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t orgtr_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t lda) + std::int64_t orgtr_scratchpad_size(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t lda) } .. container:: section @@ -44,11 +44,11 @@ orgtr_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_orgtr` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_orgtr` function will be performed. upper_lower Must be ``uplo::upper`` or ``uplo::lower``. Uses the same - ``upper_lower`` as supplied to :ref:`onemkl_lapack_sytrd`. + ``upper_lower`` as supplied to :ref:`onemath_lapack_sytrd`. n The order of the matrix :math:`Q` :math:`(0 \le n)`. @@ -62,11 +62,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -75,8 +75,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_orgtr` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_orgtr` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/ormqr.rst b/source/elements/oneMath/source/domains/lapack/ormqr.rst similarity index 62% rename from source/elements/oneMKL/source/domains/lapack/ormqr.rst rename to source/elements/oneMath/source/domains/lapack/ormqr.rst index f36d463755..255359a763 100644 --- a/source/elements/oneMKL/source/domains/lapack/ormqr.rst +++ b/source/elements/oneMath/source/domains/lapack/ormqr.rst @@ -2,13 +2,13 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ormqr: +.. _onemath_lapack_ormqr: ormqr ===== Multiplies a real matrix by the orthogonal matrix :math:`Q` of the QR -factorization formed by :ref:`onemkl_lapack_geqrf`. +factorization formed by :ref:`onemath_lapack_geqrf`. .. container:: section @@ -27,7 +27,7 @@ The routine multiplies a rectangular real :math:`m \times n` matrix :math:`C` by :math:`Q` or :math:`Q^T`, where :math:`Q` is the complex unitary matrix defined as a product of :math:`k` elementary reflectors :math:`H(i)` of order :math:`n`: :math:`Q = H(1)^TH(2)^T ... H(k)^T` as returned by the RQ factorization routine -:ref:`onemkl_lapack_gerqf`. +:ref:`onemath_lapack_gerqf`. Depending on the parameters ``side`` and ``trans``, the routine can form one of the matrix products :math:`QC`, :math:`Q^TC`, :math:`CQ`, or :math:`CQ^T` @@ -42,8 +42,8 @@ ormqr (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void ormqr(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &c, std::int64_t ldc, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void ormqr(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &c, std::int64_t ldc, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -54,17 +54,17 @@ queue The queue where the routine should be executed. side - If ``side = oneapi::mkl::side::left``, :math:`Q` or :math:`Q^{T}` is applied + If ``side = oneapi::math::side::left``, :math:`Q` or :math:`Q^{T}` is applied to :math:`C` from the left. - If ``side = oneapi::mkl::side::right``, :math:`Q` or :math:`Q^{T}` is + If ``side = oneapi::math::side::right``, :math:`Q` or :math:`Q^{T}` is applied to :math:`C` from the right. trans - If ``trans = oneapi::mkl::transpose::nontrans``, the routine multiplies + If ``trans = oneapi::math::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. - If ``trans = oneapi::mkl::transpose::trans``, the routine multiplies :math:`C` + If ``trans = oneapi::math::transpose::trans``, the routine multiplies :math:`C` by :math:`Q^{T}`. m @@ -77,19 +77,19 @@ k The number of elementary reflectors whose product defines the matrix :math:`Q` - If ``side = oneapi::mkl::side::left``, :math:`0 \le k \le m` + If ``side = oneapi::math::side::left``, :math:`0 \le k \le m` - If ``side = oneapi::mkl::side::right``, :math:`0 \le k \le n` + If ``side = oneapi::math::side::right``, :math:`0 \le k \le n` a - The buffer ``a`` as returned by :ref:`onemkl_lapack_geqrf`. + The buffer ``a`` as returned by :ref:`onemath_lapack_geqrf`. The second dimension of ``a`` must be at least :math:`\max(1,k)`. lda The leading dimension of ``a``. tau - The buffer ``tau`` as returned by :ref:`onemkl_lapack_geqrf`. + The buffer ``tau`` as returned by :ref:`onemath_lapack_geqrf`. c The buffer ``c`` contains the matrix :math:`C`. The second dimension of @@ -101,7 +101,7 @@ ldc scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the - :ref:`onemkl_lapack_ormqr_scratchpad_size` function. + :ref:`onemath_lapack_ormqr_scratchpad_size` function. .. container:: section @@ -120,17 +120,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -147,8 +147,8 @@ ormqr (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event ormqr(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, const T *a, std::int64_t lda, const T *tau, T *c, std::int64_t ldc, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event ormqr(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, const T *a, std::int64_t lda, const T *tau, T *c, std::int64_t ldc, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -159,17 +159,17 @@ queue The queue where the routine should be executed. side - If ``side = oneapi::mkl::side::left``, :math:`Q` or :math:`Q^{T}` is applied + If ``side = oneapi::math::side::left``, :math:`Q` or :math:`Q^{T}` is applied to :math:`C` from the left. - If ``side = oneapi::mkl::side::right``, :math:`Q` or :math:`Q^{T}` is + If ``side = oneapi::math::side::right``, :math:`Q` or :math:`Q^{T}` is applied to :math:`C` from the right. trans - If ``trans = oneapi::mkl::transpose::nontrans``, the routine multiplies + If ``trans = oneapi::math::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. - If ``trans = oneapi::mkl::transpose::trans``, the routine multiplies :math:`C` + If ``trans = oneapi::math::transpose::trans``, the routine multiplies :math:`C` by :math:`Q^{T}`. m @@ -182,19 +182,19 @@ k The number of elementary reflectors whose product defines the matrix :math:`Q` - If ``side = oneapi::mkl::side::left``, :math:`0 \le k \le m` + If ``side = oneapi::math::side::left``, :math:`0 \le k \le m` - If ``side = oneapi::mkl::side::right``, :math:`0 \le k \le n` + If ``side = oneapi::math::side::right``, :math:`0 \le k \le n` a - The pointer to ``a`` as returned by :ref:`onemkl_lapack_geqrf`. + The pointer to ``a`` as returned by :ref:`onemath_lapack_geqrf`. The second dimension of ``a`` must be at least :math:`\max(1,k)`. lda The leading dimension of ``a``. tau - The pointer to ``tau`` as returned by :ref:`onemkl_lapack_geqrf`. + The pointer to ``tau`` as returned by :ref:`onemath_lapack_geqrf`. c The pointer ``c`` points to the matrix :math:`C`. The second dimension of @@ -206,7 +206,7 @@ ldc scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the - :ref:`onemkl_lapack_ormqr_scratchpad_size` function. + :ref:`onemath_lapack_ormqr_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -228,17 +228,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -252,4 +252,4 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/ormqr_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/ormqr_scratchpad_size.rst similarity index 60% rename from source/elements/oneMKL/source/domains/lapack/ormqr_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/ormqr_scratchpad_size.rst index 5a53434a17..b9273e7d9a 100644 --- a/source/elements/oneMKL/source/domains/lapack/ormqr_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/ormqr_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ormqr_scratchpad_size: +.. _onemath_lapack_ormqr_scratchpad_size: ormqr_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_ormqr` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_ormqr` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_ormqr` funct * - ``float`` * - ``double`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_ormqr` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_ormqr` function should be able to hold. Calls to this routine must specify the template parameter explicitly. ormqr_scratchpad_size @@ -34,9 +34,9 @@ ormqr_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t ormqr_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t ldc, std::int64_t &scratchpad_size) + std::int64_t ormqr_scratchpad_size(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t ldc, std::int64_t &scratchpad_size) } .. container:: section @@ -44,20 +44,20 @@ ormqr_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_ormqr` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_ormqr` function will be performed. side - If ``side=oneapi::mkl::side::left``, :math:`Q` or :math:`Q^{T}` is + If ``side=oneapi::math::side::left``, :math:`Q` or :math:`Q^{T}` is applied to :math:`C` from the left. - If ``side=oneapi::mkl::side::right``, :math:`Q` or :math:`Q^{T}` is + If ``side=oneapi::math::side::right``, :math:`Q` or :math:`Q^{T}` is applied to :math:`C` from the right. trans - If ``trans=oneapi::mkl::transpose::nontrans``, the routine multiplies + If ``trans=oneapi::math::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. - If ``trans=oneapi::mkl::transpose::trans``, the routine multiplies + If ``trans=oneapi::math::transpose::trans``, the routine multiplies :math:`C` by :math:`Q^{T}`. m @@ -82,11 +82,11 @@ ldc This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -95,8 +95,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_ormqr` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_ormqr` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines`  +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines`  diff --git a/source/elements/oneMKL/source/domains/lapack/ormrq.rst b/source/elements/oneMath/source/domains/lapack/ormrq.rst similarity index 62% rename from source/elements/oneMKL/source/domains/lapack/ormrq.rst rename to source/elements/oneMath/source/domains/lapack/ormrq.rst index 97739ecf4f..504d2b567a 100644 --- a/source/elements/oneMKL/source/domains/lapack/ormrq.rst +++ b/source/elements/oneMath/source/domains/lapack/ormrq.rst @@ -2,13 +2,13 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ormrq: +.. _onemath_lapack_ormrq: ormrq ===== Multiplies a real matrix by the orthogonal matrix :math:`Q` of the RQ -factorization formed by :ref:`onemkl_lapack_gerqf`. +factorization formed by :ref:`onemath_lapack_gerqf`. .. container:: section @@ -27,7 +27,7 @@ The routine multiplies a rectangular real :math:`m \times n` matrix :math:`C` by :math:`Q` or :math:`Q^T`, where :math:`Q` is the complex unitary matrix defined as a product of :math:`k` elementary reflectors :math:`H(i)` of order :math:`n`: :math:`Q = H(1)^TH(2)^T ... H(k)^T` as returned by the RQ factorization routine -:ref:`onemkl_lapack_gerqf`. +:ref:`onemath_lapack_gerqf`. Depending on the parameters ``side`` and ``trans``, the routine can form one of the matrix products :math:`QC`, :math:`Q^TC`, :math:`CQ`, or :math:`CQ^T` @@ -42,8 +42,8 @@ ormrq (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void ormrq(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &c, std::int64_t ldc, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void ormrq(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &c, std::int64_t ldc, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -54,17 +54,17 @@ queue The queue where the routine should be executed. side - If ``side = oneapi::mkl::side::left``, :math:`Q` or :math:`Q^{T}` is applied + If ``side = oneapi::math::side::left``, :math:`Q` or :math:`Q^{T}` is applied to :math:`C` from the left. - If ``side = oneapi::mkl::side::right``, :math:`Q` or :math:`Q^{T}` is + If ``side = oneapi::math::side::right``, :math:`Q` or :math:`Q^{T}` is applied to :math:`C` from the right. trans - If ``trans = oneapi::mkl::transpose::nontrans``, the routine multiplies + If ``trans = oneapi::math::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. - If ``trans = oneapi::mkl::transpose::trans``, the routine multiplies :math:`C` + If ``trans = oneapi::math::transpose::trans``, the routine multiplies :math:`C` by :math:`Q^{T}`. m @@ -77,19 +77,19 @@ k The number of elementary reflectors whose product defines the matrix :math:`Q` - If ``side = oneapi::mkl::side::left``, :math:`0 \le k \le m` + If ``side = oneapi::math::side::left``, :math:`0 \le k \le m` - If ``side = oneapi::mkl::side::right``, :math:`0 \le k \le n` + If ``side = oneapi::math::side::right``, :math:`0 \le k \le n` a - The buffer ``a`` as returned by :ref:`onemkl_lapack_gerqf`. + The buffer ``a`` as returned by :ref:`onemath_lapack_gerqf`. The second dimension of ``a`` must be at least :math:`\max(1,k)`. lda The leading dimension of ``a``. tau - The buffer ``tau`` as returned by :ref:`onemkl_lapack_gerqf`. + The buffer ``tau`` as returned by :ref:`onemath_lapack_gerqf`. c The buffer ``c`` contains the matrix :math:`C`. The second dimension of @@ -101,7 +101,7 @@ ldc scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the - :ref:`onemkl_lapack_ormrq_scratchpad_size` function. + :ref:`onemath_lapack_ormrq_scratchpad_size` function. .. container:: section @@ -120,17 +120,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -147,8 +147,8 @@ ormrq (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event ormrq(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, const T *a, std::int64_t lda, const T *tau, T *c, std::int64_t ldc, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event ormrq(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, const T *a, std::int64_t lda, const T *tau, T *c, std::int64_t ldc, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -159,17 +159,17 @@ queue The queue where the routine should be executed. side - If ``side = oneapi::mkl::side::left``, :math:`Q` or :math:`Q^{T}` is applied + If ``side = oneapi::math::side::left``, :math:`Q` or :math:`Q^{T}` is applied to :math:`C` from the left. - If ``side = oneapi::mkl::side::right``, :math:`Q` or :math:`Q^{T}` is + If ``side = oneapi::math::side::right``, :math:`Q` or :math:`Q^{T}` is applied to :math:`C` from the right. trans - If ``trans = oneapi::mkl::transpose::nontrans``, the routine multiplies + If ``trans = oneapi::math::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. - If ``trans = oneapi::mkl::transpose::trans``, the routine multiplies :math:`C` + If ``trans = oneapi::math::transpose::trans``, the routine multiplies :math:`C` by :math:`Q^{T}`. m @@ -182,19 +182,19 @@ k The number of elementary reflectors whose product defines the matrix :math:`Q` - If ``side = oneapi::mkl::side::left``, :math:`0 \le k \le m` + If ``side = oneapi::math::side::left``, :math:`0 \le k \le m` - If ``side = oneapi::mkl::side::right``, :math:`0 \le k \le n` + If ``side = oneapi::math::side::right``, :math:`0 \le k \le n` a - The pointer to ``a`` as returned by :ref:`onemkl_lapack_gerqf`. + The pointer to ``a`` as returned by :ref:`onemath_lapack_gerqf`. The second dimension of ``a`` must be at least :math:`\max(1,k)`. lda The leading dimension of ``a``. tau - The pointer to ``tau`` as returned by :ref:`onemkl_lapack_gerqf`. + The pointer to ``tau`` as returned by :ref:`onemath_lapack_gerqf`. c The pointer ``c`` points to the matrix :math:`C`. The second dimension of @@ -206,7 +206,7 @@ ldc scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the - :ref:`onemkl_lapack_ormrq_scratchpad_size` function. + :ref:`onemath_lapack_ormrq_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -228,17 +228,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -252,5 +252,5 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/ormrq_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/ormrq_scratchpad_size.rst similarity index 60% rename from source/elements/oneMKL/source/domains/lapack/ormrq_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/ormrq_scratchpad_size.rst index f0ce238e77..dabe6020fd 100644 --- a/source/elements/oneMKL/source/domains/lapack/ormrq_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/ormrq_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ormrq_scratchpad_size: +.. _onemath_lapack_ormrq_scratchpad_size: ormrq_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_ormrq` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_ormrq` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_ormrq` funct * - ``float`` * - ``double`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_ormrq` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_ormrq` function should be able to hold. Calls to this routine must specify the template parameter explicitly. ormrq_scratchpad_size @@ -34,9 +34,9 @@ ormrq_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t ormrq_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t ldc); + std::int64_t ormrq_scratchpad_size(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t ldc); } .. container:: section @@ -47,14 +47,14 @@ queue Device queue where calculations by the ormrq function will be performed. side - If ``side = oneapi::mkl::side::left``, :math:`Q` or :math:`Q^T` is applied to :math:`C` from the left. + If ``side = oneapi::math::side::left``, :math:`Q` or :math:`Q^T` is applied to :math:`C` from the left. - If ``side = oneapi::mkl::side::right``, :math:`Q` or :math:`Q^T` is applied to :math:`C` from the right. + If ``side = oneapi::math::side::right``, :math:`Q` or :math:`Q^T` is applied to :math:`C` from the right. trans - If ``trans=oneapi::mkl::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. + If ``trans=oneapi::math::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. - If ``trans=oneapi::mkl::transpose::trans``, the routine multiplies :math:`C` by :math:`Q^T`. + If ``trans=oneapi::math::transpose::trans``, the routine multiplies :math:`C` by :math:`Q^T`. m The number of rows in the matrix :math:`C` (:math:`0 \le m`). @@ -77,11 +77,11 @@ ldc This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -90,7 +90,7 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_ormrq` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_ormrq` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/ormtr.rst b/source/elements/oneMath/source/domains/lapack/ormtr.rst similarity index 73% rename from source/elements/oneMKL/source/domains/lapack/ormtr.rst rename to source/elements/oneMath/source/domains/lapack/ormtr.rst index c02f526f69..e34cf2cf5f 100644 --- a/source/elements/oneMKL/source/domains/lapack/ormtr.rst +++ b/source/elements/oneMath/source/domains/lapack/ormtr.rst @@ -2,13 +2,13 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ormtr: +.. _onemath_lapack_ormtr: ormtr ===== Multiplies a real matrix by the real orthogonal matrix :math:`Q` determined by -:ref:`onemkl_lapack_sytrd`. +:ref:`onemath_lapack_sytrd`. .. container:: section @@ -24,9 +24,9 @@ Multiplies a real matrix by the real orthogonal matrix :math:`Q` determined by * - ``double`` The routine multiplies a real matrix :math:`C` by :math:`Q` or :math:`Q^{T}`, -where :math:`Q` is the orthogonal matrix :math:`Q` formed by:ref:`onemkl_lapack_sytrd` +where :math:`Q` is the orthogonal matrix :math:`Q` formed by:ref:`onemath_lapack_sytrd` when reducing a real symmetric matrix :math:`A` to tridiagonal form: -:math:`A = QTQ^T`. Use this routine after a call to :ref:`onemkl_lapack_sytrd`. +:math:`A = QTQ^T`. Use this routine after a call to :ref:`onemath_lapack_sytrd`. Depending on the parameters side and trans, the routine can form one of the matrix products :math:`QC`, :math:`Q^TC`, :math:`CQ`, or @@ -41,8 +41,8 @@ ormtr (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void ormtr(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::uplo upper_lower, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &c, std::int64_t ldc, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void ormtr(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::uplo upper_lower, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &c, std::int64_t ldc, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -76,7 +76,7 @@ side upper_lower Must be either ``uplo::upper`` or ``uplo::lower``. Uses the same ``upper_lower`` as supplied to - :ref:`onemkl_lapack_sytrd`. + :ref:`onemath_lapack_sytrd`. trans Must be either ``transpose::nontrans`` or ``transpose::trans``. @@ -94,13 +94,13 @@ n The number of columns in the matrix :math:`C` :math:`(n \ge 0)`. a - The buffer ``a`` as returned by :ref:`onemkl_lapack_sytrd`. + The buffer ``a`` as returned by :ref:`onemath_lapack_sytrd`. lda The leading dimension of ``a`` :math:`(\text{lda} \ge \max(1, r))`. tau - The buffer ``tau`` as returned by a :ref:`onemkl_lapack_sytrd`. The + The buffer ``tau`` as returned by a :ref:`onemath_lapack_sytrd`. The dimension of ``tau`` must be at least :math:`\max(1, r-1)`. c @@ -112,7 +112,7 @@ ldc scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_ormtr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_ormtr_scratchpad_size` function. .. container:: section @@ -131,17 +131,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -158,8 +158,8 @@ ormtr (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event ormtr(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::uplo upper_lower, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, const T *a, std::int64_t lda, const T *tau, T *c, std::int64_t ldc, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event ormtr(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::uplo upper_lower, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, const T *a, std::int64_t lda, const T *tau, T *c, std::int64_t ldc, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -192,7 +192,7 @@ side upper_lower Must be either ``uplo::upper`` or ``uplo::lower``. Uses the same - ``upper_lower`` as supplied to :ref:`onemkl_lapack_sytrd`. + ``upper_lower`` as supplied to :ref:`onemath_lapack_sytrd`. trans Must be either ``transpose::nontrans`` or ``transpose::trans``. @@ -210,13 +210,13 @@ n The number of columns in the matrix :math:`C` :math:`(n \ge 0)`. a - The pointer to ``a`` as returned by :ref:`onemkl_lapack_sytrd`. + The pointer to ``a`` as returned by :ref:`onemath_lapack_sytrd`. lda The leading dimension of ``a`` :math:`(\text{lda} \ge \max(1, r))`. tau - The buffer ``tau`` as returned by :ref:`onemkl_lapack_sytrd`. The + The buffer ``tau`` as returned by :ref:`onemath_lapack_sytrd`. The dimension of ``tau`` must be at least :math:`\max(1, r-1)`. c @@ -228,7 +228,7 @@ ldc scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_ormtr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_ormtr_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -250,17 +250,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -274,5 +274,5 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/ormtr_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/ormtr_scratchpad_size.rst similarity index 73% rename from source/elements/oneMKL/source/domains/lapack/ormtr_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/ormtr_scratchpad_size.rst index 82f0199045..41d8581ece 100644 --- a/source/elements/oneMKL/source/domains/lapack/ormtr_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/ormtr_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ormtr_scratchpad_size: +.. _onemath_lapack_ormtr_scratchpad_size: ormtr_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_ormtr` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_ormtr` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_ormtr` funct * - ``float`` * - ``double`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_ormtr` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_ormtr` function should be able to hold. Calls to this routine must specify the template parameter explicitly. @@ -35,9 +35,9 @@ ormtr_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t ormtr_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::uplo upper_lower, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t lda, std::int64_t ldc) + std::int64_t ormtr_scratchpad_size(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::uplo upper_lower, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t lda, std::int64_t ldc) } .. container:: section @@ -57,7 +57,7 @@ In the descriptions below, ``r`` denotes the order of :math:`Q`: - if ``side = side::right`` queue - Device queue where calculations by :ref:`onemkl_lapack_ormtr` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_ormtr` function will be performed. side Must be either ``side::left`` or ``side::right``. @@ -71,7 +71,7 @@ side upper_lower Must be either ``uplo::upper`` or ``uplo::lower``. Uses the same ``upper_lower`` as supplied to - :ref:`onemkl_lapack_sytrd`. + :ref:`onemath_lapack_sytrd`. trans Must be either ``transpose::nontrans`` or ``transpose::trans``. @@ -100,11 +100,11 @@ ldc This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -113,8 +113,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_ormtr` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_ormtr` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/potrf.rst b/source/elements/oneMath/source/domains/lapack/potrf.rst similarity index 74% rename from source/elements/oneMKL/source/domains/lapack/potrf.rst rename to source/elements/oneMath/source/domains/lapack/potrf.rst index ac69f1328a..e5c1aec364 100644 --- a/source/elements/oneMKL/source/domains/lapack/potrf.rst +++ b/source/elements/oneMath/source/domains/lapack/potrf.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_potrf: +.. _onemath_lapack_potrf: potrf ===== @@ -33,9 +33,9 @@ matrix :math:`A`: :header-rows: 1 * - :math:`A` = :math:`U^{T}U` for real data, :math:`A = U^{H}U` for complex data - - if upper_lower=\ ``oneapi::mkl::uplo::upper`` + - if upper_lower=\ ``oneapi::math::uplo::upper`` * - :math:`A` = :math:`LL^{T}` for real data, :math:`A = LL^{H}` for complex data - - if upper_lower=\ ``oneapi::mkl::uplo::lower`` + - if upper_lower=\ ``oneapi::math::uplo::lower`` where :math:`L` is a lower triangular matrix and :math:`U` is upper triangular. @@ -49,8 +49,8 @@ potrf (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void potrf(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void potrf(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -64,11 +64,11 @@ upper_lower Indicates whether the upper or lower triangular part of :math:`A` is stored and how :math:`A` is factored: - If upper_lower=\ ``oneapi::mkl::uplo::upper``, the array ``a`` stores the + If upper_lower=\ ``oneapi::math::uplo::upper``, the array ``a`` stores the upper triangular part of the matrix :math:`A`, and the strictly lower triangular part of the matrix is not referenced. - If upper_lower=\ ``oneapi::mkl::uplo::lower``, the array ``a`` stores the + If upper_lower=\ ``oneapi::math::uplo::lower``, the array ``a`` stores the lower triangular part of the matrix :math:`A`, and the strictly upper triangular part of the matrix is not referenced. @@ -86,7 +86,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_potrf_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_potrf_scratchpad_size` function. .. container:: section @@ -105,17 +105,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -137,8 +137,8 @@ potrf (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event potrf(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event potrf(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -152,11 +152,11 @@ upper_lower Indicates whether the upper or lower triangular part of :math:`A` is stored and how :math:`A` is factored: - If upper_lower=\ ``oneapi::mkl::uplo::upper``, the array ``a`` stores the + If upper_lower=\ ``oneapi::math::uplo::upper``, the array ``a`` stores the upper triangular part of the matrix :math:`A`, and the strictly lower triangular part of the matrix is not referenced. - If upper_lower=\ ``oneapi::mkl::uplo::lower``, the array ``a`` stores the + If upper_lower=\ ``oneapi::math::uplo::lower``, the array ``a`` stores the lower triangular part of the matrix :math:`A`, and the strictly upper triangular part of the matrix is not referenced. @@ -174,7 +174,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_potrf_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_potrf_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -196,17 +196,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -225,6 +225,6 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/potrf_batch.rst b/source/elements/oneMath/source/domains/lapack/potrf_batch.rst similarity index 76% rename from source/elements/oneMKL/source/domains/lapack/potrf_batch.rst rename to source/elements/oneMath/source/domains/lapack/potrf_batch.rst index eb1135399f..1db1d881b4 100644 --- a/source/elements/oneMKL/source/domains/lapack/potrf_batch.rst +++ b/source/elements/oneMath/source/domains/lapack/potrf_batch.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_potrf_batch: +.. _onemath_lapack_potrf_batch: potrf_batch =========== @@ -24,7 +24,7 @@ Computes the LU factorizations of a batch of general matrices. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_lapack_potrf_batch_buffer: +.. _onemath_lapack_potrf_batch_buffer: potrf_batch (Buffer Version) ---------------------------- @@ -38,8 +38,8 @@ The buffer version of ``potrf_batch`` supports only the strided API. **Strided API** | The routine forms the Cholesky factorizations of a symmetric positive-definite or, for complex data, Hermitian positive-definite matrices :math:`A_i`, :math:`i \in \{1...batch\_size\}`: - | :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data if ``uplo = mkl::uplo::upper``, - | :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data if ``uplo = mkl::uplo::lower``, + | :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data if ``uplo = math::uplo::upper``, + | :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data if ``uplo = math::uplo::lower``, | where :math:`L_i` is a lower triangular matrix and :math:`U_i` is upper triangular. .. container:: section @@ -48,8 +48,8 @@ The buffer version of ``potrf_batch`` supports only the strided API. .. code-block:: cpp - namespace oneapi::mkl::lapack { - void potrf_batch(cl::sycl::queue &queue, mkl::uplo uplo, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, std::int64_t stride_a, std::int64_t batch_size, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void potrf_batch(cl::sycl::queue &queue, math::uplo uplo, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, std::int64_t stride_a, std::int64_t batch_size, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -61,8 +61,8 @@ queue uplo | Indicates whether the upper or lower triangular part of :math:`A_i` is stored and how :math:`A_i` is factored: - | If ``uplo = mkl::uplo::upper``, the array ``a`` stores the upper triangular parts of the matrices :math:`A_i`, - | If ``uplo = mkl::uplo::lower``, the array ``a`` stores the lower triangular parts of the matrices :math:`A_i`. + | If ``uplo = math::uplo::upper``, the array ``a`` stores the upper triangular parts of the matrices :math:`A_i`, + | If ``uplo = math::uplo::lower``, the array ``a`` stores the lower triangular parts of the matrices :math:`A_i`. n Order of the matrices :math:`A_i`, (:math:`0 \le n`). @@ -83,7 +83,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemkl_lapack_potrf_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemath_lapack_potrf_batch_scratchpad_size` function. .. container:: section @@ -98,13 +98,13 @@ a This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -116,7 +116,7 @@ This routine shall throw the following exceptions if the associated condition is If ``info`` is zero, then the leading minors of some of matrices (and therefore some matrices :math:`A_i` themselves) are not positive-definite, and the factorizations could not be completed for these matrices from the batch. The indices of such matrices in the batch can be obtained with `ids()` method of the exception object. The orders of corresponding not positive-definite leading minors of these matrices can be obtained by `exceptions()` method of exception object. -.. _onemkl_lapack_potrf_batch_usm: +.. _onemath_lapack_potrf_batch_usm: potrf_batch (USM Version) ------------------------- @@ -130,8 +130,8 @@ The USM version of ``potrf_batch`` supports the group API and strided API. **Group API** | The routine forms the Cholesky factorizations of symmetric positive-definite or, for complex data, Hermitian positive-definite matrices :math:`A_i`, :math:`i \in \{1...batch\_size\}`: - | :math:`A_i = U_i^TU_i` for real data (:math:`A_i = U_i^HU_i` for complex), if :math:`\text{uplo}_g` is ``mkl::uplo::upper``, - | :math:`A_i = L_iL_i^T` for real data (:math:`A_i = L_iL_i^H` for complex), if :math:`\text{uplo}_g` is ``mkl::uplo::lower``, + | :math:`A_i = U_i^TU_i` for real data (:math:`A_i = U_i^HU_i` for complex), if :math:`\text{uplo}_g` is ``math::uplo::upper``, + | :math:`A_i = L_iL_i^T` for real data (:math:`A_i = L_iL_i^H` for complex), if :math:`\text{uplo}_g` is ``math::uplo::lower``, | where :math:`L_i` is a lower triangular matrix and :math:`U_i` is upper triangular, :math:`g` is an index of group of parameters corresponding to :math:`A_i`, and total number of problems to solve, ``batch_size``, is a sum of sizes of all of the groups of parameters as provided by ``group_sizes`` array .. container:: section @@ -140,8 +140,8 @@ The USM version of ``potrf_batch`` supports the group API and strided API. .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event potrf_batch(cl::sycl::queue &queue, mkl::uplo *uplo, std::int64_t *n, T **a, std::int64_t *lda, std::int64_t group_count, std::int64_t *group_sizes, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event potrf_batch(cl::sycl::queue &queue, math::uplo *uplo, std::int64_t *n, T **a, std::int64_t *lda, std::int64_t group_count, std::int64_t *group_sizes, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -153,8 +153,8 @@ queue uplo | Array of ``group_count`` :math:`\text{uplo}_g` parameters. Each :math:`\text{uplo}_g` indicates whether the upper or lower triangular parts of the input matrices are provided: - | If :math:`\text{uplo}_g` is ``mkl::uplo::upper``, input matrices from array ``a`` belonging to group :math:`g` store the upper triangular parts, - | If :math:`\text{uplo}_g` is ``mkl::uplo::lower``, input matrices from array ``a`` belonging to group :math:`g` store the lower triangular parts. + | If :math:`\text{uplo}_g` is ``math::uplo::upper``, input matrices from array ``a`` belonging to group :math:`g` store the upper triangular parts, + | If :math:`\text{uplo}_g` is ``math::uplo::lower``, input matrices from array ``a`` belonging to group :math:`g` store the lower triangular parts. n Array of ``group_count`` :math:`n_g` parameters. Each :math:`n_g` specifies the order of the input matrices from array a belonging to group :math:`g`. @@ -175,7 +175,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Group API of the :ref:`onemkl_lapack_potrf_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Group API of the :ref:`onemath_lapack_potrf_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -200,13 +200,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -221,8 +221,8 @@ This routine shall throw the following exceptions if the associated condition is **Strided API** | The routine forms the Cholesky factorizations of a symmetric positive-definite or, for complex data, Hermitian positive-definite matrices :math:`A_i`, :math:`i \in \{1...batch\_size\}`: - | :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data if ``uplo = mkl::uplo::upper``, - | :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data if ``uplo = mkl::uplo::lower``, + | :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data if ``uplo = math::uplo::upper``, + | :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data if ``uplo = math::uplo::lower``, | where :math:`L_i` is a lower triangular matrix and :math:`U_i` is upper triangular. .. container:: section @@ -231,8 +231,8 @@ This routine shall throw the following exceptions if the associated condition is .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event potrf_batch(cl::sycl::queue &queue, mkl::uplo uplo, std::int64_t n, T *a, std::int64_t lda, std::int64_t stride_a, std::int64_t batch_size, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event potrf_batch(cl::sycl::queue &queue, math::uplo uplo, std::int64_t n, T *a, std::int64_t lda, std::int64_t stride_a, std::int64_t batch_size, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) }; .. container:: section @@ -244,8 +244,8 @@ queue uplo | Indicates whether the upper or lower triangular part of :math:`A_i` is stored and how :math:`A_i` is factored: - | If ``uplo = mkl::uplo::upper``, the array ``a`` stores the upper triangular parts of the matrices :math:`A_i`, - | If ``uplo = mkl::uplo::lower``, the array ``a`` stores the lower triangular parts of the matrices :math:`A_i`. + | If ``uplo = math::uplo::upper``, the array ``a`` stores the upper triangular parts of the matrices :math:`A_i`, + | If ``uplo = math::uplo::lower``, the array ``a`` stores the lower triangular parts of the matrices :math:`A_i`. n Order of the matrices :math:`A_i`, (:math:`0 \le n`). @@ -266,7 +266,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemkl_lapack_potrf_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemath_lapack_potrf_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -290,13 +290,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -308,5 +308,5 @@ This routine shall throw the following exceptions if the associated condition is If ``info`` is zero, then the leading minors of some of matrices (and therefore some matrices :math:`A_i` themselves) are not positive-definite, and the factorizations could not be completed for these matrices from the batch. The indices of such matrices in the batch can be obtained with `ids()` method of the exception object. The orders of corresponding not positive-definite leading minors of these matrices can be obtained by `exceptions()` method of exception object. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/potrf_batch_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/potrf_batch_scratchpad_size.rst similarity index 66% rename from source/elements/oneMKL/source/domains/lapack/potrf_batch_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/potrf_batch_scratchpad_size.rst index dc4d4a36a7..cc2d43a61f 100644 --- a/source/elements/oneMKL/source/domains/lapack/potrf_batch_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/potrf_batch_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_potrf_batch_scratchpad_size: +.. _onemath_lapack_potrf_batch_scratchpad_size: potrf_batch_scratchpad_size =========================== -Computes size of scratchpad memory required for the :ref:`onemkl_lapack_potrf_batch` function. +Computes size of scratchpad memory required for the :ref:`onemath_lapack_potrf_batch` function. .. container:: section @@ -26,7 +26,7 @@ Computes size of scratchpad memory required for the :ref:`onemkl_lapack_potrf_ba **Group API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_potrf_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_potrf_batch` function. .. container:: section @@ -34,9 +34,9 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t potrf_batch_scratchpad_size(cl::sycl::queue &queue, mkl::uplo *uplo, std::int64_t *n, std::int64_t *lda, std::int64_t group_count, std::int64_t *group_sizes) + std::int64_t potrf_batch_scratchpad_size(cl::sycl::queue &queue, math::uplo *uplo, std::int64_t *n, std::int64_t *lda, std::int64_t group_count, std::int64_t *group_sizes) } .. container:: section @@ -49,8 +49,8 @@ queue uplo | Array of ``group_count`` :math:`\text{uplo}_g` parameters. | Each of :math:`\text{uplo}_g` indicates whether the upper or lower triangular parts of the input matrices are provided: - | If :math:`\text{uplo}_g` is ``mkl::uplo::upper``, input matrices from array ``a`` belonging to group :math:`g` store the upper triangular parts, - | If :math:`\text{uplo}_g` is ``mkl::uplo::lower``, input matrices from array ``a`` belonging to group :math:`g` store the lower triangular parts. + | If :math:`\text{uplo}_g` is ``math::uplo::upper``, input matrices from array ``a`` belonging to group :math:`g` store the upper triangular parts, + | If :math:`\text{uplo}_g` is ``math::uplo::lower``, input matrices from array ``a`` belonging to group :math:`g` store the lower triangular parts. n | Array of ``group_count`` :math:`n_g` parameters. @@ -70,7 +70,7 @@ group_sizes .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_potrf_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_potrf_batch` function. .. container:: section @@ -78,18 +78,18 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. **Strided API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_potrf_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_potrf_batch` function. .. container:: section @@ -97,9 +97,9 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t potrf_batch_scratchpad_size(cl::sycl::queue &queue, mkl::uplo uplo, std::int64_t n, std::int64_t lda, std::int64_t stride_a, std::int64_t batch_size) + std::int64_t potrf_batch_scratchpad_size(cl::sycl::queue &queue, math::uplo uplo, std::int64_t n, std::int64_t lda, std::int64_t stride_a, std::int64_t batch_size) }; .. container:: section @@ -110,8 +110,8 @@ queue Device queue where calculations will be performed. uplo | Indicates whether the upper or lower triangular part of :math:`A_i` is stored and how :math:`A_i` is factored: - | If ``uplo = mkl::uplo::upper``, the array ``a`` stores the upper triangular parts of the matrices :math:`A_i`, - | If ``uplo = mkl::uplo::lower``, the array ``a`` stores the lower triangular parts of the matrices :math:`A_i`. + | If ``uplo = math::uplo::upper``, the array ``a`` stores the upper triangular parts of the matrices :math:`A_i`, + | If ``uplo = math::uplo::lower``, the array ``a`` stores the lower triangular parts of the matrices :math:`A_i`. n Order of the matrices :math:`A_i`, (:math:`0 \le n`). @@ -129,7 +129,7 @@ batch_size .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_potrf_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_potrf_batch` function. .. container:: section @@ -137,14 +137,14 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/potrf_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/potrf_scratchpad_size.rst similarity index 67% rename from source/elements/oneMKL/source/domains/lapack/potrf_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/potrf_scratchpad_size.rst index 4da1de83d0..02ffa96371 100644 --- a/source/elements/oneMKL/source/domains/lapack/potrf_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/potrf_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_potrf_scratchpad_size: +.. _onemath_lapack_potrf_scratchpad_size: potrf_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_potrf` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_potrf` function. .. container:: section @@ -24,7 +24,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_potrf` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_potrf` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_potrf` function should be able to hold. Calls to this routine must specify the template parameter explicitly. potrf_scratchpad_size @@ -36,9 +36,9 @@ potrf_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t potrf_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t lda) + std::int64_t potrf_scratchpad_size(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t lda) } .. container:: section @@ -46,17 +46,17 @@ potrf_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_potrf` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_potrf` function will be performed. upper_lower Indicates whether the upper or lower triangular part of :math:`A` is stored and how :math:`A` is factored: - If ``upper_lower = oneapi::mkl::uplo::upper``, the array ``a`` stores the + If ``upper_lower = oneapi::math::uplo::upper``, the array ``a`` stores the upper triangular part of the matrix :math:`A`, and the strictly lower triangular part of the matrix is not referenced. - If ``upper_lower = oneapi::mkl::uplo::lower``, the array ``a`` stores the + If ``upper_lower = oneapi::math::uplo::lower``, the array ``a`` stores the lower triangular part of the matrix :math:`A`, and the strictly upper triangular part of the matrix is not referenced. @@ -72,11 +72,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -85,8 +85,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_potrf` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_potrf` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/potri.rst b/source/elements/oneMath/source/domains/lapack/potri.rst similarity index 66% rename from source/elements/oneMKL/source/domains/lapack/potri.rst rename to source/elements/oneMath/source/domains/lapack/potri.rst index 377c390888..d7b3db3f7a 100644 --- a/source/elements/oneMKL/source/domains/lapack/potri.rst +++ b/source/elements/oneMath/source/domains/lapack/potri.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_potri: +.. _onemath_lapack_potri: potri ===== @@ -27,7 +27,7 @@ matrix using the Cholesky factorization. The routine computes the inverse :math:`A^{-1}` of a symmetric positive definite or, for complex flavors, Hermitian positive-definite matrix -:math:`A`. Before calling this routine, call :ref:`onemkl_lapack_potrf` +:math:`A`. Before calling this routine, call :ref:`onemath_lapack_potrf` to factorize :math:`A`. potri (Buffer Version) @@ -39,8 +39,8 @@ potri (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void potri(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void potri(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -53,22 +53,22 @@ queue upper_lower Indicates how the input matrix :math:`A` has been factored: - If ``upper_lower = oneapi::mkl::uplo::upper``, the upper triangle of :math:`A` is stored. + If ``upper_lower = oneapi::math::uplo::upper``, the upper triangle of :math:`A` is stored. - If ``upper_lower = oneapi::mkl::uplo::lower``, the lower triangle of :math:`A` is stored. + If ``upper_lower = oneapi::math::uplo::lower``, the lower triangle of :math:`A` is stored. n Specifies the order of the matrix :math:`A` (:math:`0 \le n`). a - Contains the factorization of the matrix :math:`A`, as returned by :ref:`onemkl_lapack_potrf`. The second dimension of ``a`` must be at least :math:`\max(1, n)`. + Contains the factorization of the matrix :math:`A`, as returned by :ref:`onemath_lapack_potrf`. The second dimension of ``a`` must be at least :math:`\max(1, n)`. lda The leading dimension of ``a``. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_potri_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_potri_scratchpad_size` function. .. container:: section @@ -86,17 +86,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -116,8 +116,8 @@ potri (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event potri(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event potri(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -130,22 +130,22 @@ queue upper_lower Indicates how the input matrix :math:`A` has been factored: - If ``upper_lower = oneapi::mkl::uplo::upper``, the upper triangle of :math:`A` is stored. + If ``upper_lower = oneapi::math::uplo::upper``, the upper triangle of :math:`A` is stored. - If ``upper_lower = oneapi::mkl::uplo::lower``, the lower triangle of :math:`A` is stored. + If ``upper_lower = oneapi::math::uplo::lower``, the lower triangle of :math:`A` is stored. n Specifies the order of the matrix :math:`A` (:math:`0 \le n`). a - Contains the factorization of the matrix :math:`A`, as returned by :ref:`onemkl_lapack_potrf`. The second dimension of ``a`` must be at least :math:`\max(1, n)`. + Contains the factorization of the matrix :math:`A`, as returned by :ref:`onemath_lapack_potrf`. The second dimension of ``a`` must be at least :math:`\max(1, n)`. lda The leading dimension of ``a``. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_potri_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_potri_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -166,17 +166,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -193,6 +193,6 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/potri_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/potri_scratchpad_size.rst similarity index 62% rename from source/elements/oneMKL/source/domains/lapack/potri_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/potri_scratchpad_size.rst index 1dbd9f2d05..0d790a5fba 100644 --- a/source/elements/oneMKL/source/domains/lapack/potri_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/potri_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_potri_scratchpad_size: +.. _onemath_lapack_potri_scratchpad_size: potri_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_potri` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_potri` function. .. container:: section @@ -24,7 +24,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_potri` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_potri` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_potri` function should be able to hold. Calls to this routine must specify the template parameter explicitly. potri_scratchpad_size @@ -36,9 +36,9 @@ potri_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t potri_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t lda) + std::int64_t potri_scratchpad_size(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t lda) } .. container:: section @@ -46,14 +46,14 @@ potri_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_potri` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_potri` function will be performed. upper_lower Indicates how the input matrix :math:`A` has been factored: - If ``upper_lower = oneapi::mkl::uplo::upper``, the upper triangle of :math:`A` is stored. + If ``upper_lower = oneapi::math::uplo::upper``, the upper triangle of :math:`A` is stored. - If ``upper_lower = oneapi::mkl::uplo::lower``, the lower triangle of :math:`A` is stored. + If ``upper_lower = oneapi::math::uplo::lower``, the lower triangle of :math:`A` is stored. n Specifies the order of the matrix :math:`A` (:math:`0 \le n`). @@ -67,11 +67,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -80,7 +80,7 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_potri` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_potri` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/potrs.rst b/source/elements/oneMath/source/domains/lapack/potrs.rst similarity index 64% rename from source/elements/oneMKL/source/domains/lapack/potrs.rst rename to source/elements/oneMath/source/domains/lapack/potrs.rst index d92dcdfe98..e95483ae57 100644 --- a/source/elements/oneMKL/source/domains/lapack/potrs.rst +++ b/source/elements/oneMath/source/domains/lapack/potrs.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_potrs: +.. _onemath_lapack_potrs: potrs ===== @@ -34,15 +34,15 @@ factorization of :math:`A`: :header-rows: 1 * - :math:`A = U^TU` for real data, :math:`A = U^HU` for complex data - - if ``upper_lower=oneapi::mkl::uplo::upper`` + - if ``upper_lower=oneapi::math::uplo::upper`` * - :math:`A = LL^T` for real data, :math:`A = LL^H` for complex data - - if ``upper_lower=oneapi::mkl::uplo::lower`` + - if ``upper_lower=oneapi::math::uplo::lower`` where :math:`L` is a lower triangular matrix and :math:`U` is upper triangular. The system is solved with multiple right-hand sides stored in the columns of the matrix :math:`B`. -Before calling this routine, you must call :ref:`onemkl_lapack_potrf` to compute +Before calling this routine, you must call :ref:`onemath_lapack_potrf` to compute the Cholesky factorization of :math:`A`. potrs (Buffer Version) @@ -54,8 +54,8 @@ potrs (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void potrs(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t nrhs, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &b, std::int64_t ldb, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void potrs(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t nrhs, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &b, std::int64_t ldb, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -68,9 +68,9 @@ queue upper_lower Indicates how the input matrix has been factored: - If ``upper_lower = oneapi::mkl::uplo::upper``, the upper triangle :math:`U` of :math:`A` is stored, where :math:`A` = :math:`U^{T}`U` for real data, :math:`A` = :math:`U^{H}U` for complex data. + If ``upper_lower = oneapi::math::uplo::upper``, the upper triangle :math:`U` of :math:`A` is stored, where :math:`A` = :math:`U^{T}`U` for real data, :math:`A` = :math:`U^{H}U` for complex data. - If ``upper_lower = oneapi::mkl::uplo::lower``, the lower triangle :math:`L` of :math:`A` is stored, where :math:`A` = :math:`LL^{T}` for real data, :math:`A` = :math:`LL^{H}` for complex data. + If ``upper_lower = oneapi::math::uplo::lower``, the lower triangle :math:`L` of :math:`A` is stored, where :math:`A` = :math:`LL^{T}` for real data, :math:`A` = :math:`LL^{H}` for complex data. n The order of matrix :math:`A` (:math:`0 \le n`).\ @@ -79,7 +79,7 @@ nrhs The number of right-hand sides (:math:`0 \le \text{nrhs}`). a - Buffer containing the factorization of the matrix A, as returned by :ref:`onemkl_lapack_potrf`. The second dimension of ``a`` must be at least :math:`\max(1, n)`. + Buffer containing the factorization of the matrix A, as returned by :ref:`onemath_lapack_potrf`. The second dimension of ``a`` must be at least :math:`\max(1, n)`. lda The leading dimension of ``a``. @@ -92,7 +92,7 @@ ldb scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_potrs_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_potrs_scratchpad_size` function. .. container:: section @@ -110,17 +110,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -139,8 +139,8 @@ potrs (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event potrs(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t nrhs, const T *a, std::int64_t lda, T *b, std::int64_t ldb, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event potrs(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t nrhs, const T *a, std::int64_t lda, T *b, std::int64_t ldb, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -153,9 +153,9 @@ queue upper_lower Indicates how the input matrix has been factored: - If ``upper_lower = oneapi::mkl::uplo::upper``, the upper triangle :math:`U` of :math:`A` is stored, where :math:`A` = :math:`U^{T}U` for real data, :math:`A` = :math:`U^{H}U` for complex data. + If ``upper_lower = oneapi::math::uplo::upper``, the upper triangle :math:`U` of :math:`A` is stored, where :math:`A` = :math:`U^{T}U` for real data, :math:`A` = :math:`U^{H}U` for complex data. - If ``upper_lower = oneapi::mkl::uplo::lower``, the lower triangle :math:`L` of :math:`A` is stored, where :math:`A` = :math:`LL^{T}` for real data, :math:`A` = :math:`LL^{H}` for complex data. + If ``upper_lower = oneapi::math::uplo::lower``, the lower triangle :math:`L` of :math:`A` is stored, where :math:`A` = :math:`LL^{T}` for real data, :math:`A` = :math:`LL^{H}` for complex data. n The order of matrix :math:`A` (:math:`0 \le n`).\ @@ -164,7 +164,7 @@ nrhs The number of right-hand sides (:math:`0 \le \text{nrhs}`). a - Pointer to array containing the factorization of the matrix :math:`A`, as returned by :ref:`onemkl_lapack_potrf`. The second dimension of ``a`` must be at least :math:`\max(1, n)`. + Pointer to array containing the factorization of the matrix :math:`A`, as returned by :ref:`onemath_lapack_potrf`. The second dimension of ``a`` must be at least :math:`\max(1, n)`. lda The leading dimension of ``a``. @@ -177,7 +177,7 @@ ldb scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_potrs_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_potrs_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -198,17 +198,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -224,6 +224,6 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/potrs_batch.rst b/source/elements/oneMath/source/domains/lapack/potrs_batch.rst similarity index 72% rename from source/elements/oneMKL/source/domains/lapack/potrs_batch.rst rename to source/elements/oneMath/source/domains/lapack/potrs_batch.rst index bd44e01175..2a31b772ed 100644 --- a/source/elements/oneMKL/source/domains/lapack/potrs_batch.rst +++ b/source/elements/oneMath/source/domains/lapack/potrs_batch.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_potrs_batch: +.. _onemath_lapack_potrs_batch: potrs_batch =========== @@ -24,7 +24,7 @@ Computes the LU factorizations of a batch of general matrices. * - ``std::complex`` * - ``std::complex`` -.. _onemkl_lapack_potrs_batch_buffer: +.. _onemath_lapack_potrs_batch_buffer: potrs_batch (Buffer Version) ---------------------------- @@ -38,11 +38,11 @@ The buffer version of ``potrs_batch`` supports only the strided API. **Strided API** | The routine solves for :math:`X_i` the systems of linear equations :math:`A_iX_i = B_i` with a symmetric positive-definite or, for complex data, Hermitian positive-definite matrices :math:`A_i`, given the Cholesky factorization of :math:`A_i`, :math:`i \in \{1...batch\_size\}`: - | :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data if ``uplo = mkl::uplo::upper``, - | :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data if ``uplo = mkl::uplo::lower``, + | :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data if ``uplo = math::uplo::upper``, + | :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data if ``uplo = math::uplo::lower``, | where :math:`L_i` is a lower triangular matrix and :math:`U_i` is upper triangular. | The systems are solved with multiple right-hand sides stored in the columns of the matrices :math:`B_i`. - | Before calling this routine, matrices :math:`A_i` should be factorized by call to the Strided API of the :ref:`onemkl_lapack_potrf_batch_buffer` function. + | Before calling this routine, matrices :math:`A_i` should be factorized by call to the Strided API of the :ref:`onemath_lapack_potrf_batch_buffer` function. .. container:: section @@ -50,8 +50,8 @@ The buffer version of ``potrs_batch`` supports only the strided API. .. code-block:: cpp - namespace oneapi::mkl::lapack { - void potrs_batch(cl::sycl::queue &queue, mkl::uplo uplo, std::int64_t n, std::int64_t nrhs, cl::sycl::buffer &a, std::int64_t lda, std::int64_t stride_a, cl::sycl::buffer &b, std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void potrs_batch(cl::sycl::queue &queue, math::uplo uplo, std::int64_t n, std::int64_t nrhs, cl::sycl::buffer &a, std::int64_t lda, std::int64_t stride_a, cl::sycl::buffer &b, std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -63,8 +63,8 @@ queue uplo | Indicates how the input matrices have been factored: - | If ``uplo = mkl::uplo::upper``, the upper triangle :math:`U_i` of :math:`A_i` is stored, where :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data. - | If ``uplo = mkl::uplo::lower``, the upper triangle :math:`L_i` of :math:`A_i` is stored, where :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data. + | If ``uplo = math::uplo::upper``, the upper triangle :math:`U_i` of :math:`A_i` is stored, where :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data. + | If ``uplo = math::uplo::lower``, the upper triangle :math:`L_i` of :math:`A_i` is stored, where :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data. n The order of matrices :math:`A_i` (:math:`0 \le n`). @@ -73,7 +73,7 @@ nrhs The number of right-hand sides (:math:`0 \le \text{nrhs}`). a - Array containing batch of factorizations of the matrices :math:`A_i`, as returned by the Strided API of the :ref:`onemkl_lapack_potrf_batch_buffer` function. + Array containing batch of factorizations of the matrices :math:`A_i`, as returned by the Strided API of the :ref:`onemath_lapack_potrf_batch_buffer` function. lda Leading dimension of :math:`A_i`. @@ -97,7 +97,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemkl_lapack_potrs_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemath_lapack_potrs_batch_scratchpad_size` function. .. container:: section @@ -112,13 +112,13 @@ b This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -130,7 +130,7 @@ This routine shall throw the following exceptions if the associated condition is If ``info`` is zero, then for some of the matrices diagonal element of the Cholesky factor is zero, and the solve could not be completed. The indices of such matrices in the batch can be obtained with `ids()` method of the exception object. The indices of first zero diagonal elements in these matrices can be obtained by `exceptions()` method of exception object. -.. _onemkl_lapack_potrs_batch_usm: +.. _onemath_lapack_potrs_batch_usm: potrs_batch (USM Version) ------------------------- @@ -149,8 +149,8 @@ The USM version of ``potrs_batch`` supports the group API and strided API. .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event potrs_batch(cl::sycl::queue &queue, mkl::uplo *uplo, std::int64_t *n, std::int64_t *nrhs, const T * const *a, std::int64_t *lda, T **b, std::int64_t *ldb, std::int64_t group_count, std::int64_t *group_sizes, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event potrs_batch(cl::sycl::queue &queue, math::uplo *uplo, std::int64_t *n, std::int64_t *nrhs, const T * const *a, std::int64_t *lda, T **b, std::int64_t *ldb, std::int64_t group_count, std::int64_t *group_sizes, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -163,8 +163,8 @@ queue uplo | Array of ``group_count`` :math:`\text{uplo}_g` parameters. | Each of :math:`\text{uplo}_g` indicates whether the upper or lower triangular parts of the input matrices are provided: - | If :math:`\text{uplo}_g` is ``mkl::uplo::upper``, input matrices from array ``a`` belonging to group :math:`g` store the upper triangular parts, - | If :math:`\text{uplo}_g` is ``mkl::uplo::lower``, input matrices from array ``a`` belonging to group :math:`g` store the lower triangular parts. + | If :math:`\text{uplo}_g` is ``math::uplo::upper``, input matrices from array ``a`` belonging to group :math:`g` store the upper triangular parts, + | If :math:`\text{uplo}_g` is ``math::uplo::lower``, input matrices from array ``a`` belonging to group :math:`g` store the lower triangular parts. n | Array of ``group_count`` :math:`n_g` parameters. @@ -175,7 +175,7 @@ nrhs | Each :math:`\text{nrhs}_g` specifies the number of right-hand sides supplied for group :math:`g` in corresponding part of array ``b``. a - Array of ``batch_size`` pointers to Cholesky factored matrices :math:`A_i` as returned by the Group API of the :ref:`onemkl_lapack_potrf_batch_usm` function. + Array of ``batch_size`` pointers to Cholesky factored matrices :math:`A_i` as returned by the Group API of the :ref:`onemath_lapack_potrf_batch_usm` function. lda | Array of ``group_count`` :math:`\text{lda}_g` parameters. @@ -198,7 +198,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Group API of the :ref:`onemkl_lapack_potrs_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Group API of the :ref:`onemath_lapack_potrs_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -222,13 +222,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -243,11 +243,11 @@ This routine shall throw the following exceptions if the associated condition is **Strided API** | The routine solves for :math:`X_i` the systems of linear equations :math:`A_iX_i = B_i` with a symmetric positive-definite or, for complex data, Hermitian positive-definite matrices :math:`A_i`, given the Cholesky factorization of :math:`A_i`, :math:`i \in \{1...batch\_size\}`: - | :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data if ``uplo = mkl::uplo::upper``, - | :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data if ``uplo = mkl::uplo::lower``, + | :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data if ``uplo = math::uplo::upper``, + | :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data if ``uplo = math::uplo::lower``, | where :math:`L_i` is a lower triangular matrix and :math:`U_i` is upper triangular. | The systems are solved with multiple right-hand sides stored in the columns of the matrices :math:`B_i`. - | Before calling this routine, matrices :math:`A_i` should be factorized by call to the Strided API of the :ref:`onemkl_lapack_potrf_batch_usm` function. + | Before calling this routine, matrices :math:`A_i` should be factorized by call to the Strided API of the :ref:`onemath_lapack_potrf_batch_usm` function. .. container:: section @@ -255,8 +255,8 @@ This routine shall throw the following exceptions if the associated condition is .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event potrs_batch(cl::sycl::queue &queue, mkl::uplo uplo, std::int64_t n, std::int64_t nrhs, const T *a, std::int64_t lda, std::int64_t stride_a, T *b, std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event potrs_batch(cl::sycl::queue &queue, math::uplo uplo, std::int64_t n, std::int64_t nrhs, const T *a, std::int64_t lda, std::int64_t stride_a, T *b, std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) }; .. container:: section @@ -268,8 +268,8 @@ queue uplo | Indicates how the input matrices have been factored: - | If ``uplo = mkl::uplo::upper``, the upper triangle :math:`U_i` of :math:`A_i` is stored, where :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data. - | If ``uplo = mkl::uplo::lower``, the upper triangle :math:`L_i` of :math:`A_i` is stored, where :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data. + | If ``uplo = math::uplo::upper``, the upper triangle :math:`U_i` of :math:`A_i` is stored, where :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data. + | If ``uplo = math::uplo::lower``, the upper triangle :math:`L_i` of :math:`A_i` is stored, where :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data. n The order of matrices :math:`A_i` (:math:`0 \le n`). @@ -278,7 +278,7 @@ nrhs The number of right-hand sides (:math:`0 \le nrhs`). a - Array containing batch of factorizations of the matrices :math:`A_i`, as returned by the Strided API of the :ref:`onemkl_lapack_potrf_batch_usm` function. + Array containing batch of factorizations of the matrices :math:`A_i`, as returned by the Strided API of the :ref:`onemath_lapack_potrf_batch_usm` function. lda Leading dimension of :math:`A_i`. @@ -302,7 +302,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemkl_lapack_potrs_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by the Strided API of the :ref:`onemath_lapack_potrs_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -326,13 +326,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of problems during calculations. The info code of the problem can be obtained by `info()` method of exception object: @@ -344,5 +344,5 @@ This routine shall throw the following exceptions if the associated condition is If ``info`` is zero, then for some of the matrices diagonal element of the Cholesky factor is zero, and the solve could not be completed. The indices of such matrices in the batch can be obtained with `ids()` method of the exception object. The indices of first zero diagonal elements in these matrices can be obtained by `exceptions()` method of exception object. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/potrs_batch_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/potrs_batch_scratchpad_size.rst similarity index 67% rename from source/elements/oneMKL/source/domains/lapack/potrs_batch_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/potrs_batch_scratchpad_size.rst index 9fd0789158..19659a6507 100644 --- a/source/elements/oneMKL/source/domains/lapack/potrs_batch_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/potrs_batch_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_potrs_batch_scratchpad_size: +.. _onemath_lapack_potrs_batch_scratchpad_size: potrs_batch_scratchpad_size =========================== -Computes size of scratchpad memory required for the :ref:`onemkl_lapack_potrs_batch` function. +Computes size of scratchpad memory required for the :ref:`onemath_lapack_potrs_batch` function. .. container:: section @@ -26,7 +26,7 @@ Computes size of scratchpad memory required for the :ref:`onemkl_lapack_potrs_ba **Group API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_potrs_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_potrs_batch` function. .. container:: section @@ -34,9 +34,9 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t potrs_batch_scratchpad_size(cl::sycl::queue &queue, mkl::uplo *uplo, std::int64_t *n, std::int64_t *nrhs, std::int64_t *lda, std::int64_t *ldb, std::int64_t group_count, std::int64_t *group_sizes) + std::int64_t potrs_batch_scratchpad_size(cl::sycl::queue &queue, math::uplo *uplo, std::int64_t *n, std::int64_t *nrhs, std::int64_t *lda, std::int64_t *ldb, std::int64_t group_count, std::int64_t *group_sizes) } .. container:: section @@ -49,8 +49,8 @@ queue uplo | Array of ``group_count`` :math:`\text{uplo}_g` parameters. | Each of :math:`\text{uplo}_g` indicates whether the upper or lower triangular parts of the input matrices are provided: - | If :math:`\text{uplo}_g` is ``mkl::uplo::upper``, input matrices from array ``a`` belonging to group :math:`g` store the upper triangular parts, - | If :math:`\text{uplo}_g` is ``mkl::uplo::lower``, input matrices from array ``a`` belonging to group :math:`g` store the lower triangular parts. + | If :math:`\text{uplo}_g` is ``math::uplo::upper``, input matrices from array ``a`` belonging to group :math:`g` store the upper triangular parts, + | If :math:`\text{uplo}_g` is ``math::uplo::lower``, input matrices from array ``a`` belonging to group :math:`g` store the lower triangular parts. n | Array of ``group_count`` :math:`n_g` parameters. @@ -77,7 +77,7 @@ group_sizes Array of group_count integers. Array element with index :math:`g` sp .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_potrs_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_potrs_batch` function. .. container:: section @@ -85,18 +85,18 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. **Strided API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_potrs_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_potrs_batch` function. .. container:: section @@ -104,9 +104,9 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t potrs_batch_scratchpad_size(cl::sycl::queue &queue, mkl::uplo uplo, std::int64_t n, std::int64_t nrhs, std::int64_t lda, std::int64_t stride_a, std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size) + std::int64_t potrs_batch_scratchpad_size(cl::sycl::queue &queue, math::uplo uplo, std::int64_t n, std::int64_t nrhs, std::int64_t lda, std::int64_t stride_a, std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size) }; .. container:: section @@ -117,8 +117,8 @@ queue Device queue where calculations will be performed. uplo | Indicates how the input matrices have been factored: - | If ``uplo = mkl::uplo::upper``, the upper triangle :math:`U_i` of :math:`A_i` is stored, where :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data. - | If ``uplo = mkl::uplo::lower``, the upper triangle :math:`L_i` of :math:`A_i` is stored, where :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data. + | If ``uplo = math::uplo::upper``, the upper triangle :math:`U_i` of :math:`A_i` is stored, where :math:`A_i = U_i^TU_i` for real data, :math:`A_i = U_i^HU_i` for complex data. + | If ``uplo = math::uplo::lower``, the upper triangle :math:`L_i` of :math:`A_i` is stored, where :math:`A_i = L_iL_i^T` for real data, :math:`A_i = L_iL_i^H` for complex data. n Order of matrices :math:`A_i` (:math:`0 \le n`). @@ -145,7 +145,7 @@ batch_size .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_potrs_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_potrs_batch` function. .. container:: section @@ -153,14 +153,14 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/potrs_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/potrs_scratchpad_size.rst similarity index 58% rename from source/elements/oneMKL/source/domains/lapack/potrs_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/potrs_scratchpad_size.rst index 99e0553cf8..eafb7d4ff6 100644 --- a/source/elements/oneMKL/source/domains/lapack/potrs_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/potrs_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_potrs_scratchpad_size: +.. _onemath_lapack_potrs_scratchpad_size: potrs_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_potrs` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_potrs` function. .. container:: section @@ -24,7 +24,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_potrs` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_potrs` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_potrs` function should be able to hold. Calls to this routine must specify the template parameter explicitly. potrs_scratchpad_size @@ -36,9 +36,9 @@ potrs_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t potrs_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t nrhs, std::int64_t lda, std::int64_t ldb) + std::int64_t potrs_scratchpad_size(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t nrhs, std::int64_t lda, std::int64_t ldb) } .. container:: section @@ -46,14 +46,14 @@ potrs_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_potrs` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_potrs` function will be performed. upper_lower Indicates how the input matrix has been factored: - If ``upper_lower = oneapi::mkl::uplo::upper``, the upper triangle :math:`U` of :math:`A` is stored, where :math:`A = U^{T}U` for real data, :math:`A = U^{H}U` for complex data. + If ``upper_lower = oneapi::math::uplo::upper``, the upper triangle :math:`U` of :math:`A` is stored, where :math:`A = U^{T}U` for real data, :math:`A = U^{H}U` for complex data. - If ``upper_lower = oneapi::mkl::uplo::lower``, the lower triangle :math:`L` of :math:`A` is stored, where :math:`A = LL^{T}` for real data, :math:`A = LL^{H}` for complex data. + If ``upper_lower = oneapi::math::uplo::lower``, the lower triangle :math:`L` of :math:`A` is stored, where :math:`A = LL^{T}` for real data, :math:`A = LL^{H}` for complex data. n The order of matrix :math:`A` (:math:`0 \le n`). @@ -73,11 +73,11 @@ ldb This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -86,7 +86,7 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_potrs` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_potrs` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/syevd.rst b/source/elements/oneMath/source/domains/lapack/syevd.rst similarity index 77% rename from source/elements/oneMKL/source/domains/lapack/syevd.rst rename to source/elements/oneMath/source/domains/lapack/syevd.rst index 6d02e8c014..d017bdb2eb 100644 --- a/source/elements/oneMKL/source/domains/lapack/syevd.rst +++ b/source/elements/oneMath/source/domains/lapack/syevd.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_syevd: +.. _onemath_lapack_syevd: syevd ===== @@ -47,8 +47,8 @@ syevd (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void syevd(cl::sycl::queue &queue, jobz jobz, oneapi::mkl::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &w, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void syevd(cl::sycl::queue &queue, jobz jobz, oneapi::math::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &w, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -87,7 +87,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_syevd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_syevd_scratchpad_size` function. .. container:: section @@ -111,28 +111,28 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: If :math:`\text{info}=-i`, the :math:`i`-th parameter had an illegal value. - If :math:`\text{info}=i`, and ``jobz = oneapi::mkl::job::novec``, then the algorithm + If :math:`\text{info}=i`, and ``jobz = oneapi::math::job::novec``, then the algorithm failed to converge; :math:`i` indicates the number of off-diagonal elements of an intermediate tridiagonal form which did not converge to zero. - If :math:`\text{info}=i`, and ``jobz = oneapi::mkl::job::vec``, then the algorithm failed + If :math:`\text{info}=i`, and ``jobz = oneapi::math::job::vec``, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns :math:`\text{info}/(n+1)` through :math:`\text{mod}(\text{info},n+1)`. @@ -147,8 +147,8 @@ syevd (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event syevd(cl::sycl::queue &queue, jobz jobz, oneapi::mkl::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, T *w, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event syevd(cl::sycl::queue &queue, jobz jobz, oneapi::math::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, T *w, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -187,7 +187,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_syevd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_syevd_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -214,28 +214,28 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: If :math:`\text{info}=-i`, the :math:`i`-th parameter had an illegal value. - If :math:`\text{info}=i`, and ``jobz = oneapi::mkl::job::novec``, then the algorithm + If :math:`\text{info}=i`, and ``jobz = oneapi::math::job::novec``, then the algorithm failed to converge; :math:`i` indicates the number of off-diagonal elements of an intermediate tridiagonal form which did not converge to zero. - If :math:`\text{info}=i`, and ``jobz = oneapi::mkl::job::vec``, then the algorithm failed + If :math:`\text{info}=i`, and ``jobz = oneapi::math::job::vec``, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns :math:`\text{info}/(n+1)` through :math:`\text{mod}(\text{info},n+1)`. @@ -247,6 +247,6 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/syevd_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/syevd_scratchpad_size.rst similarity index 70% rename from source/elements/oneMKL/source/domains/lapack/syevd_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/syevd_scratchpad_size.rst index c4338d4dd1..f41a868657 100644 --- a/source/elements/oneMKL/source/domains/lapack/syevd_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/syevd_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_syevd_scratchpad_size: +.. _onemath_lapack_syevd_scratchpad_size: syevd_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_syevd` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_syevd` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_syevd` funct * - ``float`` * - ``double`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_syevd` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_syevd` function should be able to hold. Calls to this routine must specify the template parameter explicitly. syevd_scratchpad_size @@ -34,9 +34,9 @@ syevd_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t syevd_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::job jobz, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t lda) + std::int64_t syevd_scratchpad_size(cl::sycl::queue &queue, oneapi::math::job jobz, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t lda) } .. container:: section @@ -44,7 +44,7 @@ syevd_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_syevd` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_syevd` function will be performed. jobz Must be ``job::novec`` or ``job::vec``. @@ -76,11 +76,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -89,8 +89,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_syevd` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_syevd` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/sygvd.rst b/source/elements/oneMath/source/domains/lapack/sygvd.rst similarity index 82% rename from source/elements/oneMKL/source/domains/lapack/sygvd.rst rename to source/elements/oneMath/source/domains/lapack/sygvd.rst index 84a0f503ca..1894242ed9 100644 --- a/source/elements/oneMKL/source/domains/lapack/sygvd.rst +++ b/source/elements/oneMath/source/domains/lapack/sygvd.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_sygvd: +.. _onemath_lapack_sygvd: sygvd ===== @@ -44,8 +44,8 @@ sygvd (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void sygvd(cl::sycl::queue &queue, std::int64_t itype, oneapi::mkl::job jobz, oneapi::mkl::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &b, std::int64_t ldb, cl::sycl::buffer &w, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void sygvd(cl::sycl::queue &queue, std::int64_t itype, oneapi::math::job jobz, oneapi::math::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &b, std::int64_t ldb, cl::sycl::buffer &w, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -102,7 +102,7 @@ ldb scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_sygvd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_sygvd_scratchpad_size` function. .. container:: section @@ -141,17 +141,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -159,12 +159,12 @@ This routine shall throw the following exceptions if the associated condition is For :math:`\text{info} \le n`: - If :math:`\text{info}=i`, and ``jobz = oneapi::mkl::job::novec``, then the algorithm + If :math:`\text{info}=i`, and ``jobz = oneapi::math::job::novec``, then the algorithm failed to converge; :math:`i` indicates the number of off-diagonal elements of an intermediate tridiagonal form which did not converge to zero. - If :math:`\text{info}=i`, and ``jobz = oneapi::mkl::job::vec``, then the algorithm + If :math:`\text{info}=i`, and ``jobz = oneapi::math::job::vec``, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns :math:`\text{info}/(n+1)` through :math:`\text{mod}(\text{info},n+1)`. @@ -187,8 +187,8 @@ sygvd (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event sygvd(cl::sycl::queue &queue, std::int64_t itype, oneapi::mkl::job jobz, oneapi::mkl::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, T *b, std::int64_t ldb, T *w, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event sygvd(cl::sycl::queue &queue, std::int64_t itype, oneapi::math::job jobz, oneapi::math::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, T *b, std::int64_t ldb, T *w, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -245,7 +245,7 @@ ldb scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_sygvd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_sygvd_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -287,17 +287,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -305,12 +305,12 @@ This routine shall throw the following exceptions if the associated condition is For :math:`\text{info} \le n`: - If :math:`\text{info}=i`, and ``jobz = oneapi::mkl::job::novec``, then the algorithm + If :math:`\text{info}=i`, and ``jobz = oneapi::math::job::novec``, then the algorithm failed to converge; :math:`i` indicates the number of off-diagonal elements of an intermediate tridiagonal form which did not converge to zero. - If :math:`\text{info}=i`, and ``jobz = oneapi::mkl::job::vec``, then the algorithm + If :math:`\text{info}=i`, and ``jobz = oneapi::math::job::vec``, then the algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns :math:`\text{info}/(n+1)` through :math:`\text{mod}(\text{info},n+1)`. @@ -330,6 +330,6 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/sygvd_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/sygvd_scratchpad_size.rst similarity index 72% rename from source/elements/oneMKL/source/domains/lapack/sygvd_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/sygvd_scratchpad_size.rst index 15556a2121..806c0a18c7 100644 --- a/source/elements/oneMKL/source/domains/lapack/sygvd_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/sygvd_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_sygvd_scratchpad_size: +.. _onemath_lapack_sygvd_scratchpad_size: sygvd_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_sygvd` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_sygvd` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_sygvd` funct * - ``float`` * - ``double`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_sygvd` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_sygvd` function should be able to hold. Calls to this routine must specify the template parameter explicitly. sygvd_scratchpad_size @@ -34,9 +34,9 @@ sygvd_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t sygvd_scratchpad_size(cl::sycl::queue &queue, std::int64_t itype, oneapi::mkl::job jobz, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t lda, std::int64_t ldb) + std::int64_t sygvd_scratchpad_size(cl::sycl::queue &queue, std::int64_t itype, oneapi::math::job jobz, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t lda, std::int64_t ldb) } .. container:: section @@ -44,7 +44,7 @@ sygvd_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_sygvd` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_sygvd` function will be performed. itype Must be 1 or 2 or 3. Specifies the problem type to be solved: @@ -87,11 +87,11 @@ ldb This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -100,8 +100,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_sygvd` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_sygvd` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/sytrd.rst b/source/elements/oneMath/source/domains/lapack/sytrd.rst similarity index 80% rename from source/elements/oneMKL/source/domains/lapack/sytrd.rst rename to source/elements/oneMath/source/domains/lapack/sytrd.rst index f2df9bdfb1..8719dd5f89 100644 --- a/source/elements/oneMKL/source/domains/lapack/sytrd.rst +++ b/source/elements/oneMath/source/domains/lapack/sytrd.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_sytrd: +.. _onemath_lapack_sytrd: sytrd ===== @@ -37,8 +37,8 @@ sytrd (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void sytrd(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &d, cl::sycl::buffer &e, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void sytrd(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &d, cl::sycl::buffer &e, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -72,7 +72,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_sytrd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_sytrd_scratchpad_size` function. .. container:: section @@ -116,17 +116,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -143,8 +143,8 @@ sytrd (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event sytrd(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, T *d, T *e, T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event sytrd(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, T *d, T *e, T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -177,7 +177,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_sytrd_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_sytrd_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -224,17 +224,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -248,6 +248,6 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/sytrd_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/sytrd_scratchpad_size.rst similarity index 68% rename from source/elements/oneMKL/source/domains/lapack/sytrd_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/sytrd_scratchpad_size.rst index e0f089bcb4..a0e6e87290 100644 --- a/source/elements/oneMKL/source/domains/lapack/sytrd_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/sytrd_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_sytrd_scratchpad_size: +.. _onemath_lapack_sytrd_scratchpad_size: sytrd_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_sytrd` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_sytrd` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_sytrd` funct * - ``float`` * - ``double`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_sytrd` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_sytrd` function should be able to hold. Calls to this routine must specify the template parameter explicitly. sytrd_scratchpad_size @@ -34,9 +34,9 @@ sytrd_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t sytrd_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t lda) + std::int64_t sytrd_scratchpad_size(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t lda) } .. container:: section @@ -44,7 +44,7 @@ sytrd_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_sytrd` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_sytrd` function will be performed. upper_lower Must be ``uplo::upper`` or ``uplo::lower``. @@ -67,11 +67,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -80,8 +80,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_sytrd` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_sytrd` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/sytrf.rst b/source/elements/oneMath/source/domains/lapack/sytrf.rst similarity index 71% rename from source/elements/oneMKL/source/domains/lapack/sytrf.rst rename to source/elements/oneMath/source/domains/lapack/sytrf.rst index f303f49b4c..4b79e10ecc 100644 --- a/source/elements/oneMKL/source/domains/lapack/sytrf.rst +++ b/source/elements/oneMath/source/domains/lapack/sytrf.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_sytrf: +.. _onemath_lapack_sytrf: sytrf ===== @@ -48,8 +48,8 @@ sytrf (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void sytrf(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &ipiv, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void sytrf(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &ipiv, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -77,7 +77,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_sytrf_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_sytrf_scratchpad_size` function. .. container:: section @@ -89,9 +89,9 @@ a ipiv Buffer, size at least :math:`\max(1, n)`. Contains details of the interchanges and the block structure of :math:`D`. If :math:`\text{ipiv}(i)=k>0`, then :math:`d_{ii}` is a :math:`1 \times 1` block, and the :math:`i`-th row and column of :math:`A` was interchanged with the :math:`k`-th row and column. - If ``upper_lower=oneapi::mkl::uplo::upper`` and :math:`\text{ipiv}(i)=\text{ipiv}(i-1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i`-1, and (:math:`i-1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. + If ``upper_lower=oneapi::math::uplo::upper`` and :math:`\text{ipiv}(i)=\text{ipiv}(i-1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i`-1, and (:math:`i-1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. - If ``upper_lower=oneapi::mkl::uplo::lower`` and :math:`\text{ipiv}(i)=\text{ipiv}(i+1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i+1`, and (:math:`i+1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. + If ``upper_lower=oneapi::math::uplo::lower`` and :math:`\text{ipiv}(i)=\text{ipiv}(i+1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i+1`, and (:math:`i+1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. scratchpad Buffer holding scratchpad memory to be used by routine for storing intermediate results. @@ -102,17 +102,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -131,8 +131,8 @@ sytrf (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event sytrf(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, int_64 *ipiv, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event sytrf(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, int_64 *ipiv, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -160,7 +160,7 @@ lda scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_sytrf_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_sytrf_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -175,9 +175,9 @@ a ipiv Pointer to array of size at least :math:`\max(1, n)`. Contains details of the interchanges and the block structure of :math:`D`. If :math:`\text{ipiv}(i)=k>0`, then :math:`d_{ii}` is a :math:`1 \times 1` block, and the :math:`i`-th row and column of :math:`A` was interchanged with the :math:`k`-th row and column. - If ``upper_lower=oneapi::mkl::uplo::upper`` and :math:`\text{ipiv}(i)=\text{ipiv}(i-1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i-1`, and (:math:`i-1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. + If ``upper_lower=oneapi::math::uplo::upper`` and :math:`\text{ipiv}(i)=\text{ipiv}(i-1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i-1`, and (:math:`i-1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. - If ``upper_lower=oneapi::mkl::uplo::lower`` and :math:`\text{ipiv}(i)=\text{ipiv}(i+1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i+1`, and (:math:`i+1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. + If ``upper_lower=oneapi::math::uplo::lower`` and :math:`\text{ipiv}(i)=\text{ipiv}(i+1)=-m<0`, then :math:`D` has a :math:`2 \times 2` block in rows/columns :math:`i` and :math:`i+1`, and (:math:`i+1`)-th row and column of :math:`A` was interchanged with the :math:`m`-th row and column. scratchpad Pointer to scratchpad memory to be used by routine for storing intermediate results. @@ -188,17 +188,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -214,5 +214,5 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/sytrf_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/sytrf_scratchpad_size.rst similarity index 71% rename from source/elements/oneMKL/source/domains/lapack/sytrf_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/sytrf_scratchpad_size.rst index 2bd5c7faa2..a79439b828 100644 --- a/source/elements/oneMKL/source/domains/lapack/sytrf_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/sytrf_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_sytrf_scratchpad_size: +.. _onemath_lapack_sytrf_scratchpad_size: sytrf_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_sytrf` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_sytrf` function. .. container:: section @@ -24,7 +24,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_sytrf` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_sytrf` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_sytrf` function should be able to hold. Calls to this routine must specify the template parameter explicitly. @@ -37,9 +37,9 @@ sytrf_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t sytrf_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t lda) + std::int64_t sytrf_scratchpad_size(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t lda) } .. container:: section @@ -47,7 +47,7 @@ sytrf_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_sytrf` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_sytrf` function will be performed. upper_lower Indicates whether the upper or lower triangular part of :math:`A` is @@ -73,11 +73,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -86,7 +86,7 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_sytrf` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_sytrf` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/trtrs.rst b/source/elements/oneMath/source/domains/lapack/trtrs.rst similarity index 78% rename from source/elements/oneMKL/source/domains/lapack/trtrs.rst rename to source/elements/oneMath/source/domains/lapack/trtrs.rst index 0cfc537d07..2258eeb78b 100644 --- a/source/elements/oneMKL/source/domains/lapack/trtrs.rst +++ b/source/elements/oneMath/source/domains/lapack/trtrs.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_trtrs: +.. _onemath_lapack_trtrs: trtrs ===== @@ -51,8 +51,8 @@ trtrs (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void trtrs(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, oneapi::mkl::transpose transa, oneapi::mkl::diag unit_diag, std::int64_t n, std::int64_t nrhs, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &b, std::int64_t ldb, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void trtrs(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, oneapi::math::transpose transa, oneapi::math::diag unit_diag, std::int64_t n, std::int64_t nrhs, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &b, std::int64_t ldb, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -101,7 +101,7 @@ ldb scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_trtrs_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_trtrs_scratchpad_size` function. .. container:: section @@ -119,17 +119,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -146,8 +146,8 @@ trtrs (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event trtrs(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, oneapi::mkl::transpose transa, oneapi::mkl::diag unit_diag, std::int64_t n, std::int64_t nrhs, const T *a, std::int64_t lda, T *b, std::int64_t ldb, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event trtrs(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, oneapi::math::transpose transa, oneapi::math::diag unit_diag, std::int64_t n, std::int64_t nrhs, const T *a, std::int64_t lda, T *b, std::int64_t ldb, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -196,7 +196,7 @@ ldb scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_trtrs_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_trtrs_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -217,17 +217,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -241,5 +241,5 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/trtrs_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/trtrs_scratchpad_size.rst similarity index 65% rename from source/elements/oneMKL/source/domains/lapack/trtrs_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/trtrs_scratchpad_size.rst index 38674d9909..321689010f 100644 --- a/source/elements/oneMKL/source/domains/lapack/trtrs_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/trtrs_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_trtrs_scratchpad_size: +.. _onemath_lapack_trtrs_scratchpad_size: trtrs_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_trtrs` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_trtrs` function. .. container:: section @@ -24,7 +24,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_trtrs` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_trtrs` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_trtrs` function should be able to hold. Calls to this routine must specify the template parameter explicitly. trtrs_scratchpad_size @@ -36,9 +36,9 @@ trtrs_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t trtrs_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, oneapi::mkl::transpose trans, oneapi::mkl::diag diag, std::int64_t n, std::int64_t nrhs, std::int64_t lda, std::int64_t ldb) + std::int64_t trtrs_scratchpad_size(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, oneapi::math::transpose trans, oneapi::math::diag diag, std::int64_t n, std::int64_t nrhs, std::int64_t lda, std::int64_t ldb) } .. container:: section @@ -46,7 +46,7 @@ trtrs_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_trtrs` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_trtrs` function will be performed. upper_lower Indicates whether :math:`A` is upper or lower triangular: @@ -58,17 +58,17 @@ upper_lower trans Indicates the form of the equations: - If ``trans=oneapi::mkl::transpose::nontrans``, then :math:`AX = B` is solved + If ``trans=oneapi::math::transpose::nontrans``, then :math:`AX = B` is solved for :math:`X`. - If ``trans=oneapi::mkl::transpose::trans``, then :math:`A^TX = B` is solved + If ``trans=oneapi::math::transpose::trans``, then :math:`A^TX = B` is solved for :math:`X`. - If ``trans=oneapi::mkl::transpose::conjtrans``, then :math:`A^HX = B` is + If ``trans=oneapi::math::transpose::conjtrans``, then :math:`A^HX = B` is solved for :math:`X`. diag - If diag = ``oneapi::mkl::diag::nonunit``, then :math:`A` is not a unit triangular matrix. + If diag = ``oneapi::math::diag::nonunit``, then :math:`A` is not a unit triangular matrix. If unit_diag = ``diag::unit``, then :math:`A` is unit triangular: diagonal elements of :math:`A` are assumed to be 1 and not referenced in the array ``a``. @@ -90,11 +90,11 @@ ldb This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -103,7 +103,7 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_trtrs` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_trtrs` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/ungbr.rst b/source/elements/oneMath/source/domains/lapack/ungbr.rst similarity index 73% rename from source/elements/oneMKL/source/domains/lapack/ungbr.rst rename to source/elements/oneMath/source/domains/lapack/ungbr.rst index 378ef30b1e..fa899f3a90 100644 --- a/source/elements/oneMKL/source/domains/lapack/ungbr.rst +++ b/source/elements/oneMath/source/domains/lapack/ungbr.rst @@ -2,13 +2,13 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ungbr: +.. _onemath_lapack_ungbr: ungbr ===== Generates the complex unitary matrix :math:`Q` or :math:`P^{t}` determined by -:ref:`onemkl_lapack_gebrd`. +:ref:`onemath_lapack_gebrd`. .. container:: section @@ -25,7 +25,7 @@ Generates the complex unitary matrix :math:`Q` or :math:`P^{t}` determined by The routine generates the whole or part of the unitary matrices :math:`Q` and :math:`P^{H}` formed by the routines -:ref:`onemkl_lapack_gebrd`. +:ref:`onemath_lapack_gebrd`. All valid combinations of arguments are described in *Input Parameters*; in most cases you need the following: @@ -33,7 +33,7 @@ To compute the whole :math:`m \times m` matrix :math:`Q`, use: :: - oneapi::mkl::lapack::ungbr(queue, generate::q, m, m, n, a, ...) + oneapi::math::lapack::ungbr(queue, generate::q, m, m, n, a, ...) (note that the buffer ``a`` must have at least :math:`m` columns). @@ -41,13 +41,13 @@ To form the :math:`n` leading columns of :math:`Q` if :math:`m > n`, use: :: - oneapi::mkl::lapack::ungbr(queue, generate::q, m, n, n, a, ...) + oneapi::math::lapack::ungbr(queue, generate::q, m, n, n, a, ...) To compute the whole :math:`n \times n` matrix :math:`P^{T}`, use: :: - oneapi::mkl::lapack::ungbr(queue, generate::p, n, n, m, a, ...) + oneapi::math::lapack::ungbr(queue, generate::p, n, n, m, a, ...) (note that the array ``a`` must have at least :math:`n` rows). @@ -55,7 +55,7 @@ To form the :math:`m` leading rows of :math:`P^{T}` if :math:`m < n`, use: :: - oneapi::mkl::lapack::ungbr(queue, generate::p, m, n, m, a, ...) + oneapi::math::lapack::ungbr(queue, generate::p, m, n, m, a, ...) ungbr (Buffer Version) ---------------------- @@ -66,8 +66,8 @@ ungbr (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void ungbr(cl::sycl::queue &queue, oneapi::mkl::generate gen, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void ungbr(cl::sycl::queue &queue, oneapi::math::generate gen, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -100,22 +100,22 @@ n k If ``gen = generate::q``, the number of columns in the original :math:`m \times k` matrix returned by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. If ``gen = generate::p``, the number of rows in the original :math:`k \times n` matrix returned by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. a The buffer ``a`` as returned by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. lda The leading dimension of ``a``. tau - For ``gen = generate::q``, the array ``tauq`` as returned by :ref:`onemkl_lapack_gebrd`. - For ``gen = generate::p``, the array ``taup`` as returned by :ref:`onemkl_lapack_gebrd`. + For ``gen = generate::q``, the array ``tauq`` as returned by :ref:`onemath_lapack_gebrd`. + For ``gen = generate::p``, the array ``taup`` as returned by :ref:`onemath_lapack_gebrd`. The dimension of ``tau`` must be at least :math:`\max(1, \min(m, k))` for ``gen = generate::q``, or :math:`\max(1, \min(m, k))` for @@ -123,7 +123,7 @@ tau scratchpad_size Size of scratchpad memory as a number of floating point elements of type :math:`T`. - Size should not be less than the value returned by :ref:`onemkl_lapack_ungbr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_ungbr_scratchpad_size` function. .. container:: section @@ -143,17 +143,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -170,8 +170,8 @@ ungbr (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event ungbr(cl::sycl::queue &queue, oneapi::mkl::generate gen, std::int64_t m, std::int64_t n, std::int64_t k, T *a, std::int64_t lda, const T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event ungbr(cl::sycl::queue &queue, oneapi::math::generate gen, std::int64_t m, std::int64_t n, std::int64_t k, T *a, std::int64_t lda, const T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -204,22 +204,22 @@ n k If ``gen = generate::q``, the number of columns in the original :math:`m \times k` matrix returned by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. If ``gen = generate::p``, the number of rows in the original :math:`k \times n` matrix returned by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. a The pointer to ``a`` as returned by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. lda The leading dimension of ``a``. tau - For ``gen = generate::q``, the array ``tauq`` as returned by :ref:`onemkl_lapack_gebrd`. - For ``gen = generate::p``, the array ``taup`` as returned by :ref:`onemkl_lapack_gebrd`. + For ``gen = generate::q``, the array ``tauq`` as returned by :ref:`onemath_lapack_gebrd`. + For ``gen = generate::p``, the array ``taup`` as returned by :ref:`onemath_lapack_gebrd`. The dimension of ``tau`` must be at least :math:`\max(1, \min(m, k))` for ``gen = generate::q``, or :math:`\max(1, \min(m, k))` for @@ -227,7 +227,7 @@ tau scratchpad_size Size of scratchpad memory as a number of floating point elements of type :math:`T`. - Size should not be less than the value returned by :ref:`onemkl_lapack_ungbr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_ungbr_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -250,17 +250,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -274,6 +274,6 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/ungbr_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/ungbr_scratchpad_size.rst similarity index 70% rename from source/elements/oneMKL/source/domains/lapack/ungbr_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/ungbr_scratchpad_size.rst index 1b96bc59ef..513d9ff716 100644 --- a/source/elements/oneMKL/source/domains/lapack/ungbr_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/ungbr_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ungbr_scratchpad_size: +.. _onemath_lapack_ungbr_scratchpad_size: ungbr_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_ungbr` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_ungbr` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_ungbr` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type :math:`T` the scratchpad memory to be passed to :ref:`onemkl_lapack_ungbr` function should be able to hold. +Computes the number of elements of type :math:`T` the scratchpad memory to be passed to :ref:`onemath_lapack_ungbr` function should be able to hold. Calls to this routine must specify the template parameter explicitly. ungbr_scratchpad_size @@ -34,9 +34,9 @@ ungbr_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t ungbr_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::generate gen, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t &scratchpad_size) + std::int64_t ungbr_scratchpad_size(cl::sycl::queue &queue, oneapi::math::generate gen, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t &scratchpad_size) } .. container:: section @@ -44,7 +44,7 @@ ungbr_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_ungbr` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_ungbr` function will be performed. gen Must be ``generate::q`` or ``generate::p``. @@ -70,11 +70,11 @@ n k If ``gen = generate::q``, the number of columns in the original :math:`m \times k` matrix reduced by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. If ``gen = generate::p``, the number of rows in the original :math:`k \times n` matrix reduced by - :ref:`onemkl_lapack_gebrd`. + :ref:`onemath_lapack_gebrd`. lda The leading dimension of ``a``. @@ -85,11 +85,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -98,8 +98,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_ungbr` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_ungbr` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/ungqr.rst b/source/elements/oneMath/source/domains/lapack/ungqr.rst similarity index 75% rename from source/elements/oneMKL/source/domains/lapack/ungqr.rst rename to source/elements/oneMath/source/domains/lapack/ungqr.rst index e1d0875bed..98ed3ecfbe 100644 --- a/source/elements/oneMKL/source/domains/lapack/ungqr.rst +++ b/source/elements/oneMath/source/domains/lapack/ungqr.rst @@ -2,13 +2,13 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ungqr: +.. _onemath_lapack_ungqr: ungqr ===== Generates the complex unitary matrix :math:`Q` of the QR factorization formed -by :ref:`onemkl_lapack_geqrf`. +by :ref:`onemath_lapack_geqrf`. .. container:: section @@ -25,28 +25,28 @@ by :ref:`onemkl_lapack_geqrf`. The routine generates the whole or part of :math:`m \times m` unitary matrix :math:`Q` of the QR factorization formed by the routines -:ref:`onemkl_lapack_geqrf`. +:ref:`onemath_lapack_geqrf`. Usually :math:`Q` is determined from the QR factorization of an :math:`m \times p` matrix :math:`A` with :math:`m \ge p`. To compute the whole matrix :math:`Q`, use: :: - oneapi::mkl::lapack::ungqr(queue, m, m, p, a, lda, tau, scratchpad, scratchpad_size) + oneapi::math::lapack::ungqr(queue, m, m, p, a, lda, tau, scratchpad, scratchpad_size) To compute the leading :math:`p` columns of :math:`Q` (which form an orthonormal basis in the space spanned by the columns of :math:`A`): :: - oneapi::mkl::lapack::ungqr(queue, m, p, p, a, lda, tau, scratchpad, scratchpad_size) + oneapi::math::lapack::ungqr(queue, m, p, p, a, lda, tau, scratchpad, scratchpad_size) To compute the matrix :math:`Q^{k}` of the QR factorization of the leading :math:`k` columns of the matrix :math:`A`: :: - oneapi::mkl::lapack::ungqr(queue, m, m, k, a, lda, tau, scratchpad, scratchpad_size) + oneapi::math::lapack::ungqr(queue, m, m, k, a, lda, tau, scratchpad, scratchpad_size) To compute the leading :math:`k` columns of :math:`Q^{k}` (which form an orthonormal basis in the space spanned by the leading :math:`k` @@ -54,7 +54,7 @@ columns of the matrix :math:`A`): :: - oneapi::mkl::lapack::ungqr(queue, m, k, k, a, lda, tau, scratchpad, scratchpad_size) + oneapi::math::lapack::ungqr(queue, m, k, k, a, lda, tau, scratchpad, scratchpad_size) ungqr (Buffer Version) ---------------------- @@ -65,7 +65,7 @@ ungqr (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { void ungqr(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } @@ -88,18 +88,18 @@ k a The buffer ``a`` as returned by - :ref:`onemkl_lapack_geqrf`. + :ref:`onemath_lapack_geqrf`. lda The leading dimension of ``a`` (:math:`\text{lda} \le m`). tau The buffer ``tau`` as returned by - :ref:`onemkl_lapack_geqrf`. + :ref:`onemath_lapack_geqrf`. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_ungqr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_ungqr_scratchpad_size` function. .. container:: section @@ -118,17 +118,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -145,7 +145,7 @@ ungqr (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event ungqr(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t k, T *a, std::int64_t lda, const T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } @@ -168,18 +168,18 @@ k a The pointer to ``a`` as returned by - :ref:`onemkl_lapack_geqrf`. + :ref:`onemath_lapack_geqrf`. lda The leading dimension of ``a`` (:math:`\text{lda} \le m`). tau The pointer to ``tau`` as returned by - :ref:`onemkl_lapack_geqrf`. + :ref:`onemath_lapack_geqrf`. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_ungqr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_ungqr_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -201,17 +201,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -225,5 +225,5 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/ungqr_batch.rst b/source/elements/oneMath/source/domains/lapack/ungqr_batch.rst similarity index 82% rename from source/elements/oneMKL/source/domains/lapack/ungqr_batch.rst rename to source/elements/oneMath/source/domains/lapack/ungqr_batch.rst index e9ba784a97..87d63bfd49 100644 --- a/source/elements/oneMKL/source/domains/lapack/ungqr_batch.rst +++ b/source/elements/oneMath/source/domains/lapack/ungqr_batch.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ungqr_batch: +.. _onemath_lapack_ungqr_batch: ungqr_batch =========== -Generates the complex unitary matrices :math:`Q_i` of the batch of QR factorizations formed by the :ref:`onemkl_lapack_geqrf_batch` function. +Generates the complex unitary matrices :math:`Q_i` of the batch of QR factorizations formed by the :ref:`onemath_lapack_geqrf_batch` function. .. container:: section @@ -22,7 +22,7 @@ Generates the complex unitary matrices :math:`Q_i` of the batch of QR factorizat * - ``std::complex`` * - ``std::complex`` -.. _onemkl_lapack_ungqr_batch_buffer: +.. _onemath_lapack_ungqr_batch_buffer: ungqr_batch (Buffer Version) ---------------------------- @@ -35,7 +35,7 @@ The buffer version of ``ungqr_batch`` supports only the strided API. **Strided API** - | The routine generates the wholes or parts of :math`m \times m` unitary matrices :math:`Q_i` of the batch of QR factorization formed by the Strided API of the :ref:`onemkl_lapack_geqrf_batch_buffer`. + | The routine generates the wholes or parts of :math`m \times m` unitary matrices :math:`Q_i` of the batch of QR factorization formed by the Strided API of the :ref:`onemath_lapack_geqrf_batch_buffer`. | Usually :math:`Q_i` is determined from the QR factorization of an :math:`m \times p` matrix :math:`A_i` with :math`m \ge p`. | To compute the whole matrices :math:`Q_i`, use: | ``ungqr_batch(queue, m, m, p, a, ...)`` @@ -52,7 +52,7 @@ The buffer version of ``ungqr_batch`` supports only the strided API. .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { void ungqr_batch(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, std::int64_t stride_a, cl::sycl::buffer &tau, std::int64_t stride_tau, std::int64_t batch_size, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } @@ -73,7 +73,7 @@ k Number of elementary reflectors whose product defines the matrices :math:`Q_i` (:math:`0 \le k \le n`). a - Array resulting after call to the Strided API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array resulting after call to the Strided API of the :ref:`onemath_lapack_geqrf_batch_usm` function. lda Leading dimension of :math:`A_i` (:math:`\text{lda} \le m`). @@ -82,7 +82,7 @@ stride_a Stride between the beginnings of matrices :math:`A_i` inside the batch array ``a``. tau - Array resulting after call to the Strided API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array resulting after call to the Strided API of the :ref:`onemath_lapack_geqrf_batch_usm` function. stride_tau Stride between the beginnings of arrays :math:`tau_i` inside the array ``tau``. @@ -94,7 +94,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by strided version of the Strided API of the :ref:`onemkl_lapack_ungqr_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by strided version of the Strided API of the :ref:`onemath_lapack_ungqr_batch_scratchpad_size` function. .. container:: section @@ -109,13 +109,13 @@ a This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of problems during calculations. The info code of the problem can be obtained by info() method of exception object: @@ -125,7 +125,7 @@ This routine shall throw the following exceptions if the associated condition is If ``info`` is not zero and `detail()` returns zero, then there were some errors for some of the problems in the supplied batch and ``info`` code contains the number of failed calculations in a batch. -.. _onemkl_lapack_ungqr_batch_usm: +.. _onemath_lapack_ungqr_batch_usm: ungqr_batch (USM Version) ------------------------- @@ -138,7 +138,7 @@ The USM version of ``ungqr_batch`` supports the group API and strided API. **Group API** - | The routine generates the wholes or parts of :math`m \times m` unitary matrices :math:`Q_i` of the batch of QR factorization formed by the Group API of the :ref:`onemkl_lapack_geqrf_batch_buffer`. + | The routine generates the wholes or parts of :math`m \times m` unitary matrices :math:`Q_i` of the batch of QR factorization formed by the Group API of the :ref:`onemath_lapack_geqrf_batch_buffer`. | Usually :math:`Q_i` is determined from the QR factorization of an :math:`m \times p` matrix :math:`A_i` with :math`m \ge p`. | To compute the whole matrices :math:`Q_i`, use: | ``ungqr_batch(queue, m, m, p, a, ...)`` @@ -155,7 +155,7 @@ The USM version of ``ungqr_batch`` supports the group API and strided API. .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event ungqr_batch(cl::sycl::queue &queue, std::int64_t *m, std::int64_t *n, std::int64_t *k, T **a, std::int64_t *lda, const T * const *tau, std::int64_t group_count, std::int64_t *group_sizes, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } @@ -167,23 +167,23 @@ queue Device queue where calculations will be performed. m - Array of ``group_count`` :math:`m_g` parameters as previously supplied to the Group API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array of ``group_count`` :math:`m_g` parameters as previously supplied to the Group API of the :ref:`onemath_lapack_geqrf_batch_usm` function. n - Array of ``group_count`` :math:`n_g` parameters as previously supplied to the Group API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array of ``group_count`` :math:`n_g` parameters as previously supplied to the Group API of the :ref:`onemath_lapack_geqrf_batch_usm` function. k - | Array of ``group_count`` :math:`k_g` parameters as previously supplied to the Group API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + | Array of ``group_count`` :math:`k_g` parameters as previously supplied to the Group API of the :ref:`onemath_lapack_geqrf_batch_usm` function. | The number of elementary reflectors whose product defines the matrices :math:`Q_i` (:math:`0 \le k_g \le n_g`). a - Array resulting after call to the Group API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array resulting after call to the Group API of the :ref:`onemath_lapack_geqrf_batch_usm` function. lda - Array of leading dimensions of :math:`A_i` as previously supplied to the Group API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array of leading dimensions of :math:`A_i` as previously supplied to the Group API of the :ref:`onemath_lapack_geqrf_batch_usm` function. tau - Array resulting after call to the Group API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array resulting after call to the Group API of the :ref:`onemath_lapack_geqrf_batch_usm` function. group_count Number of groups of parameters. Must be at least 0. @@ -195,7 +195,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by Group API of the :ref:`onemkl_lapack_ungqr_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by Group API of the :ref:`onemath_lapack_ungqr_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -219,13 +219,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -236,7 +236,7 @@ This routine shall throw the following exceptions if the associated condition is **Strided API** - | The routine generates the wholes or parts of :math`m \times m` unitary matrices :math:`Q_i` of the batch of QR factorization formed by the Strided API of the :ref:`onemkl_lapack_geqrf_batch_usm`. + | The routine generates the wholes or parts of :math`m \times m` unitary matrices :math:`Q_i` of the batch of QR factorization formed by the Strided API of the :ref:`onemath_lapack_geqrf_batch_usm`. | Usually :math:`Q_i` is determined from the QR factorization of an :math:`m \times p` matrix :math:`A_i` with :math`m \ge p`. | To compute the whole matrices :math:`Q_i`, use: | ``ungqr_batch(queue, m, m, p, a, ...)`` @@ -253,7 +253,7 @@ This routine shall throw the following exceptions if the associated condition is .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { cl::sycl::event ungqr_batch(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t k, T *a, std::int64_t lda, std::int64_t stride_a, const T *tau, std::int64_t stride_tau, std::int64_t batch_size, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) }; @@ -274,7 +274,7 @@ k Number of elementary reflectors whose product defines the matrices :math:`Q_i` (:math:`0 \le k \le n`). a - Array resulting after call to the Strided API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array resulting after call to the Strided API of the :ref:`onemath_lapack_geqrf_batch_usm` function. lda Leading dimension of :math:`A_i` (:math:`\text{lda} \le m`). @@ -283,7 +283,7 @@ stride_a Stride between the beginnings of matrices :math:`A_i` inside the batch array ``a``. tau - Array resulting after call to the Strided API of the :ref:`onemkl_lapack_geqrf_batch_usm` function. + Array resulting after call to the Strided API of the :ref:`onemath_lapack_geqrf_batch_usm` function. stride_tau Stride between the beginnings of arrays :math:`tau_i` inside the array ``tau``. @@ -295,7 +295,7 @@ scratchpad Scratchpad memory to be used by routine for storing intermediate results. scratchpad_size - Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by strided version of the Strided API of the :ref:`onemkl_lapack_ungqr_batch_scratchpad_size` function. + Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less then the value returned by strided version of the Strided API of the :ref:`onemath_lapack_ungqr_batch_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -319,13 +319,13 @@ Output event to wait on to ensure computation is complete. This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::lapack::batch_error` +:ref:`oneapi::math::lapack::batch_error` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -335,5 +335,5 @@ This routine shall throw the following exceptions if the associated condition is If ``info`` is not zero and `detail()` returns zero, then there were some errors for some of the problems in the supplied batch and ``info`` code contains the number of failed calculations in a batch. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/ungqr_batch_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/ungqr_batch_scratchpad_size.rst similarity index 78% rename from source/elements/oneMKL/source/domains/lapack/ungqr_batch_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/ungqr_batch_scratchpad_size.rst index dbc9c6acd8..c68df2dd87 100644 --- a/source/elements/oneMKL/source/domains/lapack/ungqr_batch_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/ungqr_batch_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ungqr_batch_scratchpad_size: +.. _onemath_lapack_ungqr_batch_scratchpad_size: ungqr_batch_scratchpad_size =========================== -Computes size of scratchpad memory required for the :ref:`onemkl_lapack_ungqr_batch` function. +Computes size of scratchpad memory required for the :ref:`onemath_lapack_ungqr_batch` function. .. container:: section @@ -24,7 +24,7 @@ Computes size of scratchpad memory required for the :ref:`onemkl_lapack_ungqr_ba **Group API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_ungqr_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_ungqr_batch` function. .. container:: section @@ -32,7 +32,7 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t ungqr_batch_scratchpad_size(cl::sycl::queue &queue, std::int64_t *m, std::int64_t *n, std::int64_t *k, std::int64_t *lda, std::int64_t group_count, std::int64_t *group_sizes) } @@ -67,7 +67,7 @@ group_sizes .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemkl_lapack_ungqr_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Group API of the :ref:`onemath_lapack_ungqr_batch` function. .. container:: section @@ -75,18 +75,18 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. **Strided API** -Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_ungqr_batch` function. +Computes the number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_ungqr_batch` function. .. container:: section @@ -94,7 +94,7 @@ Computes the number of elements of type ``T`` the scratchpad memory should able .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t ungqr_batch_scratchpad_size(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t stride_a, std::int64_t stride_tau, std::int64_t batch_size) }; @@ -132,7 +132,7 @@ batch_size .. rubric:: Return Values -Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemkl_lapack_ungqr_batch` function. +Number of elements of type ``T`` the scratchpad memory should able to hold to be passed to the Strided API of the :ref:`onemath_lapack_ungqr_batch` function. .. container:: section @@ -140,14 +140,14 @@ Number of elements of type ``T`` the scratchpad memory should able to hold to be This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. -**Parent topic:** :ref:`onemkl_lapack-like-extensions-routines` +**Parent topic:** :ref:`onemath_lapack-like-extensions-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/ungqr_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/ungqr_scratchpad_size.rst similarity index 70% rename from source/elements/oneMKL/source/domains/lapack/ungqr_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/ungqr_scratchpad_size.rst index 2433f00d08..fbac1ab383 100644 --- a/source/elements/oneMKL/source/domains/lapack/ungqr_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/ungqr_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ungqr_scratchpad_size: +.. _onemath_lapack_ungqr_scratchpad_size: ungqr_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_ungqr` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_ungqr` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_ungqr` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_ungqr` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_ungqr` function should be able to hold. Calls to this routine must specify the template parameter explicitly. ungqr_scratchpad_size @@ -34,7 +34,7 @@ ungqr_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template std::int64_t ungqr_scratchpad_size(cl::sycl::queue &queue, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda) } @@ -44,7 +44,7 @@ ungqr_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_ungqr` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_ungqr` function will be performed. m The number of rows in the matrix :math:`A` (:math:`0 \le m`). @@ -65,11 +65,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -78,8 +78,8 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_ungqr` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_ungqr` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines`  +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines`  diff --git a/source/elements/oneMKL/source/domains/lapack/ungtr.rst b/source/elements/oneMath/source/domains/lapack/ungtr.rst similarity index 69% rename from source/elements/oneMKL/source/domains/lapack/ungtr.rst rename to source/elements/oneMath/source/domains/lapack/ungtr.rst index 88a090e363..0e490fdc8f 100644 --- a/source/elements/oneMKL/source/domains/lapack/ungtr.rst +++ b/source/elements/oneMath/source/domains/lapack/ungtr.rst @@ -2,13 +2,13 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ungtr: +.. _onemath_lapack_ungtr: ungtr ===== Generates the complex unitary matrix :math:`Q` determined by -:ref:`onemkl_lapack_hetrd`. +:ref:`onemath_lapack_hetrd`. .. container:: section @@ -24,10 +24,10 @@ Generates the complex unitary matrix :math:`Q` determined by * - ``std::complex`` The routine explicitly generates the :math:`n \times n` unitary matrix -:math:`Q` formed by :ref:`onemkl_lapack_hetrd` when +:math:`Q` formed by :ref:`onemath_lapack_hetrd` when reducing a complex Hermitian matrix :math:`A` to tridiagonal form: :math:`A = QTQ^H`. Use this routine after a call to -:ref:`onemkl_lapack_hetrd`. +:ref:`onemath_lapack_hetrd`. ungtr (Buffer Version) ---------------------- @@ -38,8 +38,8 @@ ungtr (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void ungtr(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void ungtr(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -52,14 +52,14 @@ queue upper_lower Must be ``uplo::upper`` or ``uplo::lower``. Uses the same ``upper_lower`` as supplied to - :ref:`onemkl_lapack_hetrd`. + :ref:`onemath_lapack_hetrd`. n The order of the matrix :math:`Q` :math:`(0 \le n)`. a The buffer ``a`` as returned by - :ref:`onemkl_lapack_hetrd`. The + :ref:`onemath_lapack_hetrd`. The second dimension of ``a`` must be at least :math:`\max(1, n)`. lda @@ -67,12 +67,12 @@ lda tau The buffer ``tau`` as returned by - :ref:`onemkl_lapack_hetrd`. The + :ref:`onemath_lapack_hetrd`. The dimension of ``tau`` must be at least :math:`\max(1, n-1)`. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_ungtr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_ungtr_scratchpad_size` function. .. container:: section @@ -90,17 +90,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -117,8 +117,8 @@ ungtr (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event ungtr(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, const T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event ungtr(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, T *a, std::int64_t lda, const T *tau, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -131,14 +131,14 @@ queue upper_lower Must be ``uplo::upper`` or ``uplo::lower``. Uses the same ``upper_lower`` as supplied to - :ref:`onemkl_lapack_hetrd`. + :ref:`onemath_lapack_hetrd`. n The order of the matrix :math:`Q` :math:`(0 \le n)`. a The pointer to ``a`` as returned by - :ref:`onemkl_lapack_hetrd`. The + :ref:`onemath_lapack_hetrd`. The second dimension of ``a`` must be at least :math:`\max(1, n)`. lda @@ -146,12 +146,12 @@ lda tau The pointer to ``tau`` as returned by - :ref:`onemkl_lapack_hetrd`. The + :ref:`onemath_lapack_hetrd`. The dimension of ``tau`` must be at least :math:`\max(1, n-1)`. scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_ungtr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_ungtr_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -172,17 +172,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -196,6 +196,6 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/ungtr_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/ungtr_scratchpad_size.rst similarity index 66% rename from source/elements/oneMKL/source/domains/lapack/ungtr_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/ungtr_scratchpad_size.rst index 9eb3f6bb38..7ca69e14ab 100644 --- a/source/elements/oneMKL/source/domains/lapack/ungtr_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/ungtr_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_ungtr_scratchpad_size: +.. _onemath_lapack_ungtr_scratchpad_size: ungtr_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_ungtr` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_ungtr` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_ungtr` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_ungtr` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_ungtr` function should be able to hold. Calls to this routine must specify the template parameter explicitly. ungtr_scratchpad_size @@ -34,9 +34,9 @@ ungtr_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t ungtr_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::uplo upper_lower, std::int64_t n, std::int64_t lda) + std::int64_t ungtr_scratchpad_size(cl::sycl::queue &queue, oneapi::math::uplo upper_lower, std::int64_t n, std::int64_t lda) } .. container:: section @@ -44,12 +44,12 @@ ungtr_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_ungtr` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_ungtr` function will be performed. upper_lower Must be ``uplo::upper`` or ``uplo::lower``. Uses the same ``upper_lower`` as supplied to - :ref:`onemkl_lapack_hetrd`. + :ref:`onemath_lapack_hetrd`. n The order of the matrix :math:`Q` :math:`(0 \le n)`. @@ -63,11 +63,11 @@ lda This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -76,7 +76,7 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type T the scratchpad memory to be passed to :ref:`onemkl_lapack_ungtr` function should be able to hold. +The number of elements of type T the scratchpad memory to be passed to :ref:`onemath_lapack_ungtr` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/unmqr.rst b/source/elements/oneMath/source/domains/lapack/unmqr.rst similarity index 63% rename from source/elements/oneMKL/source/domains/lapack/unmqr.rst rename to source/elements/oneMath/source/domains/lapack/unmqr.rst index f3d569ada5..b924422a34 100644 --- a/source/elements/oneMKL/source/domains/lapack/unmqr.rst +++ b/source/elements/oneMath/source/domains/lapack/unmqr.rst @@ -2,13 +2,13 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_unmqr: +.. _onemath_lapack_unmqr: unmqr ===== Multiplies a complex matrix by the unitary matrix :math:`Q` of the QR -factorization formed by :ref:`onemkl_lapack_geqrf`. +factorization formed by :ref:`onemath_lapack_geqrf`. .. container:: section @@ -27,7 +27,7 @@ The routine multiplies a rectangular complex :math:`m \times n` matrix :math:`C` :math:`Q` or :math:`Q^H`, where :math:`Q` is the complex unitary matrix defined as a product of :math:`k` elementary reflectors :math:`H(i)` of order :math:`n`: :math:`Q = H(1)^HH(2)^H ... H(k)^H` as returned by the RQ factorization routine -:ref:`onemkl_lapack_gerqf`. +:ref:`onemath_lapack_gerqf`. Depending on the parameters ``side`` and ``trans``, the routine can form one of the matrix products :math:`QC`, :math:`Q^HC`, :math:`CQ`, or :math:`CQ^H` @@ -42,8 +42,8 @@ unmqr (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void unmqr(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &c, std::int64_t ldc, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void unmqr(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &c, std::int64_t ldc, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -54,17 +54,17 @@ queue The queue where the routine should be executed. side - If ``side = oneapi::mkl::side::left``, :math:`Q` or :math:`Q^{H}` is applied + If ``side = oneapi::math::side::left``, :math:`Q` or :math:`Q^{H}` is applied to :math:`C` from the left. - If ``side = oneapi::mkl::side::right``, :math:`Q` or :math:`Q^{H}` is + If ``side = oneapi::math::side::right``, :math:`Q` or :math:`Q^{H}` is applied to :math:`C` from the right. trans - If ``trans = oneapi::mkl::transpose::nontrans``, the routine multiplies + If ``trans = oneapi::math::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. - If ``trans = oneapi::mkl::transpose::conjtrans``, the routine multiplies :math:`C` + If ``trans = oneapi::math::transpose::conjtrans``, the routine multiplies :math:`C` by :math:`Q^{H}`. m @@ -77,19 +77,19 @@ k The number of elementary reflectors whose product defines the matrix :math:`Q` - If ``side = oneapi::mkl::side::left``, :math:`0 \le k \le m` + If ``side = oneapi::math::side::left``, :math:`0 \le k \le m` - If ``side = oneapi::mkl::side::right``, :math:`0 \le k \le n` + If ``side = oneapi::math::side::right``, :math:`0 \le k \le n` a - The buffer ``a`` as returned by :ref:`onemkl_lapack_geqrf`. + The buffer ``a`` as returned by :ref:`onemath_lapack_geqrf`. The second dimension of ``a`` must be at least :math:`\max(1,k)`. lda The leading dimension of ``a``. tau - The buffer ``tau`` as returned by :ref:`onemkl_lapack_geqrf`. + The buffer ``tau`` as returned by :ref:`onemath_lapack_geqrf`. c The buffer ``c`` contains the matrix :math:`C`. The second dimension of @@ -101,7 +101,7 @@ ldc scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by the - :ref:`onemkl_lapack_unmqr_scratchpad_size` function. + :ref:`onemath_lapack_unmqr_scratchpad_size` function. .. container:: section @@ -120,17 +120,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -147,8 +147,8 @@ unmqr (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event unmqr(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, const T *a, std::int64_t lda, const T *tau, T *c, std::int64_t ldc, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event unmqr(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, const T *a, std::int64_t lda, const T *tau, T *c, std::int64_t ldc, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -159,17 +159,17 @@ queue The queue where the routine should be executed. side - If ``side = oneapi::mkl::side::left``, :math:`Q` or :math:`Q^{H}` is applied + If ``side = oneapi::math::side::left``, :math:`Q` or :math:`Q^{H}` is applied to :math:`C` from the left. - If ``side = oneapi::mkl::side::right``, :math:`Q` or :math:`Q^{H}` is + If ``side = oneapi::math::side::right``, :math:`Q` or :math:`Q^{H}` is applied to :math:`C` from the right. trans - If ``trans = oneapi::mkl::transpose::nontrans``, the routine multiplies + If ``trans = oneapi::math::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. - If ``trans = oneapi::mkl::transpose::conjtrans``, the routine multiplies :math:`C` + If ``trans = oneapi::math::transpose::conjtrans``, the routine multiplies :math:`C` by :math:`Q^{H}`. m @@ -182,19 +182,19 @@ k The number of elementary reflectors whose product defines the matrix :math:`Q` - If ``side = oneapi::mkl::side::left``, :math:`0 \le k \le m` + If ``side = oneapi::math::side::left``, :math:`0 \le k \le m` - If ``side = oneapi::mkl::side::right``, :math:`0 \le k \le n` + If ``side = oneapi::math::side::right``, :math:`0 \le k \le n` a - The pointer to ``a`` as returned by :ref:`onemkl_lapack_geqrf`. + The pointer to ``a`` as returned by :ref:`onemath_lapack_geqrf`. The second dimension of ``a`` must be at least :math:`\max(1,k)`. lda The leading dimension of ``a``. tau - The pointer to ``tau`` as returned by :ref:`onemkl_lapack_geqrf`. + The pointer to ``tau`` as returned by :ref:`onemath_lapack_geqrf`. c The pointer ``c`` points to the matrix :math:`C`. The second dimension of @@ -206,7 +206,7 @@ ldc scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by - :ref:`onemkl_lapack_unmqr_scratchpad_size` function. + :ref:`onemath_lapack_unmqr_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -228,17 +228,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -252,4 +252,4 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/unmqr_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/unmqr_scratchpad_size.rst similarity index 61% rename from source/elements/oneMKL/source/domains/lapack/unmqr_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/unmqr_scratchpad_size.rst index 81b97e4cc2..8c0a639e42 100644 --- a/source/elements/oneMKL/source/domains/lapack/unmqr_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/unmqr_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_unmqr_scratchpad_size: +.. _onemath_lapack_unmqr_scratchpad_size: unmqr_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_unmqr` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_unmqr` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_unmqr` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_unmqr` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_unmqr` function should be able to hold. Calls to this routine must specify the template parameter explicitly. @@ -35,9 +35,9 @@ unmqr_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t unmqr_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t ldc, std::int64_t &scratchpad_size) + std::int64_t unmqr_scratchpad_size(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t ldc, std::int64_t &scratchpad_size) } .. container:: section @@ -45,20 +45,20 @@ unmqr_scratchpad_size .. rubric:: Input Parameters queue - Device queue where calculations by :ref:`onemkl_lapack_unmqr` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_unmqr` function will be performed. side - If ``side=oneapi::mkl::side::left``, :math:`Q` or :math:`Q^{H}` is + If ``side=oneapi::math::side::left``, :math:`Q` or :math:`Q^{H}` is applied to :math:`C` from the left. - If ``side=oneapi::mkl::side::right``, :math:`Q` or :math:`Q^{H}` is + If ``side=oneapi::math::side::right``, :math:`Q` or :math:`Q^{H}` is applied to :math:`C` from the right. trans - If ``trans=oneapi::mkl::transpose::nontrans``, the routine multiplies + If ``trans=oneapi::math::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. - If ``trans=oneapi::mkl::transpose::conjtrans``, the routine multiplies + If ``trans=oneapi::math::transpose::conjtrans``, the routine multiplies :math:`C` by :math:`Q^H`. m @@ -83,11 +83,11 @@ ldc This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -96,7 +96,7 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_unmqr` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_unmqr` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/unmrq.rst b/source/elements/oneMath/source/domains/lapack/unmrq.rst similarity index 62% rename from source/elements/oneMKL/source/domains/lapack/unmrq.rst rename to source/elements/oneMath/source/domains/lapack/unmrq.rst index c8f972f445..5f924c4418 100644 --- a/source/elements/oneMKL/source/domains/lapack/unmrq.rst +++ b/source/elements/oneMath/source/domains/lapack/unmrq.rst @@ -2,13 +2,13 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_unmrq: +.. _onemath_lapack_unmrq: unmrq ===== Multiplies a complex matrix by the unitary matrix :math:`Q` of the RQ -factorization formed by :ref:`onemkl_lapack_gerqf`. +factorization formed by :ref:`onemath_lapack_gerqf`. .. container:: section @@ -27,7 +27,7 @@ The routine multiplies a rectangular complex :math:`m \times n` matrix :math:`C` :math:`Q` or :math:`Q^H`, where :math:`Q` is the complex unitary matrix defined as a product of :math:`k` elementary reflectors :math:`H(i)` of order :math:`n`: :math:`Q = H(1)^HH(2)^H ... H(k)^H` as returned by the RQ factorization routine -:ref:`onemkl_lapack_gerqf`. +:ref:`onemath_lapack_gerqf`. Depending on the parameters ``side`` and ``trans``, the routine can form one of the matrix products :math:`QC`, :math:`Q^HC`, :math:`CQ`, or :math:`CQ^H` @@ -42,8 +42,8 @@ unmrq (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void unmrq(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &c, std::int64_t ldc, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void unmrq(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &c, std::int64_t ldc, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -54,17 +54,17 @@ queue The queue where the routine should be executed. side - If ``side = oneapi::mkl::side::left``, :math:`Q` or :math:`Q^{H}` is applied + If ``side = oneapi::math::side::left``, :math:`Q` or :math:`Q^{H}` is applied to :math:`C` from the left. - If ``side = oneapi::mkl::side::right``, :math:`Q` or :math:`Q^{H}` is + If ``side = oneapi::math::side::right``, :math:`Q` or :math:`Q^{H}` is applied to :math:`C` from the right. trans - If ``trans = oneapi::mkl::transpose::nontrans``, the routine multiplies + If ``trans = oneapi::math::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. - If ``trans = oneapi::mkl::transpose::conjtrans``, the routine multiplies :math:`C` + If ``trans = oneapi::math::transpose::conjtrans``, the routine multiplies :math:`C` by :math:`Q^{H}`. m @@ -77,19 +77,19 @@ k The number of elementary reflectors whose product defines the matrix :math:`Q` - If ``side = oneapi::mkl::side::left``, :math:`0 \le k \le m` + If ``side = oneapi::math::side::left``, :math:`0 \le k \le m` - If ``side = oneapi::mkl::side::right``, :math:`0 \le k \le n` + If ``side = oneapi::math::side::right``, :math:`0 \le k \le n` a - The buffer ``a`` as returned by :ref:`onemkl_lapack_gerqf`. + The buffer ``a`` as returned by :ref:`onemath_lapack_gerqf`. The second dimension of ``a`` must be at least :math:`\max(1,k)`. lda The leading dimension of ``a``. tau - The buffer ``tau`` as returned by :ref:`onemkl_lapack_gerqf`. + The buffer ``tau`` as returned by :ref:`onemath_lapack_gerqf`. c The buffer ``c`` contains the matrix :math:`C`. The second dimension of @@ -101,7 +101,7 @@ ldc scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by - :ref:`onemkl_lapack_unmrq_scratchpad_size` function. + :ref:`onemath_lapack_unmrq_scratchpad_size` function. .. container:: section @@ -120,17 +120,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -147,8 +147,8 @@ unmrq (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event unmrq(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, const T *a, std::int64_t lda, const T *tau, T *c, std::int64_t ldc, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event unmrq(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, const T *a, std::int64_t lda, const T *tau, T *c, std::int64_t ldc, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -159,17 +159,17 @@ queue The queue where the routine should be executed. side - If ``side = oneapi::mkl::side::left``, :math:`Q` or :math:`Q^{H}` is applied + If ``side = oneapi::math::side::left``, :math:`Q` or :math:`Q^{H}` is applied to :math:`C` from the left. - If ``side = oneapi::mkl::side::right``, :math:`Q` or :math:`Q^{H}` is + If ``side = oneapi::math::side::right``, :math:`Q` or :math:`Q^{H}` is applied to :math:`C` from the right. trans - If ``trans = oneapi::mkl::transpose::nontrans``, the routine multiplies + If ``trans = oneapi::math::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. - If ``trans = oneapi::mkl::transpose::conjtrans``, the routine multiplies :math:`C` + If ``trans = oneapi::math::transpose::conjtrans``, the routine multiplies :math:`C` by :math:`Q^{H}`. m @@ -182,19 +182,19 @@ k The number of elementary reflectors whose product defines the matrix :math:`Q` - If ``side = oneapi::mkl::side::left``, :math:`0 \le k \le m` + If ``side = oneapi::math::side::left``, :math:`0 \le k \le m` - If ``side = oneapi::mkl::side::right``, :math:`0 \le k \le n` + If ``side = oneapi::math::side::right``, :math:`0 \le k \le n` a - The pointer to ``a`` as returned by :ref:`onemkl_lapack_gerqf`. + The pointer to ``a`` as returned by :ref:`onemath_lapack_gerqf`. The second dimension of ``a`` must be at least :math:`\max(1,k)`. lda The leading dimension of ``a``. tau - The pointer to ``tau`` as returned by :ref:`onemkl_lapack_gerqf`. + The pointer to ``tau`` as returned by :ref:`onemath_lapack_gerqf`. c The pointer ``c`` points to the matrix :math:`C`. The second dimension of @@ -206,7 +206,7 @@ ldc scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. Size should not be less than the value returned by - :ref:`onemkl_lapack_unmrq_scratchpad_size` function. + :ref:`onemath_lapack_unmrq_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -228,17 +228,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -252,4 +252,4 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/unmrq_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/unmrq_scratchpad_size.rst similarity index 60% rename from source/elements/oneMKL/source/domains/lapack/unmrq_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/unmrq_scratchpad_size.rst index 644de58c9a..b99220b631 100644 --- a/source/elements/oneMKL/source/domains/lapack/unmrq_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/unmrq_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_unmrq_scratchpad_size: +.. _onemath_lapack_unmrq_scratchpad_size: unmrq_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_unmrq` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_unmrq` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_unmrq` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_unmrq` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_unmrq` function should be able to hold. Calls to this routine must specify the template parameter explicitly. unmrq_scratchpad_size @@ -34,9 +34,9 @@ unmrq_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t unmrq_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t ldc) + std::int64_t unmrq_scratchpad_size(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t k, std::int64_t lda, std::int64_t ldc) } .. container:: section @@ -47,12 +47,12 @@ queue Device queue where calculations by the unmrq function will be performed. side - If ``side = oneapi::mkl::side::left``, :math:`Q` or :math:`Q^T` is applied to :math:`C` from the left. If ``side = oneapi::mkl::side::right``, :math:`Q` or :math:`Q^T` is applied to :math:`C` from the right. + If ``side = oneapi::math::side::left``, :math:`Q` or :math:`Q^T` is applied to :math:`C` from the left. If ``side = oneapi::math::side::right``, :math:`Q` or :math:`Q^T` is applied to :math:`C` from the right. trans - If ``trans=oneapi::mkl::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. + If ``trans=oneapi::math::transpose::nontrans``, the routine multiplies :math:`C` by :math:`Q`. - If ``trans=oneapi::mkl::transpose::conjtrans``, the routine multiplies :math:`C` by :math:`Q^H`. + If ``trans=oneapi::math::transpose::conjtrans``, the routine multiplies :math:`C` by :math:`Q^H`. m The number of rows in the matrix :math:`C` (:math:`0 \le m`). @@ -75,11 +75,11 @@ ldc This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -88,7 +88,7 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_unmrq` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_unmrq` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-linear-equation-routines` +**Parent topic:** :ref:`onemath_lapack-linear-equation-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/unmtr.rst b/source/elements/oneMath/source/domains/lapack/unmtr.rst similarity index 76% rename from source/elements/oneMKL/source/domains/lapack/unmtr.rst rename to source/elements/oneMath/source/domains/lapack/unmtr.rst index b8df9d4a4f..99253c20d8 100644 --- a/source/elements/oneMKL/source/domains/lapack/unmtr.rst +++ b/source/elements/oneMath/source/domains/lapack/unmtr.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_unmtr: +.. _onemath_lapack_unmtr: unmtr ===== Multiplies a complex matrix by the complex unitary matrix Q determined by -:ref:`onemkl_lapack_hetrd`. +:ref:`onemath_lapack_hetrd`. .. container:: section @@ -26,10 +26,10 @@ determined by The routine multiplies a complex matrix :math:`C` by :math:`Q` or :math:`Q^{H}`, where :math:`Q` is the unitary matrix :math:`Q` formed by -:ref:`onemkl_lapack_hetrd` +:ref:`onemath_lapack_hetrd` when reducing a complex Hermitian matrix :math:`A` to tridiagonal form: :math:`A = QTQ^H`. Use this routine after a call to -:ref:`onemkl_lapack_hetrd`. +:ref:`onemath_lapack_hetrd`. Depending on the parameters ``side`` and ``trans``, the routine can form one of the matrix products :math:`QC`, :math:`Q^{H}C`, @@ -44,8 +44,8 @@ unmtr (Buffer Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - void unmtr(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::uplo upper_lower, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &c, std::int64_t ldc, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) + namespace oneapi::math::lapack { + void unmtr(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::uplo upper_lower, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, cl::sycl::buffer &a, std::int64_t lda, cl::sycl::buffer &tau, cl::sycl::buffer &c, std::int64_t ldc, cl::sycl::buffer &scratchpad, std::int64_t scratchpad_size) } .. container:: section @@ -79,7 +79,7 @@ side upper_lower Must be either ``uplo::upper`` or ``uplo::lower``. Uses the same ``upper_lower`` as supplied to - :ref:`onemkl_lapack_hetrd`. + :ref:`onemath_lapack_hetrd`. trans Must be either ``transpose::nontrans`` or @@ -103,14 +103,14 @@ k a The buffer ``a`` as returned by - :ref:`onemkl_lapack_hetrd`. + :ref:`onemath_lapack_hetrd`. lda The leading dimension of ``a`` :math:`(\text{lda} \ge \max(1,r))`. tau The buffer ``tau`` as returned by - :ref:`onemkl_lapack_hetrd`. The + :ref:`onemath_lapack_hetrd`. The dimension of ``tau`` must be at least :math:`\max(1,r-1)`. c @@ -122,7 +122,7 @@ ldc scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_unmtr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_unmtr_scratchpad_size` function. .. container:: section @@ -142,17 +142,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -169,8 +169,8 @@ unmtr (USM Version) .. code-block:: cpp - namespace oneapi::mkl::lapack { - cl::sycl::event unmtr(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::uplo upper_lower, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, const T *a, std::int64_t lda, const T *tau, T *c, std::int64_t ldc, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) + namespace oneapi::math::lapack { + cl::sycl::event unmtr(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::uplo upper_lower, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, const T *a, std::int64_t lda, const T *tau, T *c, std::int64_t ldc, T *scratchpad, std::int64_t scratchpad_size, const std::vector &events = {}) } .. container:: section @@ -204,7 +204,7 @@ side upper_lower Must be either ``uplo::upper`` or ``uplo::lower``. Uses the same ``upper_lower`` as supplied to - :ref:`onemkl_lapack_hetrd`. + :ref:`onemath_lapack_hetrd`. trans Must be either ``transpose::nontrans`` or @@ -228,14 +228,14 @@ k a The pointer to ``a`` as returned by - :ref:`onemkl_lapack_hetrd`. + :ref:`onemath_lapack_hetrd`. lda The leading dimension of ``a`` :math:`(\text{lda} \ge \max(1,r))`. tau The pointer to ``tau`` as returned by - :ref:`onemkl_lapack_hetrd`. The + :ref:`onemath_lapack_hetrd`. The dimension of ``tau`` must be at least :math:`\max(1,r-1)`. c @@ -247,7 +247,7 @@ ldc scratchpad_size Size of scratchpad memory as a number of floating point elements of type ``T``. - Size should not be less than the value returned by :ref:`onemkl_lapack_unmtr_scratchpad_size` function. + Size should not be less than the value returned by :ref:`onemath_lapack_unmtr_scratchpad_size` function. events List of events to wait for before starting computation. Defaults to empty list. @@ -270,17 +270,17 @@ scratchpad This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::host_bad_alloc` +:ref:`oneapi::math::host_bad_alloc` -:ref:`oneapi::mkl::device_bad_alloc` +:ref:`oneapi::math::device_bad_alloc` -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` -:ref:`oneapi::mkl::lapack::computation_error` +:ref:`oneapi::math::lapack::computation_error` Exception is thrown in case of problems during calculations. The ``info`` code of the problem can be obtained by `info()` method of exception object: @@ -294,5 +294,5 @@ This routine shall throw the following exceptions if the associated condition is Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/lapack/unmtr_scratchpad_size.rst b/source/elements/oneMath/source/domains/lapack/unmtr_scratchpad_size.rst similarity index 74% rename from source/elements/oneMKL/source/domains/lapack/unmtr_scratchpad_size.rst rename to source/elements/oneMath/source/domains/lapack/unmtr_scratchpad_size.rst index 350af6c9d3..0747ce57df 100644 --- a/source/elements/oneMKL/source/domains/lapack/unmtr_scratchpad_size.rst +++ b/source/elements/oneMath/source/domains/lapack/unmtr_scratchpad_size.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_lapack_unmtr_scratchpad_size: +.. _onemath_lapack_unmtr_scratchpad_size: unmtr_scratchpad_size ===================== -Computes size of scratchpad memory required for :ref:`onemkl_lapack_unmtr` function. +Computes size of scratchpad memory required for :ref:`onemath_lapack_unmtr` function. .. container:: section @@ -22,7 +22,7 @@ Computes size of scratchpad memory required for :ref:`onemkl_lapack_unmtr` funct * - ``std::complex`` * - ``std::complex`` -Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_unmtr` function should be able to hold. +Computes the number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_unmtr` function should be able to hold. Calls to this routine must specify the template parameter explicitly. unmtr_scratchpad_size @@ -34,9 +34,9 @@ unmtr_scratchpad_size .. code-block:: cpp - namespace oneapi::mkl::lapack { + namespace oneapi::math::lapack { template - std::int64_t unmtr_scratchpad_size(cl::sycl::queue &queue, oneapi::mkl::side side, oneapi::mkl::uplo upper_lower, oneapi::mkl::transpose trans, std::int64_t m, std::int64_t n, std::int64_t lda, std::int64_t ldc) + std::int64_t unmtr_scratchpad_size(cl::sycl::queue &queue, oneapi::math::side side, oneapi::math::uplo upper_lower, oneapi::math::transpose trans, std::int64_t m, std::int64_t n, std::int64_t lda, std::int64_t ldc) } .. container:: section @@ -56,7 +56,7 @@ In the descriptions below, ``r`` denotes the order of :math:`Q`: - if ``side = side::right`` queue - Device queue where calculations by :ref:`onemkl_lapack_unmtr` function will be performed. + Device queue where calculations by :ref:`onemath_lapack_unmtr` function will be performed. side Must be either ``side::left`` or ``side::right``. @@ -70,7 +70,7 @@ side upper_lower Must be either ``uplo::upper`` or ``uplo::lower``. Uses the same ``upper_lower`` as supplied to - :ref:`onemkl_lapack_hetrd`. + :ref:`onemath_lapack_hetrd`. trans Must be either ``transpose::nontrans`` or @@ -104,11 +104,11 @@ ldc This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here. -:ref:`oneapi::mkl::unimplemented` +:ref:`oneapi::math::unimplemented` -:ref:`oneapi::mkl::unsupported_device` +:ref:`oneapi::math::unsupported_device` -:ref:`oneapi::mkl::lapack::invalid_argument` +:ref:`oneapi::math::lapack::invalid_argument` Exception is thrown in case of incorrect supplied argument value. Position of wrong argument can be determined by `info()` method of exception object. @@ -117,7 +117,7 @@ This routine shall throw the following exceptions if the associated condition is .. rubric:: Return Value -The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemkl_lapack_unmtr` function should be able to hold. +The number of elements of type ``T`` the scratchpad memory to be passed to :ref:`onemath_lapack_unmtr` function should be able to hold. -**Parent topic:** :ref:`onemkl_lapack-singular-value-eigenvalue-routines` +**Parent topic:** :ref:`onemath_lapack-singular-value-eigenvalue-routines` diff --git a/source/elements/oneMKL/source/domains/matrix-storage.rst b/source/elements/oneMath/source/domains/matrix-storage.rst similarity index 99% rename from source/elements/oneMKL/source/domains/matrix-storage.rst rename to source/elements/oneMath/source/domains/matrix-storage.rst index edd660f6fb..0a854a7dc6 100644 --- a/source/elements/oneMKL/source/domains/matrix-storage.rst +++ b/source/elements/oneMath/source/domains/matrix-storage.rst @@ -11,7 +11,7 @@ Matrix Storage .. container:: - The oneMKL BLAS and LAPACK routines for DPC++ use several matrix and + The oneMath BLAS and LAPACK routines for DPC++ use several matrix and vector storage formats. These are the same formats used in traditional Fortran BLAS/LAPACK. LAPACK routines require column major layout. @@ -582,5 +582,5 @@ Matrix Storage }_\text{1 + (1-n) x incx}] \quad if \:incx \:< \:0 - **Parent topic:** :ref:`onemkl_dense_linear_algebra` + **Parent topic:** :ref:`onemath_dense_linear_algebra` diff --git a/source/elements/oneMath/source/domains/random_number_generators.inc.rst b/source/elements/oneMath/source/domains/random_number_generators.inc.rst new file mode 100644 index 0000000000..0f882e73d5 --- /dev/null +++ b/source/elements/oneMath/source/domains/random_number_generators.inc.rst @@ -0,0 +1,17 @@ +.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation +.. +.. SPDX-License-Identifier: CC-BY-4.0 + +.. _onemath_rng: + +Random Number Generators +------------------------- + +The |onemath_full_name| Random Number Generators provides a :ref:`set of routines ` implementing commonly +used :ref:`pseudorandom, quasi-random, and non-deterministic generators ` +with :ref:`continuous and discrete distributions `. + +.. toctree:: + :hidden: + + rng/onemath-rng-overview.rst diff --git a/source/elements/oneMKL/source/domains/rng/bibliography.rst b/source/elements/oneMath/source/domains/rng/bibliography.rst similarity index 99% rename from source/elements/oneMKL/source/domains/rng/bibliography.rst rename to source/elements/oneMath/source/domains/rng/bibliography.rst index be608650f9..7c58405953 100644 --- a/source/elements/oneMKL/source/domains/rng/bibliography.rst +++ b/source/elements/oneMath/source/domains/rng/bibliography.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_bibliography: +.. _onemath_rng_bibliography: Bibliography ============ diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-distributions-template-parameter-method.rst b/source/elements/oneMath/source/domains/rng/device_api/device-distributions-template-parameter-method.rst similarity index 97% rename from source/elements/oneMKL/source/domains/rng/device_api/device-distributions-template-parameter-method.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-distributions-template-parameter-method.rst index 8414a58097..88a2e2b130 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-distributions-template-parameter-method.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-distributions-template-parameter-method.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_distributions_method: +.. _onemath_device_rng_distributions_method: Distributions Template Parameter Method ======================================= diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-distributions.rst b/source/elements/oneMath/source/domains/rng/device_api/device-distributions.rst similarity index 77% rename from source/elements/oneMKL/source/domains/rng/device_api/device-distributions.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-distributions.rst index cf7e8d20d7..5f81b79f85 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-distributions.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-distributions.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_distributions: +.. _onemath_device_rng_distributions: Device Distributions ==================== -oneMKL RNG routines are used to generate random numbers with different types of distributions. Each function group is +oneMath RNG routines are used to generate random numbers with different types of distributions. Each function group is introduced below by the type of underlying distribution and contains a short description of its functionality, as well as specifications of the call sequence and the explanation of input and output parameters. The Device Continuous Distribution Generators table and Device Discrete Distribution Generators table mention random number generator routines @@ -23,27 +23,27 @@ basic random number generators. - Data Types - BRNG Data Type - Description - * - :ref:`onemkl_device_rng_uniform_continuous` + * - :ref:`onemath_device_rng_uniform_continuous` - float, double - float, double - Uniform continuous distribution on the interval [``a,b``) - * - :ref:`onemkl_device_rng_gaussian` + * - :ref:`onemath_device_rng_gaussian` - float, double - float, double - Normal (Gaussian) distribution - * - :ref:`onemkl_device_rng_exponential` + * - :ref:`onemath_device_rng_exponential` - float, double - float, double - Exponential distribution - * - :ref:`onemkl_device_rng_lognormal` + * - :ref:`onemath_device_rng_lognormal` - float, double - float, double - Lognormal distribution - * - :ref:`onemkl_device_rng_beta` + * - :ref:`onemath_device_rng_beta` - float, double - float, double - Beta distribution - * - :ref:`onemkl_device_rng_gamma` + * - :ref:`onemath_device_rng_gamma` - float, double - float, double - Gamma distribution @@ -58,30 +58,30 @@ basic random number generators. - Data Types - BRNG Data Type - Description - * - :ref:`onemkl_device_rng_uniform_discrete` + * - :ref:`onemath_device_rng_uniform_discrete` - integer - float - Uniform discrete distribution on the interval [``a,b``) - * - :ref:`onemkl_device_rng_bits` + * - :ref:`onemath_device_rng_bits` - integer - integer - Bits of underlying BRNG integer sequence - * - :ref:`onemkl_device_rng_uniform_bits` + * - :ref:`onemath_device_rng_uniform_bits` - integer - integer - Uniformly distributed bits in 32/64-bit chunks - * - :ref:`onemkl_device_rng_poisson` + * - :ref:`onemath_device_rng_poisson` - integer - integer - Poisson distribution - * - :ref:`onemkl_device_rng_bernoulli` + * - :ref:`onemath_device_rng_bernoulli` - integer - integer - Bernoulli distribution `NOTE:` In case of ``integer`` check desired distribution for supported data types. -**Parent topic:** :ref:`onemkl_device_rng_routines` +**Parent topic:** :ref:`onemath_device_rng_routines` .. toctree:: :maxdepth: 1 diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-engines.rst b/source/elements/oneMath/source/domains/rng/device_api/device-engines.rst similarity index 64% rename from source/elements/oneMKL/source/domains/rng/device_api/device-engines.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-engines.rst index 794f089f5e..91aa55a3f2 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-engines.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-engines.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_engines: +.. _onemath_device_rng_engines: Device Engines (Basic Random Number Generators) =============================================== -oneMKL RNG provides following device pseudorandom number generators: +oneMath RNG provides following device pseudorandom number generators: .. tabularcolumns:: |\Y{0.4}|\Y{0.6}| @@ -18,19 +18,19 @@ oneMKL RNG provides following device pseudorandom number generators: * - Routine - Description - * - :ref:`onemkl_device_rng_mrg32k3a` - - The combined multiple recursive pseudorandom number generator ``MRG32k3a`` [:ref:`L'Ecuyer99 `] + * - :ref:`onemath_device_rng_mrg32k3a` + - The combined multiple recursive pseudorandom number generator ``MRG32k3a`` [:ref:`L'Ecuyer99 `] - * - :ref:`onemkl_device_rng_philox4x32x10` - - Philox4x32-10 counter-based pseudorandom number generator with a period of :math:`2^{128}` ``PHILOX4X32X10`` [:ref:`Salmon11 `] + * - :ref:`onemath_device_rng_philox4x32x10` + - Philox4x32-10 counter-based pseudorandom number generator with a period of :math:`2^{128}` ``PHILOX4X32X10`` [:ref:`Salmon11 `] - * - :ref:`onemkl_device_rng_mcg31m1` - - The 31-bit multiplicative congruential pseudorandom number generator MCG(:math:`1132489760, 2^{32}-1`) :ref:`[L'Ecuyer99a] `. + * - :ref:`onemath_device_rng_mcg31m1` + - The 31-bit multiplicative congruential pseudorandom number generator MCG(:math:`1132489760, 2^{32}-1`) :ref:`[L'Ecuyer99a] `. - * - :ref:`onemkl_device_rng_mcg59` - - The 59-bit multiplicative congruential pseudorandom number generator MCG(:math:`13^{13}, 2^{59}`) from NAG Numerical Libraries :ref:`[NAG] `. + * - :ref:`onemath_device_rng_mcg59` + - The 59-bit multiplicative congruential pseudorandom number generator MCG(:math:`13^{13}, 2^{59}`) from NAG Numerical Libraries :ref:`[NAG] `. -**Parent topic:** :ref:`onemkl_device_rng_routines` +**Parent topic:** :ref:`onemath_device_rng_routines` .. toctree:: :maxdepth: 1 diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-bernoulli.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-bernoulli.rst similarity index 87% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-bernoulli.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-bernoulli.rst index 12697e31e9..c193011a50 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-bernoulli.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-bernoulli.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_bernoulli: +.. _onemath_device_rng_bernoulli: bernoulli ========= @@ -44,7 +44,7 @@ class bernoulli .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class bernoulli { public: @@ -76,13 +76,13 @@ class bernoulli .. container:: section - typename Method = oneapi::mkl::rng::bernoulli_method::by_default + typename Method = oneapi::math::rng::bernoulli_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::bernoulli_method::by_default`` - * ``oneapi::mkl::rng::bernoulli_method::icdf`` + * ``oneapi::math::rng::bernoulli_method::by_default`` + * ``oneapi::math::rng::bernoulli_method::icdf`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -164,7 +164,7 @@ class bernoulli .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when `p > 1`, or `p < 0` .. container:: section @@ -185,5 +185,5 @@ class bernoulli Returns the distribution parameter `p` - probability. -**Parent topic:** :ref:`onemkl_device_rng_distributions` +**Parent topic:** :ref:`onemath_device_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-beta.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-beta.rst similarity index 97% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-beta.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-beta.rst index d17a39d263..fcd6602e2b 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-beta.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-beta.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_beta: +.. _onemath_device_rng_beta: beta ==== @@ -39,7 +39,7 @@ class beta .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class beta { public: @@ -166,7 +166,7 @@ class beta .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`p \leq 0`, or :math:`q \leq 0`, or :math:`\beta \leq 0` .. container:: section @@ -244,4 +244,4 @@ class beta Returns the amount of random numbers that were rejected during the last ``generate`` function call. If no ``generate`` calls, ``0`` is returned. -**Parent topic:** :ref:`onemkl_device_rng_distributions` +**Parent topic:** :ref:`onemath_device_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-bits.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-bits.rst similarity index 83% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-bits.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-bits.rst index bee0775dd8..70dce2dae4 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-bits.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-bits.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_bits: +.. _onemath_device_rng_bits: bits ==== @@ -13,7 +13,7 @@ Generates bits of underlying engine (BRNG) integer sequence. The ``bits`` class object is used in ``generate`` and function to provide integer random values. Each integer can be treated as a vector of several bits. In pseudorandom generators -this randomness can be violated. See :ref:`VS Notes` for details. +this randomness can be violated. See :ref:`VS Notes` for details. class bits @@ -23,7 +23,7 @@ class bits .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class bits { using result_type = UIntType; @@ -58,4 +58,4 @@ class bits The type which defines type of generated random numbers. -**Parent topic:** :ref:`onemkl_device_rng_distributions` +**Parent topic:** :ref:`onemath_device_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-exponential.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-exponential.rst similarity index 87% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-exponential.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-exponential.rst index eab3a2b1d4..0ee577361a 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-exponential.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-exponential.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_exponential: +.. _onemath_device_rng_exponential: exponential =========== @@ -47,7 +47,7 @@ class exponential .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class exponential { public: @@ -77,14 +77,14 @@ class exponential .. container:: section - typename Method = oneapi::mkl::rng::exponential_method::by_default + typename Method = oneapi::math::rng::exponential_method::by_default Generation method. The specific values are as follows: - * ``oneapi::mkl::rng::device::exponential_method::by_default`` - * ``oneapi::mkl::rng::device::exponential_method::icdf`` - * ``oneapi::mkl::rng::device::exponential_method::icdf_accurate`` + * ``oneapi::math::rng::device::exponential_method::by_default`` + * ``oneapi::math::rng::device::exponential_method::icdf`` + * ``oneapi::math::rng::device::exponential_method::icdf_accurate`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -169,7 +169,7 @@ class exponential .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`beta \leq 0` .. container:: section @@ -204,4 +204,4 @@ class exponential Returns the distribution parameter `beta` - scalefactor value. -**Parent topic:** :ref:`onemkl_device_rng_distributions` +**Parent topic:** :ref:`onemath_device_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-gamma.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-gamma.rst similarity index 96% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-gamma.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-gamma.rst index 40a2b6cc3b..b8a049a54e 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-gamma.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-gamma.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_gamma: +.. _onemath_device_rng_gamma: gamma ===== @@ -37,7 +37,7 @@ class gamma .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class gamma { public: @@ -161,7 +161,7 @@ class gamma .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`alpha \leq 0` or :math:`beta \leq 0` .. container:: section @@ -225,4 +225,4 @@ class gamma Returns the amount of random numbers that were rejected during the last ``generate`` function call. If no ``generate`` calls, ``0`` is returned. -**Parent topic:** :ref:`onemkl_device_rng_distributions` +**Parent topic:** :ref:`onemath_device_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-gaussian.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-gaussian.rst similarity index 91% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-gaussian.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-gaussian.rst index f809fce6b4..f31cf32eec 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-gaussian.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-gaussian.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_gaussian: +.. _onemath_device_rng_gaussian: gaussian ======== @@ -56,7 +56,7 @@ class gaussian .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class gaussian { public: @@ -88,10 +88,10 @@ class gaussian typename Method Generation method. The specific values are as follows: - * ``oneapi::mkl::rng::device::gaussian_method::by_default`` - * ``oneapi::mkl::rng::device::gaussian_method::box_muller2`` + * ``oneapi::math::rng::device::gaussian_method::by_default`` + * ``oneapi::math::rng::device::gaussian_method::box_muller2`` - See description of the methods in :ref:`Distributions methods template parameter` + See description of the methods in :ref:`Distributions methods template parameter` .. container:: section @@ -175,7 +175,7 @@ class gaussian .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when `stddev` :math:`\leq 0` .. container:: section @@ -210,4 +210,4 @@ class gaussian Returns the distribution parameter `stddev` - standard deviation value. -**Parent topic:** :ref:`onemkl_device_rng_distributions` +**Parent topic:** :ref:`onemath_device_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-generate-routines.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-generate-routines.rst similarity index 62% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-generate-routines.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-generate-routines.rst index 8b60e7429e..99dd43731d 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-generate-routines.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-generate-routines.rst @@ -2,13 +2,13 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_generate_routines: +.. _onemath_device_rng_generate_routines: Device Generate Routines ======================== -Use the :ref:`onemkl_device_rng_generate` routine to obtain random numbers from a given engine with proper +Use the :ref:`onemath_device_rng_generate` routine to obtain random numbers from a given engine with proper statistics of a given distribution. .. toctree:: diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-generate.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-generate.rst similarity index 78% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-generate.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-generate.rst index 02e62390c2..5a29df4f50 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-generate.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-generate.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_generate: +.. _onemath_device_rng_generate: generate ======== @@ -15,7 +15,7 @@ Entry point to obtain random numbers from a given engine with proper statistics .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template auto generate(Distr& distr, Engine& engine) -> typename std::conditional` with generated random numbers. -**Parent topic:** :ref:`onemkl_device_rng_generate_routines` +**Parent topic:** :ref:`onemath_device_rng_generate_routines` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-lognormal.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-lognormal.rst similarity index 91% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-lognormal.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-lognormal.rst index d9e065a5af..62b0aa01d6 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-lognormal.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-lognormal.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_lognormal: +.. _onemath_device_rng_lognormal: lognormal ========= @@ -49,7 +49,7 @@ class lognormal .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class lognormal { public: @@ -80,13 +80,13 @@ class lognormal .. container:: section - typename Method = oneapi::mkl::rng::lognormal_method::by_default + typename Method = oneapi::math::rng::lognormal_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::device::lognormal_method::by_default`` - * ``oneapi::mkl::rng::device::lognormal_method::box_muller2`` + * ``oneapi::math::rng::device::lognormal_method::by_default`` + * ``oneapi::math::rng::device::lognormal_method::box_muller2`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -176,7 +176,7 @@ class lognormal .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`s \leq 0`, or :math:`scale \leq 0` .. container:: section @@ -239,4 +239,4 @@ class lognormal Returns the distribution parameter `scale` - scalefactor value. -**Parent topic:** :ref:`onemkl_device_rng_distributions` +**Parent topic:** :ref:`onemath_device_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-mcg31m1.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-mcg31m1.rst similarity index 93% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-mcg31m1.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-mcg31m1.rst index 263335ac30..9ef7ff8ab8 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-mcg31m1.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-mcg31m1.rst @@ -2,16 +2,16 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_mcg31m1: +.. _onemath_device_rng_mcg31m1: mcg31m1 ======= -The 31-bit multiplicative congruential pseudorandom number generator MCG(:math:`1132489760, 2^{32}-1`) :ref:`[L'Ecuyer99a] `. +The 31-bit multiplicative congruential pseudorandom number generator MCG(:math:`1132489760, 2^{32}-1`) :ref:`[L'Ecuyer99a] `. .. rubric:: Description -The mcg31m1 engine is a 31-bit multiplicative congruential generator :ref:`[L'Ecuyer99] `. +The mcg31m1 engine is a 31-bit multiplicative congruential generator :ref:`[L'Ecuyer99] `. The mcg31m1 generator belongs to linear congruential generators with the period length of approximately :math:`2^{31}`. Such generators are still used as default random number generators in various software systems, mainly due to the simplicity of the portable versions implementation, speed, and compatibility with the earlier systems versions. @@ -36,7 +36,7 @@ class mcg31m1 .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class mcg31m1 { public: @@ -98,4 +98,4 @@ class mcg31m1 offset Number of skipped elements. -**Parent topic:** :ref:`onemkl_device_rng_engines` +**Parent topic:** :ref:`onemath_device_rng_engines` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-mcg59.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-mcg59.rst similarity index 92% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-mcg59.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-mcg59.rst index 0d615c636e..61f66edba5 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-mcg59.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-mcg59.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_mcg59: +.. _onemath_device_rng_mcg59: mcg59 ===== @@ -12,7 +12,7 @@ from NAG Numerical Libraries. .. rubric:: Description -The mcg59 engine is a 59-bit multiplicative congruential generator from NAG Numerical Libraries :ref:`NAG `. +The mcg59 engine is a 59-bit multiplicative congruential generator from NAG Numerical Libraries :ref:`NAG `. The mcg59 generator belongs to linear congruential generators with the period length of approximately :math:`2^{57}`. .. container:: section @@ -32,7 +32,7 @@ class mcg59 .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class mcg59 { public: @@ -94,4 +94,4 @@ class mcg59 offset Number of skipped elements. -**Parent topic:** :ref:`onemkl_device_rng_engines` +**Parent topic:** :ref:`onemath_device_rng_engines` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-mrg32k3a.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-mrg32k3a.rst similarity index 97% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-mrg32k3a.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-mrg32k3a.rst index ffd3125198..3bc1c3964a 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-mrg32k3a.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-mrg32k3a.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_mrg32k3a: +.. _onemath_device_rng_mrg32k3a: mrg32k3a ======== @@ -12,7 +12,7 @@ The combined multiple recursive pseudorandom number generator MRG32k3a. .. rubric:: Description MRG32k3a engine is a 32-bit combined multiple recursive generator with two components of order 3 -[:ref:`L'Ecuyer99a`]. MRG32k3a combined generator meets the requirements for +[:ref:`L'Ecuyer99a`]. MRG32k3a combined generator meets the requirements for modern RNGs, such as good multidimensional uniformity, or a long period (:math:`p \approx 2^{191}`). @@ -41,7 +41,7 @@ class mrg32k3a .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class mrg32k3a { public: @@ -210,4 +210,4 @@ class mrg32k3a offset Number of skipped elements. Offset is calculated as: ``num_to_skip`` [0]+ ``num_to_skip`` [1]*2\ :sup:`64` + ``num_to_skip`` [2]\* 2\ :sup:`128` + … + ``num_to_skip`` [``n``-1]\*2\ :sup:`64` \*(``n``-1). -**Parent topic:** :ref:`onemkl_device_rng_engines` +**Parent topic:** :ref:`onemath_device_rng_engines` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-philox4x32x10.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-philox4x32x10.rst similarity index 96% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-philox4x32x10.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-philox4x32x10.rst index d5f51b8068..c09f51c79f 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-philox4x32x10.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-philox4x32x10.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_philox4x32x10: +.. _onemath_device_rng_philox4x32x10: philox4x32x10 ============= -A Philox4x32-10 counter-based pseudorandom number generator [:ref:`Salmon11`]. +A Philox4x32-10 counter-based pseudorandom number generator [:ref:`Salmon11`]. .. rubric:: Description @@ -17,7 +17,7 @@ The Philox4x32x10 engine is a keyed family of generator of counter-based BRNG. T .. rubric:: Generation algorithm - The generator has 32-bit integer output obtained in the following way [:ref:`Salmon11 `]: + The generator has 32-bit integer output obtained in the following way [:ref:`Salmon11 `]: 1. :math:`c_n=c_{n-1} + 1` 2. :math:`\omega_n = f(c_n)`, where :math:`f` is a function that takes 128-bit argument and returns a 128-bit number. The returned number is obtained as follows: @@ -51,7 +51,7 @@ class philox4x32x10 .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class philox4x32x10 { public: @@ -189,4 +189,4 @@ class philox4x32x10 offset Number of skipped elements. Offset is calculated as: ``num_to_skip`` [0]+ ``num_to_skip`` [1]*2\ :sup:`64` + ``num_to_skip`` [2]\* 2\ :sup:`128` + … + ``num_to_skip`` [``n``-1]\*2\ :sup:`64` \*(``n``-1). -**Parent topic:** :ref:`onemkl_device_rng_engines` +**Parent topic:** :ref:`onemath_device_rng_engines` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-poisson.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-poisson.rst similarity index 87% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-poisson.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-poisson.rst index 63b1167cd6..909973bad7 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-poisson.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-poisson.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_poisson: +.. _onemath_device_rng_poisson: poisson ======= @@ -42,7 +42,7 @@ class poisson .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class poisson { public: @@ -70,13 +70,13 @@ class poisson .. container:: section - typename Method = oneapi::mkl::rng::poisson_method::by_default + typename Method = oneapi::math::rng::poisson_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::device::poisson_method::by_default`` - * ``oneapi::mkl::rng::device::poisson_method::devroye`` + * ``oneapi::math::rng::device::poisson_method::by_default`` + * ``oneapi::math::rng::device::poisson_method::devroye`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -158,7 +158,7 @@ class poisson .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`lambda \leq 0` .. container:: section @@ -179,4 +179,4 @@ class poisson Returns the distribution parameter `lambda`. -**Parent topic:** :ref:`onemkl_device_rng_distributions` +**Parent topic:** :ref:`onemath_device_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-skip-ahead.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-skip-ahead.rst similarity index 90% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-skip-ahead.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-skip-ahead.rst index 173b3f782c..16dbe29183 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-skip-ahead.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-skip-ahead.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_skip_ahead: +.. _onemath_device_rng_skip_ahead: skip_ahead ========== @@ -25,7 +25,7 @@ skip_ahead .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template void skip_ahead (Engine& engine, std::uint64_t num_to_skip) } @@ -52,7 +52,7 @@ skip_ahead .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template void skip_ahead (Engine& engine, std::initializer_list num_to_skip) } @@ -76,4 +76,4 @@ skip_ahead would be: :math:`num\_to\_skip[0] + num\_to\_skip[1] \cdot 2^{64} + ... + num\_to\_skip[1] \cdot 2^{64 (n - 1)}`, where `n` is a number of elements in `num_to_skip` list. -**Parent topic:** :ref:`onemkl_device_rng_service_routines` +**Parent topic:** :ref:`onemath_device_rng_service_routines` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-uniform-bits.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-uniform-bits.rst similarity index 86% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-uniform-bits.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-uniform-bits.rst index 56bc8cf7d2..84a7aee4fc 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-uniform-bits.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-uniform-bits.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_uniform_bits: +.. _onemath_device_rng_uniform_bits: uniform_bits ============ @@ -16,7 +16,7 @@ in 32/64-bit chunks. It is designed to ensure each bit in the 32/64-bit chunk is is supported for philox4x32x10 and mcg59 engines. When generating 64-bit chunks, twice as much engine offset needs to be provided. -``UIntType`` denotes the chunk size and can be ``std::uint32_t``, ``std::uint64_t``. See :ref:`VS Notes` for details. +``UIntType`` denotes the chunk size and can be ``std::uint32_t``, ``std::uint64_t``. See :ref:`VS Notes` for details. class uniform_bits @@ -26,7 +26,7 @@ class uniform_bits .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class uniform_bits { using result_type = UIntType; @@ -61,4 +61,4 @@ class uniform_bits The type which defines type of generated random numbers. -**Parent topic:** :ref:`onemkl_device_rng_distributions` +**Parent topic:** :ref:`onemath_device_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-uniform-continuous.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-uniform-continuous.rst similarity index 89% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-uniform-continuous.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-uniform-continuous.rst index ef218522cf..8ce4ac3532 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-uniform-continuous.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-uniform-continuous.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_uniform_continuous: +.. _onemath_device_rng_uniform_continuous: uniform (Continuous) ==================== @@ -48,7 +48,7 @@ class uniform .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class uniform { public: @@ -81,11 +81,11 @@ class uniform typename Method Generation method. The specific values are as follows: - * ``oneapi::mkl::rng::device::uniform_method::by_default`` - * ``oneapi::mkl::rng::device::uniform_method::standard`` - * ``oneapi::mkl::rng::device::uniform_method::accurate`` + * ``oneapi::math::rng::device::uniform_method::by_default`` + * ``oneapi::math::rng::device::uniform_method::standard`` + * ``oneapi::math::rng::device::uniform_method::accurate`` - See description of the methods in :ref:`Distributions methods template parameter` + See description of the methods in :ref:`Distributions methods template parameter` .. container:: section @@ -170,7 +170,7 @@ class uniform .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`a \ge b` .. container:: section @@ -205,4 +205,4 @@ class uniform Returns the distribution parameter `b` - right bound. -**Parent topic:** :ref:`onemkl_device_rng_distributions` +**Parent topic:** :ref:`onemath_device_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-uniform-discrete.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-uniform-discrete.rst similarity index 86% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-uniform-discrete.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-uniform-discrete.rst index a3b632a69a..1712a33cc5 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-uniform-discrete.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-uniform-discrete.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_uniform_discrete: +.. _onemath_device_rng_uniform_discrete: uniform (Discrete) ================== @@ -45,7 +45,7 @@ class uniform .. code-block:: cpp - namespace oneapi::mkl::rng::device { + namespace oneapi::math::rng::device { template class uniform { public: @@ -77,14 +77,14 @@ class uniform .. container:: section - typename Method = oneapi::mkl::rng::uniform_method::by_default + typename Method = oneapi::math::rng::uniform_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::device::uniform_method::by_default`` - * ``oneapi::mkl::rng::device::uniform_method::standard`` - * ``oneapi::mkl::rng::device::uniform_method::accurate`` + * ``oneapi::math::rng::device::uniform_method::by_default`` + * ``oneapi::math::rng::device::uniform_method::standard`` + * ``oneapi::math::rng::device::uniform_method::accurate`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -142,7 +142,7 @@ class uniform .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`a \ge b` .. container:: section @@ -177,4 +177,4 @@ class uniform Returns the distribution parameter `b` - right bound. -**Parent topic:** :ref:`onemkl_device_rng_distributions` +**Parent topic:** :ref:`onemath_device_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-usage-model.rst b/source/elements/oneMath/source/domains/rng/device_api/device-rng-usage-model.rst similarity index 68% rename from source/elements/oneMKL/source/domains/rng/device_api/device-rng-usage-model.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-rng-usage-model.rst index 15c65c6631..697feb7bd3 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-rng-usage-model.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-rng-usage-model.rst @@ -2,17 +2,17 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_usage_model: +.. _onemath_device_rng_usage_model: -oneMKL RNG Device Usage Model -============================= +oneMath RNG Device Usage Model +============================== .. contents:: :local: :depth: 1 A typical usage model for device routines is the same as described in -:ref:`onemkl_rng_usage_model`: +:ref:`onemath_rng_usage_model`: #. Create and initialize the object for basic random number generator. @@ -27,7 +27,7 @@ Example of Scalar Random Numbers Generation .. code-block:: cpp - #include "oneapi/mkl/rng/device.hpp" + #include "oneapi/math/rng/device.hpp" int main() { sycl::queue q; @@ -37,11 +37,11 @@ Example of Scalar Random Numbers Generation // ... cgh.parallel_for(n, [=](size_t idx) { // Create an engine object - oneapi::mkl::rng::device::philox4x32x10<> engine(seed, idx); + oneapi::math::rng::device::philox4x32x10<> engine(seed, idx); // Create a distribution object - oneapi::mkl::rng::device::uniform distr; + oneapi::math::rng::device::uniform distr; // Call generate function to obtain scalar random number - float res = oneapi::mkl::rng::device::generate(distr, engine); + float res = oneapi::math::rng::device::generate(distr, engine); // ... }); }); @@ -53,7 +53,7 @@ Example of Vector Random Numbers Generation .. code-block:: cpp - #include "oneapi/mkl/rng/device.hpp" + #include "oneapi/math/rng/device.hpp" int main() { sycl::queue q; @@ -63,15 +63,15 @@ Example of Vector Random Numbers Generation // ... cgh.parallel_for((n / vec_size), [=](size_t idx) { // Create an engine object - oneapi::mkl::rng::device::philox4x32x10 engine(seed, idx * vec_size); + oneapi::math::rng::device::philox4x32x10 engine(seed, idx * vec_size); // Create a distribution object - oneapi::mkl::rng::device::uniform distr; + oneapi::math::rng::device::uniform distr; // Call generate function to obtain random numbers - sycl::vec res = oneapi::mkl::rng::device::generate(distr, engine); + sycl::vec res = oneapi::math::rng::device::generate(distr, engine); // ... }); }); // ... } -**Parent topic:** :ref:`onemkl_device_rng_routines` +**Parent topic:** :ref:`onemath_device_rng_routines` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-routines.rst b/source/elements/oneMath/source/domains/rng/device_api/device-routines.rst similarity index 73% rename from source/elements/oneMKL/source/domains/rng/device_api/device-routines.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-routines.rst index 16e7d7664e..022775085b 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-routines.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-routines.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_routines: +.. _onemath_device_rng_routines: Random Number Generators Device Routines ======================================== @@ -15,11 +15,11 @@ The main purpose of Device routines is to make them callable from your SYCL kern queue.submit([&](sycl::handler& cgh) { cgh.parallel_for(range,[=](...) { - oneapi::mkl::rng::device::routine(...); // calling routine from user's kernel code + oneapi::math::rng::device::routine(...); // calling routine from user's kernel code }); }); - oneapi::mkl::rng::device::routine(...); // calling routine from host + oneapi::math::rng::device::routine(...); // calling routine from host .. rubric:: Structure @@ -27,26 +27,26 @@ RNG domain contains two classes types: - Engines (basic random number generators) classes, which holds the state of generator and is a source of independent and identically distributed random variables. - Refer to :ref:`onemkl_rng_engines_basic_random_number_generators` + Refer to :ref:`onemath_rng_engines_basic_random_number_generators` for a detailed description. - Distribution classes templates (transformation classes) for different types of statistical distributions, for example, uniform, normal (Gaussian), binomial, etc. These classes contain all of the distribution’s parameters - (including generation method). Refer to :ref:`onemkl_device_rng_distributions` for + (including generation method). Refer to :ref:`onemath_device_rng_distributions` for a detailed description of the distributions. The RNG domain also contains two types of free functions: - Generation routines. The current routines are used to obtain random numbers from a given engine with proper statistics defined by a - given distribution. Refer to the :ref:`onemkl_device_rng_generate_routines` + given distribution. Refer to the :ref:`onemath_device_rng_generate_routines` section for a detailed description. - - Service routines. The routines are used to modify the engine state. Refer to :ref:`onemkl_device_rng_service_routines` for a + - Service routines. The routines are used to modify the engine state. Refer to :ref:`onemath_device_rng_service_routines` for a description of these routines. Engine classes work with both generation and service routines. Distribution classes are used in -generation routines only. Refer to the :ref:`onemkl_device_rng_usage_model` +generation routines only. Refer to the :ref:`onemath_device_rng_usage_model` section for the description of typical RNG scenario. .. toctree:: @@ -59,4 +59,4 @@ section for the description of typical RNG scenario. device-service-routines.rst ../bibliography.rst -**Parent topic:** :ref:`onemkl_rng` +**Parent topic:** :ref:`onemath_rng` diff --git a/source/elements/oneMKL/source/domains/rng/device_api/device-service-routines.rst b/source/elements/oneMath/source/domains/rng/device_api/device-service-routines.rst similarity index 76% rename from source/elements/oneMKL/source/domains/rng/device_api/device-service-routines.rst rename to source/elements/oneMath/source/domains/rng/device_api/device-service-routines.rst index cf04188904..f19fdc05ea 100644 --- a/source/elements/oneMKL/source/domains/rng/device_api/device-service-routines.rst +++ b/source/elements/oneMath/source/domains/rng/device_api/device-service-routines.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_device_rng_service_routines: +.. _onemath_device_rng_service_routines: Device Service Routines ======================= @@ -15,7 +15,7 @@ Device Service Routines * - Routine - Description - * - :ref:`onemkl_device_rng_skip_ahead` + * - :ref:`onemath_device_rng_skip_ahead` - Proceed state of engine by the skip-ahead method to skip a given number of elements from the original sequence. .. toctree:: @@ -24,4 +24,4 @@ Device Service Routines device-rng-skip-ahead.rst -**Parent topic:** :ref:`onemkl_device_rng_routines` \ No newline at end of file +**Parent topic:** :ref:`onemath_device_rng_routines` \ No newline at end of file diff --git a/source/elements/oneMKL/source/domains/rng/host_api/distributions-template-parameter-mkl-rng-method-values.rst b/source/elements/oneMath/source/domains/rng/host_api/distributions-template-parameter-onemath-rng-method-values.rst similarity index 98% rename from source/elements/oneMKL/source/domains/rng/host_api/distributions-template-parameter-mkl-rng-method-values.rst rename to source/elements/oneMath/source/domains/rng/host_api/distributions-template-parameter-onemath-rng-method-values.rst index 741fc34c97..d575c6f951 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/distributions-template-parameter-mkl-rng-method-values.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/distributions-template-parameter-onemath-rng-method-values.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_distributions_template_parameter_mkl_rng_method_values: +.. _onemath_rng_distributions_template_parameter_onemath_rng_method_values: Distributions Template Parameter Method ======================================= @@ -96,4 +96,4 @@ Distributions Template Parameter Method - Inverse cumulative distribution function (ICDF) method. **Parent -topic:** :ref:`onemkl_rng_distributions` +topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/distributions.rst b/source/elements/oneMath/source/domains/rng/host_api/distributions.rst similarity index 54% rename from source/elements/oneMKL/source/domains/rng/host_api/distributions.rst rename to source/elements/oneMath/source/domains/rng/host_api/distributions.rst index 8308f0783b..fb9d285709 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/distributions.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/distributions.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_distributions: +.. _onemath_rng_distributions: Host Distributions ================== @@ -11,7 +11,7 @@ Host Distributions .. container:: - oneMKL RNG routines are used to generate random + oneMath RNG routines are used to generate random numbers with different types of distribution. Each function group is introduced below by the type of underlying distribution and contains a short description of its functionality, as well as specifications @@ -33,31 +33,31 @@ Host Distributions * - Routine - Description - * - \ :ref:`onemkl_rng_uniform_continuous`\ + * - \ :ref:`onemath_rng_uniform_continuous`\ - Uniform continuous distribution on the interval [``a,b``) - * - \ :ref:`onemkl_rng_gaussian`\ + * - \ :ref:`onemath_rng_gaussian`\ - Normal (Gaussian) distribution - * - \ :ref:`onemkl_rng_exponential`\ + * - \ :ref:`onemath_rng_exponential`\ - Exponential distribution - * - \ :ref:`onemkl_rng_laplace`\ + * - \ :ref:`onemath_rng_laplace`\ - Laplace distribution (double exponential distribution) - * - \ :ref:`onemkl_rng_weibull`\ + * - \ :ref:`onemath_rng_weibull`\ - Weibull distribution - * - \ :ref:`onemkl_rng_cauchy`\ + * - \ :ref:`onemath_rng_cauchy`\ - Cauchy distribution - * - \ :ref:`onemkl_rng_rayleigh`\ + * - \ :ref:`onemath_rng_rayleigh`\ - Rayleigh distribution - * - \ :ref:`onemkl_rng_lognormal`\ + * - \ :ref:`onemath_rng_lognormal`\ - Lognormal distribution - * - \ :ref:`onemkl_rng_gumbel`\ + * - \ :ref:`onemath_rng_gumbel`\ - Gumbel (extreme value) distribution - * - \ :ref:`onemkl_rng_gamma`\ + * - \ :ref:`onemath_rng_gamma`\ - Gamma distribution - * - \ :ref:`onemkl_rng_beta`\ + * - \ :ref:`onemath_rng_beta`\ - Beta distribution - * - \ :ref:`onemkl_rng_chi_square`\ + * - \ :ref:`onemath_rng_chi_square`\ - Chi-Square distribution - * - \ :ref:`onemkl_rng_gaussian_mv`\ + * - \ :ref:`onemath_rng_gaussian_mv`\ - Normal Multivariate (Gaussian Multivariate) distribution @@ -71,27 +71,27 @@ Host Distributions * - Type of Distribution - Description - * - \ :ref:`onemkl_rng_uniform_discrete`\ + * - \ :ref:`onemath_rng_uniform_discrete`\ - Uniform discrete distribution on the interval [``a,b``) - * - \ :ref:`onemkl_rng_uniform_bits`\ + * - \ :ref:`onemath_rng_uniform_bits`\ - Uniformly distributed bits in 32/64-bit chunks - * - \ :ref:`onemkl_rng_bits`\ + * - \ :ref:`onemath_rng_bits`\ - Bits of underlying BRNG integer recurrence - * - \ :ref:`onemkl_rng_bernoulli`\ + * - \ :ref:`onemath_rng_bernoulli`\ - Bernoulli distribution - * - \ :ref:`onemkl_rng_geometric`\ + * - \ :ref:`onemath_rng_geometric`\ - Geometric distribution - * - \ :ref:`onemkl_rng_binomial`\ + * - \ :ref:`onemath_rng_binomial`\ - Binomial distribution - * - \ :ref:`onemkl_rng_hypergeometric`\ + * - \ :ref:`onemath_rng_hypergeometric`\ - Hypergeometric distribution - * - \ :ref:`onemkl_rng_poisson`\ + * - \ :ref:`onemath_rng_poisson`\ - Poisson distribution - * - \ :ref:`onemkl_rng_poisson_v`\ + * - \ :ref:`onemath_rng_poisson_v`\ - Poisson distribution with varying mean - * - \ :ref:`onemkl_rng_negative_binomial`\ + * - \ :ref:`onemath_rng_negative_binomial`\ - Negative binomial distribution, or Pascal distribution - * - \ :ref:`onemkl_rng_multinomial`\ + * - \ :ref:`onemath_rng_multinomial`\ - Multinomial distribution @@ -127,50 +127,50 @@ Host Distributions * - Distribution - Method - * - \ :ref:`onemkl_rng_uniform_continuous`\ - - `oneapi::mkl::rng::unform_method::accurate` - * - \ :ref:`onemkl_rng_exponential`\ - - `oneapi::mkl::rng::exponential_method::icdf_accurate` - * - \ :ref:`onemkl_rng_weibull`\ - - `oneapi::mkl::rng::weibull_method::icdf_accurate` - * - \ :ref:`onemkl_rng_rayleigh`\ - - `oneapi::mkl::rng::rayleigh_method::icdf_accurate` - * - \ :ref:`onemkl_rng_lognormal`\ - - `oneapi::mkl::rng::lognormal_method::box_muller2_accurate`, `oneapi::mkl::rng::lognormal_method::icdf_accurate` - * - \ :ref:`onemkl_rng_gamma`\ - - `oneapi::mkl::rng::gamma_method::marsaglia_accurate` - * - \ :ref:`onemkl_rng_beta`\ - - `oneapi::mkl::rng::beta_method::cja_accurate` + * - \ :ref:`onemath_rng_uniform_continuous`\ + - `oneapi::math::rng::unform_method::accurate` + * - \ :ref:`onemath_rng_exponential`\ + - `oneapi::math::rng::exponential_method::icdf_accurate` + * - \ :ref:`onemath_rng_weibull`\ + - `oneapi::math::rng::weibull_method::icdf_accurate` + * - \ :ref:`onemath_rng_rayleigh`\ + - `oneapi::math::rng::rayleigh_method::icdf_accurate` + * - \ :ref:`onemath_rng_lognormal`\ + - `oneapi::math::rng::lognormal_method::box_muller2_accurate`, `oneapi::math::rng::lognormal_method::icdf_accurate` + * - \ :ref:`onemath_rng_gamma`\ + - `oneapi::math::rng::gamma_method::marsaglia_accurate` + * - \ :ref:`onemath_rng_beta`\ + - `oneapi::math::rng::beta_method::cja_accurate`   - **Parent topic:** :ref:`onemkl_rng_manual_offload_routines` + **Parent topic:** :ref:`onemath_rng_manual_offload_routines` .. toctree:: :hidden: - distributions-template-parameter-mkl-rng-method-values - mkl-rng-uniform-continuous - mkl-rng-gaussian - mkl-rng-exponential - mkl-rng-laplace - mkl-rng-weibull - mkl-rng-cauchy - mkl-rng-rayleigh - mkl-rng-lognormal - mkl-rng-gumbel - mkl-rng-gamma - mkl-rng-beta - mkl-rng-chi_square - mkl-rng-gaussian_mv - mkl-rng-uniform-discrete - mkl-rng-uniform_bits - mkl-rng-bits - mkl-rng-bernoulli - mkl-rng-geometric - mkl-rng-binomial - mkl-rng-hypergeometric - mkl-rng-poisson - mkl-rng-poisson_v - mkl-rng-negbinomial - mkl-rng-multinomial + distributions-template-parameter-onemath-rng-method-values + onemath-rng-uniform-continuous + onemath-rng-gaussian + onemath-rng-exponential + onemath-rng-laplace + onemath-rng-weibull + onemath-rng-cauchy + onemath-rng-rayleigh + onemath-rng-lognormal + onemath-rng-gumbel + onemath-rng-gamma + onemath-rng-beta + onemath-rng-chi_square + onemath-rng-gaussian_mv + onemath-rng-uniform-discrete + onemath-rng-uniform_bits + onemath-rng-bits + onemath-rng-bernoulli + onemath-rng-geometric + onemath-rng-binomial + onemath-rng-hypergeometric + onemath-rng-poisson + onemath-rng-poisson_v + onemath-rng-negbinomial + onemath-rng-multinomial diff --git a/source/elements/oneMKL/source/domains/rng/host_api/engines-basic-random-number-generators.rst b/source/elements/oneMath/source/domains/rng/host_api/engines-basic-random-number-generators.rst similarity index 57% rename from source/elements/oneMKL/source/domains/rng/host_api/engines-basic-random-number-generators.rst rename to source/elements/oneMath/source/domains/rng/host_api/engines-basic-random-number-generators.rst index 5b4b6a2ce6..f997f52503 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/engines-basic-random-number-generators.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/engines-basic-random-number-generators.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_engines_basic_random_number_generators: +.. _onemath_rng_engines_basic_random_number_generators: Host Engines (Basic Random Number Generators) ============================================= @@ -11,7 +11,7 @@ Host Engines (Basic Random Number Generators) .. container:: - oneMKL RNG provides pseudorandom, quasi-random, and non-deterministic + oneMath RNG provides pseudorandom, quasi-random, and non-deterministic random number generators for Data Parallel C++: @@ -23,43 +23,43 @@ Host Engines (Basic Random Number Generators) * - Routine - Description - * - \ :ref:`onemkl_rng_default_engine`\ + * - \ :ref:`onemath_rng_default_engine`\ - The default random engine - * - \ :ref:`onemkl_rng_mrg32k3a`\ - - The combined multiple recursive pseudorandom number generator ``MRG32k3a``\ :ref:`[L'Ecuyer99a] `\ - * - \ :ref:`onemkl_rng_philox4x32x10`\ - - Philox4x32-10 counter-based pseudorandom number generator with a period of 2\ :sup:`128`\ ``PHILOX4X32X10``\ :ref:`[Salmon11] `\ - * - \ :ref:`onemkl_rng_mcg31m1`\ - - The 31-bit multiplicative congruential pseudorandom number generator MCG(1132489760, 231 -1) :ref:`[L'Ecuyer99] `\ - * - \ :ref:`onemkl_rng_r250`\ - - The 32-bit generalized feedback shift register pseudorandom number generator ``GFSR(250,103)``\ :ref:`[Kirkpatrick81] `\ - * - \ :ref:`onemkl_rng_mcg59`\ - - The 59-bit multiplicative congruential pseudorandom number generator ``MCG(13``\ :sup:`13`\ ``, 2``\ :sup:`59`) from NAG Numerical Libraries :ref:`[NAG] `\ - * - \ :ref:`onemkl_rng_wichmann_hill`\ - - Wichmann-Hill pseudorandom number generator (a set of 273 basic generators) from NAG Numerical Libraries :ref:`[NAG] `\ - * - \ :ref:`onemkl_rng_mt19937`\ - - Mersenne Twister pseudorandom number generator ``MT19937``\ :ref:`[Matsumoto98] ` with period length 2\ :sup:`19937`-1 of the produced sequence - * - \ :ref:`onemkl_rng_mt2203`\ - - Set of 6024 Mersenne Twister pseudorandom number generators ``MT2203``\ :ref:`[Matsumoto98] `, :ref:`[Matsumoto00] `. Each of them generates a sequence of period length equal to 2\ :sup:`2203`-1. Parameters of the generators provide mutual independence of the corresponding sequences. - * - \ :ref:`onemkl_rng_sfmt19937`\ - - SIMD-oriented Fast Mersenne Twister pseudorandom number generator ``SFMT19937``\ :ref:`[Saito08] ` with a period length equal to 2\ :sup:`19937`-1 of the produced sequence. - * - \ :ref:`onemkl_rng_sobol`\ - - Sobol quasi-random number generator :ref:`[Sobol76] `, :ref:`[Bratley88] `, which works in arbitrary dimension. - * - \ :ref:`onemkl_rng_niederreiter`\ - - Niederreiter quasi-random number generator :ref:`[Bratley92] `, which works in arbitrary dimension. - * - \ :ref:`onemkl_rng_ars5`\ - - ARS-5 counter-based pseudorandom number generator with a period of 2\ :sup:`128`, which uses instructions from the AES-NI set ``ARS5``\ :ref:`[Salmon11] `. - * - \ :ref:`onemkl_rng_nondeterministic`\ + * - \ :ref:`onemath_rng_mrg32k3a`\ + - The combined multiple recursive pseudorandom number generator ``MRG32k3a``\ :ref:`[L'Ecuyer99a] `\ + * - \ :ref:`onemath_rng_philox4x32x10`\ + - Philox4x32-10 counter-based pseudorandom number generator with a period of 2\ :sup:`128`\ ``PHILOX4X32X10``\ :ref:`[Salmon11] `\ + * - \ :ref:`onemath_rng_mcg31m1`\ + - The 31-bit multiplicative congruential pseudorandom number generator MCG(1132489760, 231 -1) :ref:`[L'Ecuyer99] `\ + * - \ :ref:`onemath_rng_r250`\ + - The 32-bit generalized feedback shift register pseudorandom number generator ``GFSR(250,103)``\ :ref:`[Kirkpatrick81] `\ + * - \ :ref:`onemath_rng_mcg59`\ + - The 59-bit multiplicative congruential pseudorandom number generator ``MCG(13``\ :sup:`13`\ ``, 2``\ :sup:`59`) from NAG Numerical Libraries :ref:`[NAG] `\ + * - \ :ref:`onemath_rng_wichmann_hill`\ + - Wichmann-Hill pseudorandom number generator (a set of 273 basic generators) from NAG Numerical Libraries :ref:`[NAG] `\ + * - \ :ref:`onemath_rng_mt19937`\ + - Mersenne Twister pseudorandom number generator ``MT19937``\ :ref:`[Matsumoto98] ` with period length 2\ :sup:`19937`-1 of the produced sequence + * - \ :ref:`onemath_rng_mt2203`\ + - Set of 6024 Mersenne Twister pseudorandom number generators ``MT2203``\ :ref:`[Matsumoto98] `, :ref:`[Matsumoto00] `. Each of them generates a sequence of period length equal to 2\ :sup:`2203`-1. Parameters of the generators provide mutual independence of the corresponding sequences. + * - \ :ref:`onemath_rng_sfmt19937`\ + - SIMD-oriented Fast Mersenne Twister pseudorandom number generator ``SFMT19937``\ :ref:`[Saito08] ` with a period length equal to 2\ :sup:`19937`-1 of the produced sequence. + * - \ :ref:`onemath_rng_sobol`\ + - Sobol quasi-random number generator :ref:`[Sobol76] `, :ref:`[Bratley88] `, which works in arbitrary dimension. + * - \ :ref:`onemath_rng_niederreiter`\ + - Niederreiter quasi-random number generator :ref:`[Bratley92] `, which works in arbitrary dimension. + * - \ :ref:`onemath_rng_ars5`\ + - ARS-5 counter-based pseudorandom number generator with a period of 2\ :sup:`128`, which uses instructions from the AES-NI set ``ARS5``\ :ref:`[Salmon11] `. + * - \ :ref:`onemath_rng_nondeterministic`\ - Non-deterministic random number generator \ - For some basic generators, oneMKL RNG provides two methods of + For some basic generators, oneMath RNG provides two methods of creating independent states in multiprocessor computations, which are the leapfrog method and the block-splitting method. These sequence splitting methods are also useful in sequential Monte Carlo. The - description of these functions can be found in the :ref:`onemkl_rng_service_routines` section. + description of these functions can be found in the :ref:`onemath_rng_service_routines` section. In addition, the MT2203 pseudorandom number generator is a set of 6024 @@ -69,76 +69,76 @@ Host Engines (Basic Random Number Generators) allows creating up to 273 independent random streams. The properties of the generators designed for parallel computations are discussed in detail in - [:ref:`Coddington94 `]. + [:ref:`Coddington94 `]. - **Parent topic:** :ref:`onemkl_rng_manual_offload_routines` + **Parent topic:** :ref:`onemath_rng_manual_offload_routines` .. container:: - - :ref:`onemkl_rng_default_engine` + - :ref:`onemath_rng_default_engine` The default random engine (implementation defined) - - :ref:`onemkl_rng_mrg32k3a` + - :ref:`onemath_rng_mrg32k3a` The combined multiple recursive pseudorandom number generator MRG32k3a [ L'Ecuyer99a] - - :ref:`onemkl_rng_philox4x32x10` + - :ref:`onemath_rng_philox4x32x10` A Philox4x32-10 counter-based pseudorandom number generator. [Salmon11]. - - :ref:`onemkl_rng_mcg31m1` + - :ref:`onemath_rng_mcg31m1` The 31-bit multiplicative congruential pseudorandom number generator MCG(1132489760, 231 -1) [L'Ecuyer99] - - :ref:`onemkl_rng_mcg59` + - :ref:`onemath_rng_mcg59` The 59-bit multiplicative congruential pseudorandom number generator MCG(1313, 259) from NAG Numerical Libraries [NAG]. - - :ref:`onemkl_rng_r250` + - :ref:`onemath_rng_r250` The 32-bit generalized feedback shift register pseudorandom number generator GFSR(250,103)[Kirkpatrick81]. - - :ref:`onemkl_rng_wichmann_hill` + - :ref:`onemath_rng_wichmann_hill` Wichmann-Hill pseudorandom number generator (a set of 273 basic generators) from NAG Numerical Libraries [NAG]. - - :ref:`onemkl_rng_mt19937` + - :ref:`onemath_rng_mt19937` Mersenne Twister pseudorandom number generator MT19937 [Matsumoto98] with period length 2\ :sup:`19937`-1 of the produced sequence. - - :ref:`onemkl_rng_sfmt19937` + - :ref:`onemath_rng_sfmt19937` SIMD-oriented Fast Mersenne Twister pseudorandom number generator SFMT19937 [Saito08] with a period length equal to 2\ :sup:`19937`-1 of the produced sequence. - - :ref:`onemkl_rng_mt2203` + - :ref:`onemath_rng_mt2203` Set of 6024 Mersenne Twister pseudorandom number generators MT2203 [Matsumoto98], [Matsumoto00]. Each of them generates a sequence of period length equal to 2\ :sup:`2203`-1. Parameters of the generators provide mutual independence of the corresponding sequences.. - - :ref:`onemkl_rng_ars5` + - :ref:`onemath_rng_ars5` ARS-5 counter-based pseudorandom number generator with a period of 2\ :sup:`128`, which uses instructions from the AES-NI set ARS5[Salmon11]. - - :ref:`onemkl_rng_sobol` + - :ref:`onemath_rng_sobol` Sobol quasi-random number generator [Sobol76], [Bratley88], which works in arbitrary dimension. - - :ref:`onemkl_rng_niederreiter` + - :ref:`onemath_rng_niederreiter` Niederreiter quasi-random number generator [Bratley92], which works in arbitrary dimension. - - :ref:`onemkl_rng_nondeterministic` + - :ref:`onemath_rng_nondeterministic` Non-deterministic random number generator. .. toctree:: :hidden: - mkl-rng-default_engine - mkl-rng-mrg32k3a - mkl-rng-philox4x32x10 - mkl-rng-mcg31m1 - mkl-rng-mcg59 - mkl-rng-r250 - mkl-rng-wichmann_hill - mkl-rng-mt19937 - mkl-rng-sfmt19937 - mkl-rng-mt2203 - mkl-rng-ars5 - mkl-rng-sobol - mkl-rng-niederreiter - mkl-rng-nondeterministic + onemath-rng-default_engine + onemath-rng-mrg32k3a + onemath-rng-philox4x32x10 + onemath-rng-mcg31m1 + onemath-rng-mcg59 + onemath-rng-r250 + onemath-rng-wichmann_hill + onemath-rng-mt19937 + onemath-rng-sfmt19937 + onemath-rng-mt2203 + onemath-rng-ars5 + onemath-rng-sobol + onemath-rng-niederreiter + onemath-rng-nondeterministic diff --git a/source/elements/oneMKL/source/domains/rng/host_api/generate-routine.rst b/source/elements/oneMath/source/domains/rng/host_api/generate-routine.rst similarity index 66% rename from source/elements/oneMKL/source/domains/rng/host_api/generate-routine.rst rename to source/elements/oneMath/source/domains/rng/host_api/generate-routine.rst index 8c43e955c7..93563eede1 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/generate-routine.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/generate-routine.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_generate_routine: +.. _onemath_rng_generate_routine: Host Generate Routine ===================== @@ -10,13 +10,13 @@ Host Generate Routine .. container:: - - :ref:`onemkl_rng_generate` + - :ref:`onemath_rng_generate` Entry point to obtain random numbers from a given engine with proper statistics of a given distribution. - **Parent topic:** :ref:`onemkl_rng_manual_offload_routines` + **Parent topic:** :ref:`onemath_rng_manual_offload_routines` .. toctree:: :hidden: - mkl-rng-generate + onemath-rng-generate diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-ars5.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-ars5.rst similarity index 88% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-ars5.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-ars5.rst index 7212e5a5e2..d124114feb 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-ars5.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-ars5.rst @@ -2,24 +2,24 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_ars5: +.. _onemath_rng_ars5: ars5 ==== The ars5 counter-based pseudorandom number generator. -.. _onemkl_rng_ars5_description: +.. _onemath_rng_ars5_description: .. rubric:: Description -The ars5 engine is a keyed family of counter-based BRNG. The state consists of a 128-bit integer counter :math:`c` and a 128-bit key :math:`k`. The BRNG is based on the AES encryption algorithm [:ref:`FIPS-197 `]. +The ars5 engine is a keyed family of counter-based BRNG. The state consists of a 128-bit integer counter :math:`c` and a 128-bit key :math:`k`. The BRNG is based on the AES encryption algorithm [:ref:`FIPS-197 `]. .. container:: section .. rubric:: Generation algorithm - The generator has a 32-bit integer output obtained in the following way [:ref:`Salmon11 `]: + The generator has a 32-bit integer output obtained in the following way [:ref:`Salmon11 `]: 1. The i-th number is defined by the following formula :math:`r_i=(f(i/ 4) >> ((i \ mod \ 4) * 32)) \ mod \ 2 ^ {32}` 2. Function :math:`f(c)` takes a 128-bit argument and returns a 128-bit number. The returned number is obtained as follows: @@ -39,13 +39,13 @@ The ars5 engine is a keyed family of counter-based BRNG. The state consists of a :math:`Hi(k_{i+1}) = Hi(k) + 0xBB67AE8584CAA73B` - Specification for :math:`SubBytes, ShiftRows, MixColumns, AddRoundKey` functions can be found in [:ref:`FIPS-197 `]. + Specification for :math:`SubBytes, ShiftRows, MixColumns, AddRoundKey` functions can be found in [:ref:`FIPS-197 `]. 2.3. Put :math:`f(c) = c_N`, where :math:`N = 10` 3. Real output: :math:`u_n=(int)r_n / 2^{32} + 1/2` -.. _onemkl_rng_ars5_description_syntax: +.. _onemath_rng_ars5_description_syntax: class ars5 ---------- @@ -54,7 +54,7 @@ class ars5 .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { class ars5 { public: static constexpr std::uint64_t default_seed = 0; @@ -112,7 +112,7 @@ class ars5 .. rubric:: Input Parameters queue - Valid sycl::queue object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid sycl::queue object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state, assume :math:`k = seed, c = 0`, where :math:`k` is 128-bit key, :math:`c` is 128-bit counter. @@ -128,7 +128,7 @@ class ars5 .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state, assume @@ -197,4 +197,4 @@ class ars5 other Valid ``ars5`` r-value object. The ``queue`` and state of the other engine is moved to the current engine. -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-bernoulli.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-bernoulli.rst similarity index 80% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-bernoulli.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-bernoulli.rst index 07c49277cc..3991b199e5 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-bernoulli.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-bernoulli.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_bernoulli: +.. _onemath_rng_bernoulli: bernoulli ========= Class is used for generation of Bernoulli distributed integer types random numbers. -.. _onemkl_rng_bernoulli_description: +.. _onemath_rng_bernoulli_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers Bernoulli distributed with probability :math:`p` of a single trial success, where :math:`p \in R; 0 \leq p; p \leq 1`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers Bernoulli distributed with probability :math:`p` of a single trial success, where :math:`p \in R; 0 \leq p; p \leq 1`. The probability distribution is given by: @@ -31,7 +31,7 @@ The cumulative distribution function is as follows: F_{p}(x) = \left\{ \begin{array}{rcl} 0, x < 0 \\ 1 - p, 0 \leq x < 1, x \in R \\ 1, x \ge 1 \end{array}\right. -.. _onemkl_rng_bernoulli_syntax: +.. _onemath_rng_bernoulli_syntax: class bernoulli --------------- @@ -40,7 +40,7 @@ class bernoulli .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class bernoulli { public: @@ -65,13 +65,13 @@ class bernoulli .. container:: section - typename Method = oneapi::mkl::rng::bernoulli_method::by_default + typename Method = oneapi::math::rng::bernoulli_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::bernoulli_method::by_default`` - * ``oneapi::mkl::rng::bernoulli_method::icdf`` + * ``oneapi::math::rng::bernoulli_method::by_default`` + * ``oneapi::math::rng::bernoulli_method::icdf`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -153,7 +153,7 @@ class bernoulli .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when `p > 1.0f`, or `p < 0.0f` .. container:: section @@ -174,4 +174,4 @@ class bernoulli Returns the distribution parameter `p` - probability. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-beta.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-beta.rst similarity index 88% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-beta.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-beta.rst index 5fae969970..1bb6018e49 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-beta.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-beta.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_beta: +.. _onemath_rng_beta: beta ==== Class is used for generation of beta distributed real types random numbers. -.. _onemkl_rng_beta_description: +.. _onemath_rng_beta_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers beta distributed with shape parameters :math:`p` and :math:`q`, displacement :math:`\alpha` and scale parameter :math:`(b, \beta)`, where :math:`p`, :math:`q`. :math:`\alpha`, :math:`\beta` :math:`\in R; p > 0; q > 0; \beta > 0`. @@ -33,7 +33,7 @@ The cumulative distribution function is as follows: Where :math:`B(p, 1)` is the complete beta function. -.. _onemkl_rng_beta_syntax: +.. _onemath_rng_beta_syntax: class beta ---------- @@ -42,7 +42,7 @@ class beta .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class beta { public: @@ -70,14 +70,14 @@ class beta .. container:: section - typename Method = oneapi::mkl::rng::beta_method::by_default + typename Method = oneapi::math::rng::beta_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::beta_method::by_default`` - * ``oneapi::mkl::rng::beta_method::cja`` - * ``oneapi::mkl::rng::beta_method::cja_accurate`` + * ``oneapi::math::rng::beta_method::by_default`` + * ``oneapi::math::rng::beta_method::cja`` + * ``oneapi::math::rng::beta_method::cja_accurate`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -165,7 +165,7 @@ class beta .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`p \leq 0.0f`, or :math:`q \leq 0.0f`, or :math:`\beta \leq 0.0f` .. container:: section @@ -228,4 +228,4 @@ class beta Returns the distribution parameter :math:`\beta` - scalefactor. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-binomial.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-binomial.rst similarity index 83% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-binomial.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-binomial.rst index 0dbcdfecf6..6c4fc2e5d5 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-binomial.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-binomial.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_binomial: +.. _onemath_rng_binomial: binomial ======== Class is used for generation of binomially distributed integer types random numbers. -.. _onemkl_rng_binomial_description: +.. _onemath_rng_binomial_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers binomially distributed with a number of independent Bernoulli trials :math:`m`, and with probability :math:`p` of a single trial success, where :math:`p \in R; 0 \leq p \leq 1, m \in N`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers binomially distributed with a number of independent Bernoulli trials :math:`m`, and with probability :math:`p` of a single trial success, where :math:`p \in R; 0 \leq p \leq 1, m \in N`. A binomially distributed variate represents the number of successes in :math:`m` independent Bernoulli trials with probability of a single trial success :math:`p`. @@ -30,7 +30,7 @@ The cumulative distribution function is as follows: F_{m, p}(x) = \left\{ \begin{array}{rcl} 0, x < 0 \\ \sum^{\lfloor x \rfloor}_{k = 0} C^k_{m}p^k(1 - p)^{m - k}, 0 \leq x < m, x \in R \\ 1, x \ge m \end{array}\right. -.. _onemkl_rng_binomial_syntax: +.. _onemath_rng_binomial_syntax: class binomial -------------- @@ -39,7 +39,7 @@ class binomial .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class binomial { public: @@ -64,13 +64,13 @@ class binomial .. container:: section - typename Method = oneapi::mkl::rng::binomial_method::by_default + typename Method = oneapi::math::rng::binomial_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::binomial_method::by_default`` - * ``oneapi::mkl::rng::binomial_method::btpe`` + * ``oneapi::math::rng::binomial_method::by_default`` + * ``oneapi::math::rng::binomial_method::btpe`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -154,7 +154,7 @@ class binomial .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`p > 1.0`, or :math:`p < 0.0`, or :math:`ntrial < 1` .. container:: section @@ -189,4 +189,4 @@ class binomial Returns the distribution parameter `p` - success probability of a single trial. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-bits.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-bits.rst similarity index 66% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-bits.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-bits.rst index edc41aee7e..f6cdf37dee 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-bits.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-bits.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_bits: +.. _onemath_rng_bits: bits ==== Class is used for generation of underlying engine integer recurrence. -.. _onemkl_rng_bits_description: +.. _onemath_rng_bits_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide integer random numbers. Each integer can be treated as a vector of several bits. In a truly random generator, these bits are random, while in pseudorandom generators this randomness can be violated. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide integer random numbers. Each integer can be treated as a vector of several bits. In a truly random generator, these bits are random, while in pseudorandom generators this randomness can be violated. class bits ---------- @@ -22,7 +22,7 @@ class bits .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class bits { public: @@ -56,4 +56,4 @@ class bits The type which defines type of generated random numbers. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-cauchy.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-cauchy.rst similarity index 82% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-cauchy.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-cauchy.rst index 2cfd69027e..8a10ef78a1 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-cauchy.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-cauchy.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_cauchy: +.. _onemath_rng_cauchy: cauchy ====== Class is used for generation of Cauchy distributed real types random numbers. -.. _onemkl_rng_cauchy_description: +.. _onemath_rng_cauchy_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers Cauchy distributed with displacement :math:`a`, and scale parameter :math:`(b, \beta)`, where :math:`a, \beta \in R; \beta > 0`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers Cauchy distributed with displacement :math:`a`, and scale parameter :math:`(b, \beta)`, where :math:`a, \beta \in R; \beta > 0`. The probability distribution is given by: @@ -27,7 +27,7 @@ The cumulative distribution function is as follows: F_{a, \beta}(x) = \frac{1}{2} + \frac{1}{\pi} \arctan{(\frac{x - a}{\beta})}, x \in R. -.. _onemkl_rng_cauchy_syntax: +.. _onemath_rng_cauchy_syntax: class cauchy ------------ @@ -36,7 +36,7 @@ class cauchy .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class cauchy { public: @@ -62,13 +62,13 @@ class cauchy .. container:: section - typename Method = oneapi::mkl::rng::cauchy_method::by_default + typename Method = oneapi::math::rng::cauchy_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::cauchy_method::by_default`` - * ``oneapi::mkl::rng::cauchy_method::icdf`` + * ``oneapi::math::rng::cauchy_method::by_default`` + * ``oneapi::math::rng::cauchy_method::icdf`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -152,7 +152,7 @@ class cauchy .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`b \leq` static_cast(0.0) .. container:: section @@ -187,4 +187,4 @@ class cauchy Returns the distribution parameter `b` - scalefactor value. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-chi_square.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-chi_square.rst similarity index 82% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-chi_square.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-chi_square.rst index 4f335f053e..0978b8c49c 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-chi_square.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-chi_square.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_chi_square: +.. _onemath_rng_chi_square: chi_square ========== Class is used for generation of chi-square distributed real types random numbers. -.. _onemkl_rng_chi_square_description: +.. _onemath_rng_chi_square_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers chi-square distributed with :math:`n` degrees of freedom, :math:`n \in N; n > 0`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers chi-square distributed with :math:`n` degrees of freedom, :math:`n \in N; n > 0`. The probability distribution is given by: @@ -28,7 +28,7 @@ The cumulative distribution function is as follows: F_{n}(x) = \left\{ \begin{array}{rcl} \int^{x}_{0}\frac{y^{\frac{n - 2}{2}}e^{-\frac{x}{2}}}{2^{n/2}\Gamma(n/2)}dy, x \ge 0 \\ 0, x < 0 \end{array}\right. -.. _onemkl_rng_chi_square_syntax: +.. _onemath_rng_chi_square_syntax: class chi_square ---------------- @@ -37,7 +37,7 @@ class chi_square .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class chi_square { public: @@ -62,13 +62,13 @@ class chi_square .. container:: section - typename Method = oneapi::mkl::rng::chi_square_method::by_default + typename Method = oneapi::math::rng::chi_square_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::chi_square_method::by_default`` - * ``oneapi::mkl::rng::chi_square_method::gamma_based`` + * ``oneapi::math::rng::chi_square_method::by_default`` + * ``oneapi::math::rng::chi_square_method::gamma_based`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -150,7 +150,7 @@ class chi_square .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`n < 1` .. container:: section @@ -171,4 +171,4 @@ class chi_square Returns the distribution parameter `n` - number of degrees of freedom. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-default_engine.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-default_engine.rst similarity index 72% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-default_engine.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-default_engine.rst index 95241dca85..9d11919a29 100755 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-default_engine.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-default_engine.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_default_engine: +.. _onemath_rng_default_engine: default_engine ============== Default random engine. -.. _onemkl_rng_default_engine_description: +.. _onemath_rng_default_engine_description: .. rubric:: Description The choice of engine type named by default_engine is implementation-defined. The implementation may select this type on the basis of performance, size, quality, or any combination of such factors. -.. _onemkl_rng_default_engine_description_syntax: +.. _onemath_rng_default_engine_description_syntax: type alias default_engine ------------------------- @@ -27,4 +27,4 @@ type alias default_engine using default_engine = implementation-defined; -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-exponential.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-exponential.rst similarity index 81% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-exponential.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-exponential.rst index 9c0b30c443..ab21ecdff9 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-exponential.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-exponential.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_exponential: +.. _onemath_rng_exponential: exponential =========== Class is used for generation of exponentially distributed real types random numbers. -.. _onemkl_rng_exponential_description: +.. _onemath_rng_exponential_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers exponentially distributed with displacement :math:`a` and scalefactor :math:`\beta`, where :math:`a, \beta \in R; \beta > 0`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers exponentially distributed with displacement :math:`a` and scalefactor :math:`\beta`, where :math:`a, \beta \in R; \beta > 0`. The probability distribution is given by: @@ -27,7 +27,7 @@ The cumulative distribution function is as follows: F_{a, \beta}(x) = \left\{ \begin{array}{rcl} 1 - exp(-\frac{x - a}{\beta}), x \ge a \\ 0, x < a \end{array}\right. -.. _onemkl_rng_exponential_syntax: +.. _onemath_rng_exponential_syntax: class exponential ----------------- @@ -36,7 +36,7 @@ class exponential .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class exponential { public: @@ -62,14 +62,14 @@ class exponential .. container:: section - typename Method = oneapi::mkl::rng::exponential_method::by_default + typename Method = oneapi::math::rng::exponential_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::exponential_method::by_default`` - * ``oneapi::mkl::rng::exponential_method::icdf`` - * ``oneapi::mkl::rng::exponential_method::icdf_accurate`` + * ``oneapi::math::rng::exponential_method::by_default`` + * ``oneapi::math::rng::exponential_method::icdf`` + * ``oneapi::math::rng::exponential_method::icdf_accurate`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -153,7 +153,7 @@ class exponential .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`beta \leq` static_cast(0.0) .. container:: section @@ -188,4 +188,4 @@ class exponential Returns the distribution parameter `beta` - scalefactor value. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-gamma.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-gamma.rst similarity index 87% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-gamma.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-gamma.rst index 644914851d..afe899bc12 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-gamma.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-gamma.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_gamma: +.. _onemath_rng_gamma: gamma ===== Class is used for generation of gamma distributed real types random numbers. -.. _onemkl_rng_gamma_description: +.. _onemath_rng_gamma_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers gamma distributed with shape :math:`\alpha`, displacement :math:`a`, and scale parameter :math:`\beta`, where :math:`a, \alpha, \beta \in R; \alpha > 0; \beta > 0`. @@ -30,7 +30,7 @@ The cumulative distribution function is as follows: F_{a, \alpha, \beta}(x) = \left\{ \begin{array}{rcl} \int^x_a\frac{1}{\Gamma(\alpha)\beta^{\alpha}}(y - a)^{\alpha - 1}e^{-(y - a) / \beta}dy, x \ge a \\ 0, x < a \end{array}\right. -.. _onemkl_rng_gamma_syntax: +.. _onemath_rng_gamma_syntax: class gamma ----------- @@ -39,7 +39,7 @@ class gamma .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class gamma { public: @@ -66,14 +66,14 @@ class gamma .. container:: section - typename Method = oneapi::mkl::rng::gamma_method::by_default + typename Method = oneapi::math::rng::gamma_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::gamma_method::by_default`` - * ``oneapi::mkl::rng::gamma_method::marsaglia`` - * ``oneapi::mkl::rng::gamma_method::marsaglia_accurate`` + * ``oneapi::math::rng::gamma_method::by_default`` + * ``oneapi::math::rng::gamma_method::marsaglia`` + * ``oneapi::math::rng::gamma_method::marsaglia_accurate`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -159,7 +159,7 @@ class gamma .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`alpha \leq` static_cast(0.0), or :math:`beta \leq` static_cast(0.0) .. container:: section @@ -208,4 +208,4 @@ class gamma Returns the distribution parameter `beta` - scale parameter. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-gaussian.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-gaussian.rst similarity index 80% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-gaussian.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-gaussian.rst index d10d626e75..0a88916c6b 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-gaussian.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-gaussian.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_gaussian: +.. _onemath_rng_gaussian: gaussian ======== Class is used for generation of normally distributed real types random numbers. -.. _onemkl_rng_gaussian_description: +.. _onemath_rng_gaussian_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers normally distributed with mean :math:`(mean, a)` and standard deviation :math:`(stddev, \sigma)`, where :math:`a, \sigma \in R; \sigma > 0`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers normally distributed with mean :math:`(mean, a)` and standard deviation :math:`(stddev, \sigma)`, where :math:`a, \sigma \in R; \sigma > 0`. The probability distribution is given by: @@ -28,7 +28,7 @@ The cumulative distribution function is as follows: F_{a, \sigma}(x) = \int^x_{-\infty}\frac{1}{\sigma\sqrt{2\pi}}exp(-\frac{(y - a)^2}{2*\sigma^2})dy, x \in R. -.. _onemkl_rng_gaussian_syntax: +.. _onemath_rng_gaussian_syntax: class gaussian -------------- @@ -37,7 +37,7 @@ class gaussian .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class gaussian { public: @@ -63,15 +63,15 @@ class gaussian .. container:: section - typename Method = oneapi::mkl::rng::gaussian_method::by_default + typename Method = oneapi::math::rng::gaussian_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::gaussian_method::by_default`` - * ``oneapi::mkl::rng::gaussian_method::box_muller`` - * ``oneapi::mkl::rng::gaussian_method::box_muller2`` - * ``oneapi::mkl::rng::gaussian_method::icdf`` + * ``oneapi::math::rng::gaussian_method::by_default`` + * ``oneapi::math::rng::gaussian_method::box_muller`` + * ``oneapi::math::rng::gaussian_method::box_muller2`` + * ``oneapi::math::rng::gaussian_method::icdf`` - See description of the methods in :ref:`Distributions methods template parameter` + See description of the methods in :ref:`Distributions methods template parameter` .. container:: section @@ -155,7 +155,7 @@ class gaussian .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when `stddev` :math:`\leq` `static_cast(0.0)` .. container:: section @@ -190,4 +190,4 @@ class gaussian Returns the distribution parameter `stddev` - standard deviation value. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-gaussian_mv.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-gaussian_mv.rst similarity index 79% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-gaussian_mv.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-gaussian_mv.rst index 1232a5377d..7ff58d8e77 100755 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-gaussian_mv.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-gaussian_mv.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_gaussian_mv: +.. _onemath_rng_gaussian_mv: gaussian_mv =========== Class is used for generation of multivariate normally distributed real types random numbers. -.. _onemkl_rng_gaussian_mv_description: +.. _onemath_rng_gaussian_mv_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide n random numbers :math:`d`-variate normally distributed, with mean :math:`a` and variance-covariance matrix :math:`C`, where :math:`a \in R^d;` :math:`C` is dxd symmetric positive matrix. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide n random numbers :math:`d`-variate normally distributed, with mean :math:`a` and variance-covariance matrix :math:`C`, where :math:`a \in R^d;` :math:`C` is dxd symmetric positive matrix. The probability density function is given by: @@ -21,7 +21,7 @@ The probability density function is given by: f_{a, C}(x) = \frac{1}{\sqrt{det(2\pi C)}}exp(-1 / 2(x - a)^T C^{-1}(x-a)). -.. _onemkl_rng_gaussian_mv_syntax: +.. _onemath_rng_gaussian_mv_syntax: class gaussian_mv ----------------- @@ -33,7 +33,7 @@ It's implementation defined which type ``SequenceContainerOrView`` represents. .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class gaussian_mv { public: @@ -61,23 +61,23 @@ It's implementation defined which type ``SequenceContainerOrView`` represents. .. container:: section - oneapi::mkl::rng::layout Layout + oneapi::math::rng::layout Layout Matrix layout: - * ``oneapi::mkl::rng::layout::full`` - * ``oneapi::mkl::rng::layout::packed`` - * ``oneapi::mkl::rng::layout::diagonal`` + * ``oneapi::math::rng::layout::full`` + * ``oneapi::math::rng::layout::packed`` + * ``oneapi::math::rng::layout::diagonal`` .. container:: section - typename Method = oneapi::mkl::rng::gaussian_mv_method::by_default + typename Method = oneapi::math::rng::gaussian_mv_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::gaussian_mv_method::by_default`` - * ``oneapi::mkl::rng::gaussian_mv_method::box_muller`` - * ``oneapi::mkl::rng::gaussian_mv_method::box_muller2`` - * ``oneapi::mkl::rng::gaussian_mv_method::icdf`` + * ``oneapi::math::rng::gaussian_mv_method::by_default`` + * ``oneapi::math::rng::gaussian_mv_method::box_muller`` + * ``oneapi::math::rng::gaussian_mv_method::box_muller2`` + * ``oneapi::math::rng::gaussian_mv_method::icdf`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -147,7 +147,7 @@ It's implementation defined which type ``SequenceContainerOrView`` represents. .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`mean.size() \leq 0`, or :math:`matrix.size() \leq 0` .. container:: section @@ -196,4 +196,4 @@ It's implementation defined which type ``SequenceContainerOrView`` represents. Returns the variance-covariance matrix. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-generate.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-generate.rst similarity index 73% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-generate.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-generate.rst index d1557ab80c..724275fd8b 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-generate.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-generate.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_generate: +.. _onemath_rng_generate: generate ======== Entry point to obtain random numbers from a given engine with proper statistics of a given distribution. -.. _onemkl_rng_generate_description: +.. _onemath_rng_generate_description: .. rubric:: Description and Assumptions -oneapi::mkl::rng::generate function produces random numbers sequence from the given engine object and applied transformation from a given distribution object. +oneapi::math::rng::generate function produces random numbers sequence from the given engine object and applied transformation from a given distribution object. -.. _onemkl_rng_generate_buffer: +.. _onemath_rng_generate_buffer: generate (Buffer version) ------------------------- @@ -24,7 +24,7 @@ generate (Buffer version) .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template void generate (const DistrType& distr, EngineType& engine, std::int64_t n, sycl::buffer& r); } @@ -44,10 +44,10 @@ generate (Buffer version) .. rubric:: Input Parameters distr - Distribution object. See :ref:`onemkl_rng_distributions` for details. + Distribution object. See :ref:`onemath_rng_distributions` for details. engine - Engine object. See :ref:`onemkl_rng_engines_basic_random_number_generators` for details. + Engine object. See :ref:`onemath_rng_engines_basic_random_number_generators` for details. n Number of random values to be generated. @@ -63,10 +63,10 @@ generate (Buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when n > r.get_count(), or n < 0 -.. _onemkl_rng_generate_usm: +.. _onemath_rng_generate_usm: generate (USM version) ---------------------- @@ -75,7 +75,7 @@ generate (USM version) .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template sycl::event generate (const DistrType& distr, EngineType& engine, std::int64_t n, typename DistrType::result_type* r, const std::vector & dependencies); } @@ -95,10 +95,10 @@ generate (USM version) .. rubric:: Input Parameters distr - Distribution object. See :ref:`onemkl_rng_distributions` for details. + Distribution object. See :ref:`onemath_rng_distributions` for details. engine - Engine object. See :ref:`onemkl_rng_engines_basic_random_number_generators` for details. + Engine object. See :ref:`onemath_rng_engines_basic_random_number_generators` for details. n Number of random values to be generated. @@ -117,7 +117,7 @@ generate (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when r == nullptr, or n < 0 .. container:: section @@ -127,4 +127,4 @@ generate (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_rng_generate_routine` +**Parent topic:** :ref:`onemath_rng_generate_routine` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-geometric.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-geometric.rst similarity index 81% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-geometric.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-geometric.rst index a513863856..6968606594 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-geometric.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-geometric.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_geometric: +.. _onemath_rng_geometric: geometric ========= Class is used for generation of geometrically distributed integer types random numbers. -.. _onemkl_rng_geometric_description: +.. _onemath_rng_geometric_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers geometrically distributed with probability :math:`p` of a single success trial, where :math:`p \in R; 0 < p < 1`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers geometrically distributed with probability :math:`p` of a single success trial, where :math:`p \in R; 0 < p < 1`. The probability distribution is given by: @@ -27,7 +27,7 @@ The cumulative distribution function is as follows: F_{p}(x) = \left\{ \begin{array}{rcl} 0, x < 0 \\ 1 - (1 - p)^{\lfloor x + 1 \rfloor}, x \ge 0 \end{array}\right. -.. _onemkl_rng_geometric_syntax: +.. _onemath_rng_geometric_syntax: class geometric --------------- @@ -36,7 +36,7 @@ class geometric .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class geometric { public: @@ -61,13 +61,13 @@ class geometric .. container:: section - typename Method = oneapi::mkl::rng::geometric_method::by_default + typename Method = oneapi::math::rng::geometric_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::geometric_method::by_default`` - * ``oneapi::mkl::rng::geometric_method::icdf`` + * ``oneapi::math::rng::geometric_method::by_default`` + * ``oneapi::math::rng::geometric_method::icdf`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -149,7 +149,7 @@ class geometric .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`p \ge 1.0f`, or :math:`p \leq 0.0f` .. container:: section @@ -170,4 +170,4 @@ class geometric Returns the distribution parameter `p` - probability value. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-gumbel.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-gumbel.rst similarity index 82% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-gumbel.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-gumbel.rst index 88d9a8aaf7..ba3b58db29 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-gumbel.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-gumbel.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_gumbel: +.. _onemath_rng_gumbel: gumbel ====== Class is used for generation of Gumbel distributed real types random numbers. -.. _onemkl_rng_gumbel_description: +.. _onemath_rng_gumbel_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers Gumbel distributed with displacement :math:`a`, and scalefactor :math:`(b, \beta)`, where :math:`a, \beta \in R; \beta > 0`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers Gumbel distributed with displacement :math:`a`, and scalefactor :math:`(b, \beta)`, where :math:`a, \beta \in R; \beta > 0`. The probability distribution is given by: @@ -27,7 +27,7 @@ The cumulative distribution function is as follows: F_{a, \beta}(x) = 1 - exp(-exp(\frac{x - a}{\beta})), x \in R. -.. _onemkl_rng_gumbel_syntax: +.. _onemath_rng_gumbel_syntax: class gumbel ------------ @@ -36,7 +36,7 @@ class gumbel .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class gumbel { public: @@ -62,13 +62,13 @@ class gumbel .. container:: section - typename Method = oneapi::mkl::rng::gumbel_method::by_default + typename Method = oneapi::math::rng::gumbel_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::gumbel_method::by_default`` - * ``oneapi::mkl::rng::gumbel_method::icdf`` + * ``oneapi::math::rng::gumbel_method::by_default`` + * ``oneapi::math::rng::gumbel_method::icdf`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -152,7 +152,7 @@ class gumbel .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`b \leq` static_cast(0.0) .. container:: section @@ -187,4 +187,4 @@ class gumbel Returns the distribution parameter `b` - scalefactor value. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-hypergeometric.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-hypergeometric.rst similarity index 85% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-hypergeometric.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-hypergeometric.rst index 863f066c85..0a66d761e6 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-hypergeometric.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-hypergeometric.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_hypergeometric: +.. _onemath_rng_hypergeometric: hypergeometric ============== Class is used for generation of hypergeometrically distributed integer types random numbers. -.. _onemkl_rng_hypergeometric_description: +.. _onemath_rng_hypergeometric_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers hypergeometrically distributed with lot size :math:`l`, size of sampling :math:`s`, and number of marked elements in the lot :math:`m`, where :math:`l, m, s \in N \bigcup \{0\}; l \ge max (s, m)`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers hypergeometrically distributed with lot size :math:`l`, size of sampling :math:`s`, and number of marked elements in the lot :math:`m`, where :math:`l, m, s \in N \bigcup \{0\}; l \ge max (s, m)`. Consider a lot of :math:`l` elements comprising :math:`m` marked and :math:`l` - :math:`m` unmarked elements. A trial sampling without replacement of exactly :math:`s` elements from this lot helps to define the hypergeometric distribution, which is the probability that the group of :math:`s` elements contains exactly :math:`k` marked elements. @@ -29,7 +29,7 @@ The cumulative distribution function is as follows: F_{l, s, m}(x) = \left\{ \begin{array}{rcl} 0, x < max(0, s + m - l) \\ \sum^{\lfloor x \rfloor}_{k = max(0, s + m - l)}\frac{C^k_mC^{s-k}_{l-m}}{C^s_l}, max(0, s + m - l) \leq x \leq min(s, m) \\ 1, x > min(s, m) \end{array}\right. -.. _onemkl_rng_hypergeometric_syntax: +.. _onemath_rng_hypergeometric_syntax: class hypergeometric -------------------- @@ -38,7 +38,7 @@ class hypergeometric .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class hypergeometric { public: @@ -65,13 +65,13 @@ class hypergeometric .. container:: section - typename Method = oneapi::mkl::rng::hypergeometric_method::by_default + typename Method = oneapi::math::rng::hypergeometric_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::hypergeometric_method::by_default`` - * ``oneapi::mkl::rng::hypergeometric_method::h2pe`` + * ``oneapi::math::rng::hypergeometric_method::by_default`` + * ``oneapi::math::rng::hypergeometric_method::h2pe`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -157,7 +157,7 @@ class hypergeometric .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`s < 0`, or :math:`m < 0`, or :math:`l < (s > m ? s : m)` .. container:: section @@ -206,4 +206,4 @@ class hypergeometric Returns the distribution parameter `m` - number of marked elements. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-laplace.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-laplace.rst similarity index 81% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-laplace.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-laplace.rst index ddb8206d0c..54a26233f0 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-laplace.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-laplace.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_laplace: +.. _onemath_rng_laplace: laplace ======= Class is used for generation of Laplace distributed real types random numbers. -.. _onemkl_rng_laplace_description: +.. _onemath_rng_laplace_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers Laplace distributed with mean value (or average) :math:`a`, and scalefactor :math:`(b, \beta)`, where :math:`a, \beta \in R; \beta > 0`. The scalefactor value determines the standard deviation as :math:`\sigma = \beta\sqrt{2}`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers Laplace distributed with mean value (or average) :math:`a`, and scalefactor :math:`(b, \beta)`, where :math:`a, \beta \in R; \beta > 0`. The scalefactor value determines the standard deviation as :math:`\sigma = \beta\sqrt{2}`. The probability distribution is given by: @@ -27,7 +27,7 @@ The cumulative distribution function is as follows: F_{a, \beta}(x) = \left\{ \begin{array}{rcl} \frac{1}{2}exp(-\frac{|x - a|}{\beta}), x \ge a \\ 1 - \frac{1}{2}exp(-\frac{|x - a|}{\beta}), x < a \end{array}\right. -.. _onemkl_rng_laplace_syntax: +.. _onemath_rng_laplace_syntax: class laplace ------------- @@ -60,13 +60,13 @@ class laplace .. container:: section - typename Method = oneapi::mkl::rng::laplace_method::by_default + typename Method = oneapi::math::rng::laplace_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::laplace_method::by_default`` - * ``oneapi::mkl::rng::laplace_method::icdf`` + * ``oneapi::math::rng::laplace_method::by_default`` + * ``oneapi::math::rng::laplace_method::icdf`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -150,7 +150,7 @@ class laplace .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`b \leq` static_cast(0.0) .. container:: section @@ -185,4 +185,4 @@ class laplace Returns the distribution parameter `b` - scalefactor value. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-leapfrog.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-leapfrog.rst similarity index 56% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-leapfrog.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-leapfrog.rst index b767ec0b66..3365f90240 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-leapfrog.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-leapfrog.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_leapfrog: +.. _onemath_rng_leapfrog: leapfrog ======== Proceed state of engine by the leapfrog method. -.. _onemkl_rng_leapfrog_description: +.. _onemath_rng_leapfrog_description: .. rubric:: Description and Assumptions -oneapi::mkl::rng::leapfrog function generates random numbers in an engine with non-unit stride. This feature is particularly useful in distributing random numbers from the original stream across the stride buffers without generating the original random sequence with subsequent manual distribution. see `Figure "Leapfrog Method" <#rng_leapfrog>`__. +oneapi::math::rng::leapfrog function generates random numbers in an engine with non-unit stride. This feature is particularly useful in distributing random numbers from the original stream across the stride buffers without generating the original random sequence with subsequent manual distribution. see `Figure "Leapfrog Method" <#rng_leapfrog>`__. .. container:: figtop :name: rng_leapfrog @@ -22,7 +22,7 @@ oneapi::mkl::rng::leapfrog function generates random numbers in an engine with n |image0| -.. _onemkl_rng_leapfrog_common: +.. _onemath_rng_leapfrog_common: leapfrog -------- @@ -31,7 +31,7 @@ leapfrog .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template void leapfrog(EngineType& engine, std::uint64_t idx, std::uint64_t stride); } @@ -61,19 +61,19 @@ leapfrog .. code-block:: cpp // Creating 3 identical engines - oneapi::mkl::rng::mcg31m1 engine_1(queue, seed); + oneapi::math::rng::mcg31m1 engine_1(queue, seed); - oneapi::mkl::rng::mcg31m1 engine_2(engine_1); - oneapi::mkl::rng::mcg31m1 engine_3(engine_1); + oneapi::math::rng::mcg31m1 engine_2(engine_1); + oneapi::math::rng::mcg31m1 engine_3(engine_1); // Leapfrogging the states of engines - oneapi::mkl::rng::leapfrog(engine_1, 0 , 3); - oneapi::mkl::rng::leapfrog(engine_2, 1 , 3); - oneapi::mkl::rng::leapfrog(engine_3, 2 , 3); + oneapi::math::rng::leapfrog(engine_1, 0 , 3); + oneapi::math::rng::leapfrog(engine_2, 1 , 3); + oneapi::math::rng::leapfrog(engine_3, 2 , 3); // Generating random numbers -**Parent topic:** :ref:`onemkl_rng_service_routines` +**Parent topic:** :ref:`onemath_rng_service_routines` .. |image0| image:: ../../equations/rng-leapfrog.png diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-lognormal.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-lognormal.rst similarity index 82% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-lognormal.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-lognormal.rst index 10feecd4c2..b541ea69eb 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-lognormal.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-lognormal.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_lognormal: +.. _onemath_rng_lognormal: lognormal ========= Class is used for generation of lognormally distributed real types random numbers. -.. _onemkl_rng_lognormal_description: +.. _onemath_rng_lognormal_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers lognormally distributed with mean :math:`(m, a)` and standard deviation :math:`(s, \sigma)` of subject normal distribution, displacement :math:`(displ, b)`, and scalefactor :math:`(scale, \beta)`, where :math:`a, \sigma, b, \beta \in R; \sigma > 0; \beta > 0`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers lognormally distributed with mean :math:`(m, a)` and standard deviation :math:`(s, \sigma)` of subject normal distribution, displacement :math:`(displ, b)`, and scalefactor :math:`(scale, \beta)`, where :math:`a, \sigma, b, \beta \in R; \sigma > 0; \beta > 0`. The probability distribution is given by: @@ -27,7 +27,7 @@ The cumulative distribution function is as follows: F_{a, \sigma, b, \beta}(x) = \left\{ \begin{array}{rcl} \Phi( \frac{(ln((x - b) / \beta) - a)}{\sigma}), x > b \\ 0, x \leq b \end{array}\right. -.. _onemkl_rng_lognormal_syntax: +.. _onemath_rng_lognormal_syntax: class lognormal --------------- @@ -36,7 +36,7 @@ class lognormal .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class lognormal { public: @@ -64,16 +64,16 @@ class lognormal .. container:: section - typename Method = oneapi::mkl::rng::lognormal_method::by_default + typename Method = oneapi::math::rng::lognormal_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::lognormal_method::by_default`` - * ``oneapi::mkl::rng::lognormal_method::box_muller2`` - * ``oneapi::mkl::rng::lognormal_method::icdf`` - * ``oneapi::mkl::rng::lognormal_method::box_muller2_accurate`` - * ``oneapi::mkl::rng::lognormal_method::icdf_accurate`` + * ``oneapi::math::rng::lognormal_method::by_default`` + * ``oneapi::math::rng::lognormal_method::box_muller2`` + * ``oneapi::math::rng::lognormal_method::icdf`` + * ``oneapi::math::rng::lognormal_method::box_muller2_accurate`` + * ``oneapi::math::rng::lognormal_method::icdf_accurate`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -161,7 +161,7 @@ class lognormal .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`s \leq` static_cast(0.0), or :math:`scale \leq` static_cast(0.0) .. container:: section @@ -224,4 +224,4 @@ class lognormal Returns the distribution parameter `scale` - scalefactor value. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mcg31m1.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mcg31m1.rst similarity index 76% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mcg31m1.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mcg31m1.rst index df851db12c..2fc224d40f 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mcg31m1.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mcg31m1.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_mcg31m1: +.. _onemath_rng_mcg31m1: mcg31m1 ======= The 31-bit multiplicative congruential pseudorandom number generator MCG(1132489760, 231 -1). -.. _onemkl_rng_mcg31m1_description: +.. _onemath_rng_mcg31m1_description: .. rubric:: Description -The mcg31m1 engine is a 31-bit multiplicative congruential generator :ref:`[L'Ecuyer99] `. The mcg31m1 generator belongs to linear congruential generators with the period length of approximately :math:`2^{31}`. Such generators are still used as default random number generators in various software systems, mainly due to the simplicity of the portable versions implementation, speed, and compatibility with the earlier systems versions. However, their period length does not meet the requirements for modern basic generators. Still, the mcg31m1 generator possesses good statistic properties and you may successfully use it to generate random numbers of different distributions for small samplings. +The mcg31m1 engine is a 31-bit multiplicative congruential generator :ref:`[L'Ecuyer99] `. The mcg31m1 generator belongs to linear congruential generators with the period length of approximately :math:`2^{31}`. Such generators are still used as default random number generators in various software systems, mainly due to the simplicity of the portable versions implementation, speed, and compatibility with the earlier systems versions. However, their period length does not meet the requirements for modern basic generators. Still, the mcg31m1 generator possesses good statistic properties and you may successfully use it to generate random numbers of different distributions for small samplings. .. container:: section @@ -25,7 +25,7 @@ The mcg31m1 engine is a 31-bit multiplicative congruential generator :ref:`[L'Ec :math:`a = 1132489760, m=2^{31} - 1` -.. _onemkl_rng_mcg31m1_description_syntax: +.. _onemath_rng_mcg31m1_description_syntax: class mcg31m1 ------------- @@ -34,7 +34,7 @@ class mcg31m1 .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { class mcg31m1 { public: static constexpr std::uint32_t default_seed = 1; @@ -88,7 +88,7 @@ class mcg31m1 .. rubric:: Input Parameters queue - Valid sycl::queue object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid sycl::queue object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state, assume :math:`x_0 = seed \ mod \ 0x7FFFFFFF`, if :math:`x_0 = 0`, assume :math:`x_0 = 1`. @@ -145,4 +145,4 @@ class mcg31m1 other Valid ``mcg31m1`` r-value object. The ``queue`` and state of the other engine is moved to the current engine. -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mcg59.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mcg59.rst similarity index 85% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mcg59.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mcg59.rst index d05c1ba2f8..f887f6d556 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mcg59.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mcg59.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_mcg59: +.. _onemath_rng_mcg59: mcg59 ===== The 59-bit multiplicative congruential pseudorandom number generator. -.. _onemkl_rng_mcg59_description: +.. _onemath_rng_mcg59_description: .. rubric:: Description -The mcg59 engine is a 59-bit multiplicative congruential generator from NAG Numerical Libraries :ref:`NAG `. The mcg59 generator belongs to linear congruential generators with the period length of approximately :math:`2^{57}`. +The mcg59 engine is a 59-bit multiplicative congruential generator from NAG Numerical Libraries :ref:`NAG `. The mcg59 generator belongs to linear congruential generators with the period length of approximately :math:`2^{57}`. .. container:: section @@ -25,7 +25,7 @@ The mcg59 engine is a 59-bit multiplicative congruential generator from NAG Nume :math:`a = 13^{13}, m=2^{59}` -.. _onemkl_rng_mcg59_description_syntax: +.. _onemath_rng_mcg59_description_syntax: class mcg59 ----------- @@ -34,7 +34,7 @@ class mcg59 .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { class mcg59 { public: static constexpr std::uint64_t default_seed = 1; @@ -88,7 +88,7 @@ class mcg59 .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state, assume :math:`x_0 = seed \ mod \ 2^{59}`, if :math:`x_0 = 0`, assume :math:`x_0 = 1`. @@ -145,4 +145,4 @@ class mcg59 other Valid ``mcg59`` r-value object. The ``queue`` and state of the other engine is moved to the current engine. -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mrg32k3a.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mrg32k3a.rst similarity index 88% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mrg32k3a.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mrg32k3a.rst index e72ff80b03..19f265dfac 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mrg32k3a.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mrg32k3a.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_mrg32k3a: +.. _onemath_rng_mrg32k3a: mrg32k3a ======== The combined multiple recursive pseudorandom number generator MRG32k3a. -.. _onemkl_rng_mrg32k3a_description: +.. _onemath_rng_mrg32k3a_description: .. rubric:: Description -MRG32k3a engine is a 32-bit combined multiple recursive generator with two components of order 3 :ref:`[L'Ecuyer99a] `. MRG32k3a combined generator meets the requirements for modern RNGs, such as good multidimensional uniformity, or a long period (:math:`p \approx 2^{191}`). +MRG32k3a engine is a 32-bit combined multiple recursive generator with two components of order 3 :ref:`[L'Ecuyer99a] `. MRG32k3a combined generator meets the requirements for modern RNGs, such as good multidimensional uniformity, or a long period (:math:`p \approx 2^{191}`). .. container:: section @@ -33,7 +33,7 @@ MRG32k3a engine is a 32-bit combined multiple recursive generator with two compo :math:`a_{21} = 527612, a_{22} = 0, a_{23} = -1370589, m_2 = 2^{32} - 22853` -.. _onemkl_rng_mrg32k3a_description_syntax: +.. _onemath_rng_mrg32k3a_description_syntax: class mrg32k3a -------------- @@ -42,7 +42,7 @@ class mrg32k3a .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { class mrg32k3a { public: static constexpr std::uint32_t default_seed = 1; @@ -100,7 +100,7 @@ class mrg32k3a .. rubric:: Input Parameters queue - Valid ``sycl::queue object``, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue object``, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state, assume :math:`x_{-3} = seed \ mod \ m_1, x_{-2} = x_{-1} = y_{-3} = y_{-2} = y_{-1} = 1`. @@ -116,7 +116,7 @@ class mrg32k3a .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state, assume @@ -198,4 +198,4 @@ class mrg32k3a other Valid ``mrg32k3a`` r-value object. The ``queue`` and state of the other engine is moved to the current engine. -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mt19937.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mt19937.rst similarity index 82% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mt19937.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mt19937.rst index fead41585f..b1f8b71234 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mt19937.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mt19937.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_mt19937: +.. _onemath_rng_mt19937: mt19937 ======= Mersenne Twister pseudorandom number generator. -.. _onemkl_rng_mt19937_description: +.. _onemath_rng_mt19937_description: .. rubric:: Description -The Mersenne Twister pseudorandom number generator, mt19937, is a modification of twisted generalized feedback shift register generator [:ref:`Matsumoto98 `]. MT19937 has the period length of :math:`2^{19937} - 1` and is 623-dimensionally equidistributed with up to 32-bit accuracy. These properties make the generator applicable for simulations in various fields of science and engineering. The state of the generator is represented by 624 32-bit unsigned integer numbers. +The Mersenne Twister pseudorandom number generator, mt19937, is a modification of twisted generalized feedback shift register generator [:ref:`Matsumoto98 `]. MT19937 has the period length of :math:`2^{19937} - 1` and is 623-dimensionally equidistributed with up to 32-bit accuracy. These properties make the generator applicable for simulations in various fields of science and engineering. The state of the generator is represented by 624 32-bit unsigned integer numbers. .. container:: section @@ -46,7 +46,7 @@ The Mersenne Twister pseudorandom number generator, mt19937, is a modification o Where the 32-bit vector :math:`a = a_{31}..a_{0}` has the value :math:`a=0x9908B0DF`. -.. _onemkl_rng_mt19937_description_syntax: +.. _onemath_rng_mt19937_description_syntax: class mt19937 -------------- @@ -55,7 +55,7 @@ class mt19937 .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { class mt19937 { public: static constexpr std::uint32_t default_seed = 1; @@ -113,10 +113,10 @@ class mt19937 .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed - The initial conditions of the generator state. The initialization algorithm described in [:ref:`MT2203 `]. + The initial conditions of the generator state. The initialization algorithm described in [:ref:`MT2203 `]. .. _`mt19937(sycl::queue queue, std::initializer_list seed)`: @@ -129,10 +129,10 @@ class mt19937 .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed - The initial conditions of the generator state. The initialization algorithm described in [:ref:`MT2203 `]. + The initial conditions of the generator state. The initialization algorithm described in [:ref:`MT2203 `]. .. _`mt19937(const mt19937& other)`: @@ -186,4 +186,4 @@ class mt19937 other Valid ``mt19937`` r-value object. The ``queue`` and state of the other engine is moved to the current engine. -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mt2203.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mt2203.rst similarity index 84% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mt2203.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mt2203.rst index 62aeedc36f..b7a6ac297c 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-mt2203.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-mt2203.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_mt2203: +.. _onemath_rng_mt2203: mt2203 ====== -The mt2203 engine is the set of 6024 Mersenne Twister pseudorandom number generators MT2203 [:ref:`Matsumoto98 `], [:ref:`Matsumoto00 `]. +The mt2203 engine is the set of 6024 Mersenne Twister pseudorandom number generators MT2203 [:ref:`Matsumoto98 `], [:ref:`Matsumoto00 `]. -.. _onemkl_rng_mt2203_description: +.. _onemath_rng_mt2203_description: .. rubric:: Description @@ -43,7 +43,7 @@ The set of 6024 basic pseudorandom number generators MT2203 is a natural additio \left [ \begin{array}{ccccc} 0 & 1 & 0 & ... & ... \\ 0 & 0 & ... & 0 & ... \\ ... & ... & ... & ... & ... \\ 0 & ... & 0 & 0 & 1 \\ a_{31, j} & a_{30, j} & ... & ... & a_{0, 1} \end{array}\right ] -.. _onemkl_rng_mt2203_description_syntax: +.. _onemath_rng_mt2203_description_syntax: class mt2203 ------------ @@ -52,7 +52,7 @@ class mt2203 .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { class mt2203 { public: static constexpr std::uint32_t default_seed = 1; @@ -118,10 +118,10 @@ class mt2203 .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed - The initial conditions of the generator state. The initialization algorithm described in [:ref:`MT2203 `]. + The initial conditions of the generator state. The initialization algorithm described in [:ref:`MT2203 `]. .. _`mt2203(sycl::queue queue, std::uint32_t seed, std::uint32_t engine_idx)`: @@ -134,10 +134,10 @@ class mt2203 .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed - The initial conditions of the generator state. The initialization algorithm described in [:ref:`MT2203 `]. + The initial conditions of the generator state. The initialization algorithm described in [:ref:`MT2203 `]. engine_idx The index of the set 1, ..., 6024. @@ -146,7 +146,7 @@ class mt2203 .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`idx > 6024` .. _`mt2203(sycl::queue queue, std::initializer_list seed)`: @@ -160,10 +160,10 @@ class mt2203 .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed - The initial conditions of the generator state. The initialization algorithm described in [:ref:`MT2203 `]. + The initial conditions of the generator state. The initialization algorithm described in [:ref:`MT2203 `]. .. _`mt2203(sycl::queue queue, std::initializer_list seed, std::uint32_t engine_idx)`: @@ -176,10 +176,10 @@ class mt2203 .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed - The initial conditions of the generator state. The initialization algorithm described in [:ref:`MT2203 `]. + The initial conditions of the generator state. The initialization algorithm described in [:ref:`MT2203 `]. engine_idx The index of the set 1, ..., 6024. @@ -236,4 +236,4 @@ class mt2203 other Valid ``mt2203`` r-value object. The ``queue`` and state of the other engine is moved to the current engine. -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-multinomial.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-multinomial.rst similarity index 80% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-multinomial.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-multinomial.rst index 5cd9433328..73700c3cac 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-multinomial.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-multinomial.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_multinomial: +.. _onemath_rng_multinomial: multinomial =========== Class is used for generation of multinomially distributed integer types random numbers. -.. _onemkl_rng_multinomial_description: +.. _onemath_rng_multinomial_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide `n` random numbers multinomially distributed, with independent trials :math:`(ntrial, m)` and possible mutually exclusive outcomes :math:`k`, with corresponding probabilities :math:`p_i`, where :math:`p_i \in R; 0 \leq p_i \leq 1; m, k \in N`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide `n` random numbers multinomially distributed, with independent trials :math:`(ntrial, m)` and possible mutually exclusive outcomes :math:`k`, with corresponding probabilities :math:`p_i`, where :math:`p_i \in R; 0 \leq p_i \leq 1; m, k \in N`. The probability distribution is given by: @@ -21,7 +21,7 @@ The probability distribution is given by: P(X_1 = x_1, ..., X_k = x_k) = \frac{m!}{\Pi^k_{i = 1}x_i!}\Pi^k_{i = 1}p_i^{x_i}, 0 \leq x_i \leq m, \sum^{k}_{i = 1}x_i = m -.. _onemkl_rng_multinomial_syntax: +.. _onemath_rng_multinomial_syntax: class multinomial ----------------- @@ -33,7 +33,7 @@ It's implementation defined which type ``SequenceContainerOrView`` represents. .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class multinomial { public: @@ -58,13 +58,13 @@ It's implementation defined which type ``SequenceContainerOrView`` represents. .. container:: section - typename Method = oneapi::mkl::rng::multinomial_method::by_default + typename Method = oneapi::math::rng::multinomial_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::multinomial_method::by_default`` - * ``oneapi::mkl::rng::multinomial_method::poisson_icdf_based`` + * ``oneapi::math::rng::multinomial_method::by_default`` + * ``oneapi::math::rng::multinomial_method::poisson_icdf_based`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -132,7 +132,7 @@ It's implementation defined which type ``SequenceContainerOrView`` represents. .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`ntrial < 0`, or :math:`p.size() < 1` .. container:: section @@ -167,4 +167,4 @@ It's implementation defined which type ``SequenceContainerOrView`` represents. Returns the distribution parameter `p`. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-negbinomial.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-negbinomial.rst similarity index 82% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-negbinomial.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-negbinomial.rst index 187ba77da3..8711da3fc1 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-negbinomial.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-negbinomial.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_negative_binomial: +.. _onemath_rng_negative_binomial: negative_binomial ================= Class is used for generation of negative binomially distributed integer types random numbers. -.. _onemkl_rng_negative_binomial_description: +.. _onemath_rng_negative_binomial_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers negative binomially distributed with distribution parameters :math:`a` and :math:`p`, where :math:`p, a \in R; 0 \leq p \leq 1, a > 0`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers negative binomially distributed with distribution parameters :math:`a` and :math:`p`, where :math:`p, a \in R; 0 \leq p \leq 1, a > 0`. The probability distribution is given by: @@ -28,7 +28,7 @@ The cumulative distribution function is as follows: F_{a, p}(x) = \left\{ \begin{array}{rcl} \sum^{\lfloor x \rfloor}_{k = 0} C^k_{a + k - 1}p^a(1 - p)^{k}, x \ge 0, x \in R \\ 0, x < 0 \end{array}\right. -.. _onemkl_rng_negative_binomial_syntax: +.. _onemath_rng_negative_binomial_syntax: class negative_binomial ----------------------- @@ -37,7 +37,7 @@ class negative_binomial .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class negative_binomial { public: @@ -63,13 +63,13 @@ class negative_binomial .. container:: section - typename Method = oneapi::mkl::rng::negative_binomial_method::by_default + typename Method = oneapi::math::rng::negative_binomial_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::negative_binomial_method::by_default`` - * ``oneapi::mkl::rng::negative_binomial_method::nbar`` + * ``oneapi::math::rng::negative_binomial_method::by_default`` + * ``oneapi::math::rng::negative_binomial_method::nbar`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -153,7 +153,7 @@ class negative_binomial .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`p \ge 1.0`, or :math:`p \leq 0.0`, or :math:`a \leq 0.0` .. container:: section @@ -188,4 +188,4 @@ class negative_binomial Returns the distribution parameter `p` - the second distribution parameter. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-niederreiter.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-niederreiter.rst similarity index 86% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-niederreiter.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-niederreiter.rst index 0ddb6549be..114a210b68 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-niederreiter.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-niederreiter.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_niederreiter: +.. _onemath_rng_niederreiter: niederreiter ============ The niederreiter generator is a 32-bit Gray code-based quasi-random number generator. -.. _onemkl_rng_niederreiter_description: +.. _onemath_rng_niederreiter_description: .. rubric:: Description -According to results of Bratley, Fox and Niederreiter :ref:`[Bratley92] ` Niederreiter sequences have the best known theoretical asymptotic properties. The default dimension of quasi-random vectors can vary from 1 to 318 inclusive. It is also allowed to register user-defined parameters (irreducible polynomials). +According to results of Bratley, Fox and Niederreiter :ref:`[Bratley92] ` Niederreiter sequences have the best known theoretical asymptotic properties. The default dimension of quasi-random vectors can vary from 1 to 318 inclusive. It is also allowed to register user-defined parameters (irreducible polynomials). .. container:: section @@ -26,7 +26,7 @@ According to results of Bratley, Fox and Niederreiter :ref:`[Bratley92] ` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. dimensions Number of dimensions. If :math:`dimen < 1` or :math:`dimen > 318`, assume :math:`dimen = 1`. @@ -109,7 +109,7 @@ class niederreiter .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. irred_polynomials If you want to generate quasi-random vectors of greater dimension or obtain another sequence, you can register a set of your own irreducible polynomials. The number of dimensions corresponds to the length of the vector. @@ -166,4 +166,4 @@ class niederreiter other Valid ``niederreiter`` r-value object. The ``queue`` and state of the other engine is moved to the current engine. -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-nondeterministic.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-nondeterministic.rst similarity index 89% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-nondeterministic.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-nondeterministic.rst index 38e3aff5b9..886c09a519 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-nondeterministic.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-nondeterministic.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_nondeterministic: +.. _onemath_rng_nondeterministic: nondeterministic ================ Non-deterministic random number generator. -.. _onemkl_rng_nondeterministic_description: +.. _onemath_rng_nondeterministic_description: .. rubric:: Description Implementation defined generator with non-deterministic source of randomness (for example, a hardware device). -.. _onemkl_rng_nondeterministic_description_syntax: +.. _onemath_rng_nondeterministic_description_syntax: class nondeterministic ---------------------- @@ -24,7 +24,7 @@ class nondeterministic .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { class nondeterministic { public: nondeterministic(sycl::queue queue); @@ -76,7 +76,7 @@ class nondeterministic .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. .. _`nondeterministic(const nondeterministic& other)`: @@ -131,4 +131,4 @@ class nondeterministic other Valid ``nondeterministic`` r-value object. The ``queue`` and state of the other engine is moved to the current engine. -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-philox4x32x10.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-philox4x32x10.rst similarity index 91% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-philox4x32x10.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-philox4x32x10.rst index 95330ac4eb..c2b5d4d0a4 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-philox4x32x10.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-philox4x32x10.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_philox4x32x10: +.. _onemath_rng_philox4x32x10: philox4x32x10 ============= The Philox4x32x10 counter-based pseudorandom number generator. -.. _onemkl_rng_philox4x32x10_description: +.. _onemath_rng_philox4x32x10_description: .. rubric:: Description @@ -19,7 +19,7 @@ The Philox4x32x10 engine is a keyed family of generator of counter-based BRNG. T .. rubric:: Generation algorithm - The generator has 32-bit integer output obtained in the following way [:ref:`Salmon11 `]: + The generator has 32-bit integer output obtained in the following way [:ref:`Salmon11 `]: 1. :math:`c_n=c_{n-1} + 1` 2. :math:`\omega_n = f(c_n)`, where :math:`f` is a function that takes 128-bit argument and returns a 128-bit number. The returned number is obtained as follows: @@ -44,7 +44,7 @@ The Philox4x32x10 engine is a keyed family of generator of counter-based BRNG. T 3. Integer output: :math:`r_{4n + k} = \omega_n(k)`, where :math:`\omega_n(k)` is the k-th 32-bit integer in quadruple :math:`\omega_n, k = 0, 1, 2, 3` 4. Real output: :math:`u_n=(int)r_n / 2^{32} + 1/2` -.. _onemkl_rng_philox4x32x10_description_syntax: +.. _onemath_rng_philox4x32x10_description_syntax: class philox4x32x10 ------------------- @@ -53,7 +53,7 @@ class philox4x32x10 .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { class philox4x32x10 { public: static constexpr std::uint64_t default_seed = 0; @@ -111,7 +111,7 @@ class philox4x32x10 .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state, assume :math:`k = seed, c = 0`, where :math:`k` is a 64-bit key, :math:`c` is a 128-bit counter. @@ -127,7 +127,7 @@ class philox4x32x10 .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state, assume @@ -193,4 +193,4 @@ class philox4x32x10 other Valid ``philox4x32x10`` r-value object. The ``queue`` and state of the other engine is moved to the current engine. -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-poisson.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-poisson.rst similarity index 79% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-poisson.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-poisson.rst index 16b6c47a14..79d881c615 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-poisson.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-poisson.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_poisson: +.. _onemath_rng_poisson: poisson ======= Class is used for generation of Poisson distributed integer types random numbers. -.. _onemkl_rng_poisson_description: +.. _onemath_rng_poisson_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers Poisson distributed with distribution parameter :math:`\lambda`, where :math:`\lambda \in R; \lambda > 0;`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers Poisson distributed with distribution parameter :math:`\lambda`, where :math:`\lambda \in R; \lambda > 0;`. The probability distribution is given by: @@ -27,7 +27,7 @@ The cumulative distribution function is as follows: F_{\lambda}(x) = \left\{ \begin{array}{rcl} \sum_{k = 0}^{\lfloor x \rfloor} \frac{\lambda^ke^{-\lambda}}{k!}, x \ge 0 \\ 0, x < 0 \end{array}\right. -.. _onemkl_rng_poisson_syntax: +.. _onemath_rng_poisson_syntax: class poisson ------------- @@ -36,7 +36,7 @@ class poisson .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class poisson { public: @@ -60,14 +60,14 @@ class poisson .. container:: section - typename Method = oneapi::mkl::rng::poisson_method::by_default + typename Method = oneapi::math::rng::poisson_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::poisson_method::by_default`` - * ``oneapi::mkl::rng::poisson_method::ptpe`` - * ``oneapi::mkl::rng::poisson_method::gaussian_icdf_based`` + * ``oneapi::math::rng::poisson_method::by_default`` + * ``oneapi::math::rng::poisson_method::ptpe`` + * ``oneapi::math::rng::poisson_method::gaussian_icdf_based`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -149,7 +149,7 @@ class poisson .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`lambda \leq 0.0` .. container:: section @@ -170,4 +170,4 @@ class poisson Returns the distribution parameter `lambda`. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-poisson_v.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-poisson_v.rst similarity index 84% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-poisson_v.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-poisson_v.rst index 9d699eab2e..d9a93424e7 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-poisson_v.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-poisson_v.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_poisson_v: +.. _onemath_rng_poisson_v: poisson_v ========= Class is used for generation of Poisson distributed integer types random numbers with varying mean. -.. _onemkl_rng_poisson_v_description: +.. _onemath_rng_poisson_v_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide n random numbers Poisson distributed, with distribution parameter :math:`\lambda_i`, where :math:`\lambda_i \in R; \lambda_i > 0; i = 1, ... , n`. The probability distribution is given by: @@ -28,7 +28,7 @@ The cumulative distribution function is as follows: F_{\lambda_i}(x) = \left\{ \begin{array}{rcl} \sum_{k = 0}^{\lfloor x \rfloor} \frac{\lambda_i^ke^{-\lambda_i}}{k!}, x \ge 0 \\ 0, x < 0 \end{array}\right. -.. _onemkl_rng_poisson_v_syntax: +.. _onemath_rng_poisson_v_syntax: class poisson_v --------------- @@ -40,7 +40,7 @@ It's implementation defined which type ``SequenceContainerOrView`` represents. .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class poisson_v { public: @@ -63,13 +63,13 @@ It's implementation defined which type ``SequenceContainerOrView`` represents. .. container:: section - typename Method = oneapi::mkl::rng::poisson_v_method::by_default + typename Method = oneapi::math::rng::poisson_v_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::poisson_v_method::by_default`` - * ``oneapi::mkl::rng::poisson_v_method::gaussian_icdf_based`` + * ``oneapi::math::rng::poisson_v_method::by_default`` + * ``oneapi::math::rng::poisson_v_method::gaussian_icdf_based`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -135,7 +135,7 @@ It's implementation defined which type ``SequenceContainerOrView`` represents. .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`lambda.size() \leq 1` .. container:: section @@ -156,4 +156,4 @@ It's implementation defined which type ``SequenceContainerOrView`` represents. Returns the distribution parameter ``lambda``. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-r250.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-r250.rst similarity index 88% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-r250.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-r250.rst index 9359db585b..948a4c695d 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-r250.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-r250.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_r250: +.. _onemath_rng_r250: r250 ==== -The 32-bit generalized feedback shift register pseudorandom number generator GFSR(250,103) :ref:`[Kirkpatrick81] `. +The 32-bit generalized feedback shift register pseudorandom number generator GFSR(250,103) :ref:`[Kirkpatrick81] `. -.. _onemkl_rng_r250_description: +.. _onemath_rng_r250_description: .. rubric:: Description @@ -25,7 +25,7 @@ Feedback shift register generators possess ample theoretical foundation and were :math:`u_n=x_n / 2 ^ {32}` -.. _onemkl_rng_r250_description_syntax: +.. _onemath_rng_r250_description_syntax: class r250 ---------- @@ -34,7 +34,7 @@ class r250 .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { class r250 { public: static constexpr std::uint32_t default_seed = 1; @@ -92,7 +92,7 @@ class r250 .. rubric:: Input Parameters queue - Valid sycl::queue object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid sycl::queue object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state, assume :math:`x_{-250} = seed`. If :math:`seed = 0`, assume :math:`seed = 1`. Other values in state are initialized according to recurrent correlation :math:`x_{n+1} = 69069x_{n}(mod \ 2 ^ {32})`. Then the values :math:`x_{7k-247}, k = 0, 1, ..., 31` are interpreted as a binary matrix of size 32 x 32 and diagonal bits are set to 0, the under-diagonal bits to 0. @@ -108,7 +108,7 @@ class r250 .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state @@ -166,4 +166,4 @@ class r250 other Valid ``r250`` r-value object. The ``queue`` and state of the other engine is moved to the current engine. -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-rayleigh.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-rayleigh.rst similarity index 79% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-rayleigh.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-rayleigh.rst index 92d6afc5b9..eb608e1d33 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-rayleigh.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-rayleigh.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_rayleigh: +.. _onemath_rng_rayleigh: rayleigh ======== Class is used for generation of Rayleigh distributed real types random numbers. -.. _onemkl_rng_rayleigh_description: +.. _onemath_rng_rayleigh_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers Rayleigh distributed with displacement :math:`a`, and scalefactor :math:`(b, \beta)`, where :math:`a, \beta \in R; \beta > 0`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers Rayleigh distributed with displacement :math:`a`, and scalefactor :math:`(b, \beta)`, where :math:`a, \beta \in R; \beta > 0`. -The Rayleigh distribution is a special case of the :ref:`onemkl_rng_weibull` distribution, where the shape parameter `\alpha` = 2 . +The Rayleigh distribution is a special case of the :ref:`onemath_rng_weibull` distribution, where the shape parameter `\alpha` = 2 . The probability distribution is given by: @@ -29,7 +29,7 @@ The cumulative distribution function is as follows: F_{a, \beta}(x) = \left\{ \begin{array}{rcl} 1 - exp(-\frac{(x - a)^2)}{\beta^2}), x \ge a \\ 0, x < a \end{array}\right. -.. _onemkl_rng_rayleigh_syntax: +.. _onemath_rng_rayleigh_syntax: class rayleigh -------------- @@ -38,7 +38,7 @@ class rayleigh .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class rayleigh { public: @@ -64,14 +64,14 @@ class rayleigh .. container:: section - typename Method = oneapi::mkl::rng::rayleigh_method::by_default + typename Method = oneapi::math::rng::rayleigh_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::rayleigh_method::by_default`` - * ``oneapi::mkl::rng::rayleigh_method::icdf`` - * ``oneapi::mkl::rng::rayleigh_method::icdf_accurate`` + * ``oneapi::math::rng::rayleigh_method::by_default`` + * ``oneapi::math::rng::rayleigh_method::icdf`` + * ``oneapi::math::rng::rayleigh_method::icdf_accurate`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -155,7 +155,7 @@ class rayleigh .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`b \leq` static_cast(0.0) .. container:: section @@ -190,4 +190,4 @@ class rayleigh Returns the distribution parameter `b` - scalefactor value. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-sfmt19937.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-sfmt19937.rst similarity index 84% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-sfmt19937.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-sfmt19937.rst index bb67cd2343..770d82d037 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-sfmt19937.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-sfmt19937.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_sfmt19937: +.. _onemath_rng_sfmt19937: sfmt19937 ========= The SIMD-oriented Mersenne Twister pseudorandom number generator. -.. _onemkl_rng_sfmt19937_description: +.. _onemath_rng_sfmt19937_description: .. rubric:: Description -SIMD-oriented Fast Mersenne Twister pseudorandom number generator SFMT19937 [:ref:`Saito08 `] with a period length equal to :math:`2 ^ {19937}-1` of the produced sequence. The state of the engine contains the array of 156 128-bit integers. +SIMD-oriented Fast Mersenne Twister pseudorandom number generator SFMT19937 [:ref:`Saito08 `] with a period length equal to :math:`2 ^ {19937}-1` of the produced sequence. The state of the engine contains the array of 156 128-bit integers. .. container:: section @@ -36,7 +36,7 @@ SIMD-oriented Fast Mersenne Twister pseudorandom number generator SFMT19937 [:re :math:`u_n = (int) r_n / 2^{32} + 1/2` -.. _onemkl_rng_sfmt19937_description_syntax: +.. _onemath_rng_sfmt19937_description_syntax: class sfmt19937 --------------- @@ -45,7 +45,7 @@ class sfmt19937 .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { class sfmt19937 { public: static constexpr std::uint32_t default_seed = 1; @@ -103,10 +103,10 @@ class sfmt19937 .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed - The initial conditions of the generator state. The initialization algorithm described in [:ref:`Saito08 `]. + The initial conditions of the generator state. The initialization algorithm described in [:ref:`Saito08 `]. .. _`sfmt19937(sycl::queue queue, std::initializer_list seed)`: @@ -119,10 +119,10 @@ class sfmt19937 .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed - The initial conditions of the generator state. The initialization algorithm described in [:ref:`Saito08 `]. + The initial conditions of the generator state. The initialization algorithm described in [:ref:`Saito08 `]. .. _`sfmt19937(const sfmt19937& other)`: @@ -176,4 +176,4 @@ class sfmt19937 other Valid ``sfmt19937`` r-value object. The ``queue`` and state of the other engine is moved to the current engine. -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-skip_ahead.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-skip_ahead.rst similarity index 68% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-skip_ahead.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-skip_ahead.rst index f975421867..dc6c616a7c 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-skip_ahead.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-skip_ahead.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_skip_ahead: +.. _onemath_rng_skip_ahead: skip_ahead ========== Proceed state of engine by the skip-ahead method. -.. _onemkl_rng_skip_ahead_description: +.. _onemath_rng_skip_ahead_description: .. rubric:: Description and Assumptions -oneapi::mkl::rng::skip_ahead function changes the current state of the engine so that with the further call of the generator the output subsequence begins with the specified offset see `Figure "Block-Splitting Method" <#rng_block_splitting>`__. +oneapi::math::rng::skip_ahead function changes the current state of the engine so that with the further call of the generator the output subsequence begins with the specified offset see `Figure "Block-Splitting Method" <#rng_block_splitting>`__. .. container:: figtop :name: rng_block_splitting @@ -22,7 +22,7 @@ oneapi::mkl::rng::skip_ahead function changes the current state of the engine so |image0| -.. _onemkl_rng_skip_ahead_common: +.. _onemath_rng_skip_ahead_common: skip_ahead ---------- @@ -31,7 +31,7 @@ skip_ahead .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template void skip_ahead(EngineType& engine, std::uint64_t num_to_skip); } @@ -58,18 +58,18 @@ skip_ahead .. code-block:: cpp // Creating 3 identical engines - oneapi::mkl::rng::mcg31m1 engine_1(queue, seed); - oneapi::mkl::rng::mcg31m1 engine_2(engine_1); - oneapi::mkl::rng::mcg31m1 engine_3(engine_2); + oneapi::math::rng::mcg31m1 engine_1(queue, seed); + oneapi::math::rng::mcg31m1 engine_2(engine_1); + oneapi::math::rng::mcg31m1 engine_3(engine_2); // Skipping ahead by 7 elements the 2nd engine - oneapi::mkl::rng::skip_ahead(engine_2, 7); + oneapi::math::rng::skip_ahead(engine_2, 7); // Skipping ahead by 14 elements the 3rd engine - oneapi::mkl::rng::skip_ahead(engine_3, 14); + oneapi::math::rng::skip_ahead(engine_3, 14); -.. _onemkl_rng_skip_ahead_ex: +.. _onemath_rng_skip_ahead_ex: skip_ahead (Interface with a partitioned number of skipped elements) -------------------------------------------------------------------- @@ -78,9 +78,9 @@ skip_ahead (Interface with a partitioned number of skipped elements) .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template - void oneapi::mkl::rng::skip_ahead(EngineType& engine, std::initializer_list num_to_skip); + void oneapi::math::rng::skip_ahead(EngineType& engine, std::initializer_list num_to_skip); } .. container:: section @@ -105,17 +105,17 @@ skip_ahead (Interface with a partitioned number of skipped elements) .. code-block:: cpp // Creating the first engine - oneapi::mkl::rng::mrg32k3a engine_1(queue, seed); + oneapi::math::rng::mrg32k3a engine_1(queue, seed); // To skip 2^64 elements in the random stream number of skipped elements should be // represented as num_to_skip = 2^64 = 0 + 1 * 2^64 std::initializer_list num_to_skip = {0, 1}; // Creating the 2nd engine based on 1st. Skipping by 2^64 - oneapi::mkl::rng::mrg32k3a engine_2(engine_1); - oneapi::mkl::rng::skip_ahead(engine_2, num_to_skip); + oneapi::math::rng::mrg32k3a engine_2(engine_1); + oneapi::math::rng::skip_ahead(engine_2, num_to_skip); -**Parent topic:** :ref:`onemkl_rng_service_routines` +**Parent topic:** :ref:`onemath_rng_service_routines` .. |image0| image:: ../../equations/rng-skip-ahead.png diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-sobol.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-sobol.rst similarity index 85% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-sobol.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-sobol.rst index 261cc1ea87..4fb71cdf70 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-sobol.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-sobol.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_sobol: +.. _onemath_rng_sobol: sobol ===== The sobol is a 32-bit Gray code-based quasi-random number generator. -.. _onemkl_rng_sobol_description: +.. _onemath_rng_sobol_description: .. rubric:: Description -Bratley and Fox :ref:`[Bratley88] ` provide an implementation of the SOBOL quasi-random number generator. The default dimensions of quasi-random vectors can vary from 1 to 40 inclusive. It is also allowed to register user-defined parameters (direction numbers). +Bratley and Fox :ref:`[Bratley88] ` provide an implementation of the SOBOL quasi-random number generator. The default dimensions of quasi-random vectors can vary from 1 to 40 inclusive. It is also allowed to register user-defined parameters (direction numbers). .. container:: section @@ -26,7 +26,7 @@ Bratley and Fox :ref:`[Bratley88] ` provide an implemen The value :math:`c` is the right-most zero bit in :math:`n-1`; :math:`x_n` is s-dimensional vector of 32-bit values. The s-dimensional vectors (calculated during engine initialization) :math:`v_i, i = 1, 32` are called direction numbers. The vector :math:`u_n` is the generator output normalized to the unit hypercube :math:`(0, 1) ^ s`. -.. _onemkl_rng_sobol_description_syntax: +.. _onemath_rng_sobol_description_syntax: class sobol ----------- @@ -35,7 +35,7 @@ class sobol .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { class sobol { public: static constexpr std::uint32_t default_dimensions_number = 1; @@ -93,7 +93,7 @@ class sobol .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. dimensions Number of dimensions. If :math:`dimen < 1` or :math:`dimen > 40`, assume :math:`dimen = 1`. @@ -109,7 +109,7 @@ class sobol .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. direction_numbers If you want to generate quasi-random vectors of greater dimension or obtain another sequence, you can register a set of your own direction_numbers. The number of dimensions corresponds to direction_numbers.size() / 32. @@ -166,4 +166,4 @@ class sobol other Valid ``sobol`` r-value object. The ``queue`` and state of the other engine is moved to the current engine. -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-uniform-continuous.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-uniform-continuous.rst similarity index 81% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-uniform-continuous.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-uniform-continuous.rst index 540c0484cf..2feb34f87d 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-uniform-continuous.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-uniform-continuous.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_uniform_continuous: +.. _onemath_rng_uniform_continuous: uniform (continuous) ==================== Class is used for generation of uniformly distributed real types random numbers. -.. _onemkl_rng_uniform_continuous_description: +.. _onemath_rng_uniform_continuous_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers uniformly distributed over the interval :math:`[a, b)`, where :math:`a`, :math:`b` are the left and right bounds of the +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers uniformly distributed over the interval :math:`[a, b)`, where :math:`a`, :math:`b` are the left and right bounds of the interval, respectively, and :math:`a, b \in R; a < b` The probability distribution is given by: @@ -29,7 +29,7 @@ The cumulative distribution function is as follows: F_{a, b}(x) = \left\{ \begin{array}{rcl} 0, x < a \\ \frac{x - a}{b - a}, a \leq x < b, x \in R \\ 1, x \ge b \end{array}\right. -.. _onemkl_rng_uniform_continuous_syntax: +.. _onemath_rng_uniform_continuous_syntax: class uniform ------------- @@ -38,7 +38,7 @@ class uniform .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class uniform { public: @@ -64,14 +64,14 @@ class uniform .. container:: section - typename Method = oneapi::mkl::rng::uniform_method::by_default + typename Method = oneapi::math::rng::uniform_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::uniform_method::by_default`` - * ``oneapi::mkl::rng::uniform_method::standard`` - * ``oneapi::mkl::rng::uniform_method::accurate`` + * ``oneapi::math::rng::uniform_method::by_default`` + * ``oneapi::math::rng::uniform_method::standard`` + * ``oneapi::math::rng::uniform_method::accurate`` - See description of the methods in :ref:`Distributions methods template parameter` + See description of the methods in :ref:`Distributions methods template parameter` .. container:: section @@ -155,7 +155,7 @@ class uniform .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`a \ge b` .. container:: section @@ -190,4 +190,4 @@ class uniform Returns the distribution parameter `b` - right bound. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-uniform-discrete.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-uniform-discrete.rst similarity index 82% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-uniform-discrete.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-uniform-discrete.rst index 8e837b3f6f..9babc632de 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-uniform-discrete.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-uniform-discrete.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_uniform_discrete: +.. _onemath_rng_uniform_discrete: uniform (discrete) ================== Class is used for generation of uniformly distributed integer types random numbers. -.. _onemkl_rng_uniform_discrete_description: +.. _onemath_rng_uniform_discrete_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers uniformly distributed over the interval :math:`[a, b)`, where :math:`a`, :math:`b` are the left and right bounds of the +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers uniformly distributed over the interval :math:`[a, b)`, where :math:`a`, :math:`b` are the left and right bounds of the interval, respectively, and :math:`a, b \in R; a < b`. The probability distribution is given by: @@ -29,7 +29,7 @@ The cumulative distribution function is as follows: F_{a, b}(x) = \left\{ \begin{array}{rcl} 0, x < a \\ \frac{\lfloor x - a + 1 \rfloor}{b-a}, a \leq x < b, x \in R \\ 1, x \ge b \end{array}\right. -.. _onemkl_rng_uniform_discrete_syntax: +.. _onemath_rng_uniform_discrete_syntax: class uniform ------------- @@ -38,7 +38,7 @@ class uniform .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class uniform { public: @@ -57,13 +57,13 @@ class uniform .. container:: section - typename Method = oneapi::mkl::rng::uniform_method::by_default + typename Method = oneapi::math::rng::uniform_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::uniform_method::by_default`` - * ``oneapi::mkl::rng::uniform_method::standard`` + * ``oneapi::math::rng::uniform_method::by_default`` + * ``oneapi::math::rng::uniform_method::standard`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -147,7 +147,7 @@ class uniform .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`a \ge b` .. container:: section @@ -182,4 +182,4 @@ class uniform Returns the distribution parameter `b` - right bound. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-uniform_bits.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-uniform_bits.rst similarity index 69% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-uniform_bits.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-uniform_bits.rst index 10da230479..748c16a318 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-uniform_bits.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-uniform_bits.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_uniform_bits: +.. _onemath_rng_uniform_bits: uniform_bits ============ Class is used for generation of uniformly distributed bits in 32/64-bit chunks. -.. _onemkl_rng_uniform_bits_description: +.. _onemath_rng_uniform_bits_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide uniformly distributed bits in 32/64-bit chunks. It is designed to ensure each bit in the 32/64-bit chunk is uniformly distributed. Can be not supported by the specific engine. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide uniformly distributed bits in 32/64-bit chunks. It is designed to ensure each bit in the 32/64-bit chunk is uniformly distributed. Can be not supported by the specific engine. class uniform_bits ------------------ @@ -22,7 +22,7 @@ class uniform_bits .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class uniform_bits { public: @@ -57,4 +57,4 @@ class uniform_bits The type which defines type of generated random numbers. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/onemkl-rng-usage-model.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-usage-model.rst similarity index 68% rename from source/elements/oneMKL/source/domains/rng/host_api/onemkl-rng-usage-model.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-usage-model.rst index ad62a589e9..4a4ad5a322 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/onemkl-rng-usage-model.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-usage-model.rst @@ -2,10 +2,10 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_usage_model: +.. _onemath_rng_usage_model: -oneMKL RNG Host Usage Model -=========================== +oneMath RNG Host Usage Model +============================ .. rubric:: Description @@ -27,17 +27,17 @@ Buffer-based example .. code-block:: cpp - #include "oneapi/mkl/rng.hpp" + #include "oneapi/math/rng.hpp" int main() { sycl::queue q; // Create the random number generator object - oneapi::mkl::rng::philox4x32x10 engine(q, seed); + oneapi::math::rng::philox4x32x10 engine(q, seed); // Create the distribution object - oneapi::mkl::rng::gaussian distr(5.0, 2.0); + oneapi::math::rng::gaussian distr(5.0, 2.0); // Fill the SYCL buffer with random numbers - oneapi::mkl::rng::generate(distr, engine, n, sycl_buffer); + oneapi::math::rng::generate(distr, engine, n, sycl_buffer); // ... } @@ -48,21 +48,21 @@ USM-based example .. code-block:: cpp - #include "oneapi/mkl/rng.hpp" + #include "oneapi/math/rng.hpp" int main() { sycl::queue q; // Create the random number generator object - oneapi::mkl::rng::philox4x32x10 engine(q, seed); + oneapi::math::rng::philox4x32x10 engine(q, seed); // Create the distribution object - oneapi::mkl::rng::gaussian distr(5.0, 2.0); + oneapi::math::rng::gaussian distr(5.0, 2.0); // Fill the USM memory under the pointer with random numbers - auto event = oneapi::mkl::rng::generate(distr, engine, n, usm_ptr); + auto event = oneapi::math::rng::generate(distr, engine, n, usm_ptr); // ... // wait until generation is finalized event.wait(); // ... } -**Parent topic:** :ref:`onemkl_rng_manual_offload_routines` +**Parent topic:** :ref:`onemath_rng_manual_offload_routines` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-weibull.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-weibull.rst similarity index 83% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-weibull.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-weibull.rst index bceb7c63fe..1ae31a8879 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-weibull.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-weibull.rst @@ -2,18 +2,18 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_weibull: +.. _onemath_rng_weibull: weibull ======= Class is used for generation of Weibull distributed real types random numbers. -.. _onemkl_rng_weibull_description: +.. _onemath_rng_weibull_description: .. rubric:: Description -The class object is used in the :ref:`oneapi::mkl::rng::generate()` function to provide random numbers Weibull distributed with displacement :math:`a`, scalefactor :math:`\beta`, and shape :math:`\alpha`, where :math:`a, \beta, \alpha \in R; \alpha > 0; \beta > 0`. +The class object is used in the :ref:`oneapi::math::rng::generate()` function to provide random numbers Weibull distributed with displacement :math:`a`, scalefactor :math:`\beta`, and shape :math:`\alpha`, where :math:`a, \beta, \alpha \in R; \alpha > 0; \beta > 0`. The probability distribution is given by: @@ -27,7 +27,7 @@ The cumulative distribution function is as follows: F_{a, \alpha, \beta}(x) = \left\{ \begin{array}{rcl} 1 - exp((-\frac{x - a}{\beta})^{\alpha}), x \ge a \\ 0, x < a \end{array}\right. -.. _onemkl_rng_weibull_syntax: +.. _onemath_rng_weibull_syntax: class weibull ------------- @@ -36,7 +36,7 @@ class weibull .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { template class weibull { public: @@ -63,14 +63,14 @@ class weibull .. container:: section - typename Method = oneapi::mkl::rng::weibull_method::by_default + typename Method = oneapi::math::rng::weibull_method::by_default Transformation method, which will be used for generation. Supported types: - * ``oneapi::mkl::rng::weibull_method::by_default`` - * ``oneapi::mkl::rng::weibull_method::icdf`` - * ``oneapi::mkl::rng::weibull_method::icdf_accurate`` + * ``oneapi::math::rng::weibull_method::by_default`` + * ``oneapi::math::rng::weibull_method::icdf`` + * ``oneapi::math::rng::weibull_method::icdf_accurate`` - See description of the methods in :ref:`Distributions methods template parameter`. + See description of the methods in :ref:`Distributions methods template parameter`. .. container:: section @@ -156,7 +156,7 @@ class weibull .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`alpha \leq` static_cast(0.0), or :math:`beta \leq` static_cast(0.0) .. container:: section @@ -205,4 +205,4 @@ class weibull Returns the distribution parameter `beta` - scalefactor value. -**Parent topic:** :ref:`onemkl_rng_distributions` +**Parent topic:** :ref:`onemath_rng_distributions` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-wichmann_hill.rst b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-wichmann_hill.rst similarity index 90% rename from source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-wichmann_hill.rst rename to source/elements/oneMath/source/domains/rng/host_api/onemath-rng-wichmann_hill.rst index a35adb8c1b..cc44cf4c47 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/mkl-rng-wichmann_hill.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/onemath-rng-wichmann_hill.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_wichmann_hill: +.. _onemath_rng_wichmann_hill: wichmann_hill ============= -The wichmann_hill engine is the set of 273 Wichmann-Hill's combined multiplicative congruential generators from NAG Numerical Libraries :ref:`[NAG] `. +The wichmann_hill engine is the set of 273 Wichmann-Hill's combined multiplicative congruential generators from NAG Numerical Libraries :ref:`[NAG] `. -.. _onemkl_rng_wichmann_hill_description: +.. _onemath_rng_wichmann_hill_description: .. rubric:: Description @@ -32,7 +32,7 @@ The set of 372 different basic pseudorandom number generators wichmann_hill is t The constants :math:`a_{i, j}` range from 112 to 127, the constants :math:`m_{i, j}` are prime numbers ranging from 16718909 to 16776917, close to :math:`2 ^ {24}`. -.. _onemkl_rng_wichmann_hill_description_syntax: +.. _onemath_rng_wichmann_hill_description_syntax: class wichmann_hill ------------------- @@ -41,7 +41,7 @@ class wichmann_hill .. code-block:: cpp - namespace oneapi::mkl::rng { + namespace oneapi::math::rng { class wichmann_hill { public: static constexpr std::uint32_t default_seed = 1; @@ -107,7 +107,7 @@ class wichmann_hill .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state. Assume :math:`x_0=seed \ mod \ m_1, y_0 = z_0 = w_0 = 1`. If :math:`x_0 = 0`, assume :math:`x_0 = 1`. @@ -123,7 +123,7 @@ class wichmann_hill .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state. Assume :math:`x_0=seed \ mod \ m_1, y_0 = z_0 = w_0 = 1`. If :math:`x_0 = 0`, assume :math:`x_0 = 1`. @@ -135,7 +135,7 @@ class wichmann_hill .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`idx > 273` .. _`wichmann_hill(sycl::queue& queue, std::initializer_list seed)`: @@ -149,7 +149,7 @@ class wichmann_hill .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state, assume: @@ -177,7 +177,7 @@ class wichmann_hill .. rubric:: Input Parameters queue - Valid ``sycl::queue`` object, calls of the :ref:`oneapi::mkl::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. + Valid ``sycl::queue`` object, calls of the :ref:`oneapi::math::rng::generate()` routine submits kernels in this queue to obtain random numbers from a given engine. seed The initial conditions of the generator state, assume: @@ -248,4 +248,4 @@ class wichmann_hill other Valid ``wichmann_hill`` r-value object. The ``queue`` and state of the other engine is moved to the current engine. -**Parent topic:** :ref:`onemkl_rng_engines_basic_random_number_generators` +**Parent topic:** :ref:`onemath_rng_engines_basic_random_number_generators` diff --git a/source/elements/oneMKL/source/domains/rng/host_api/rng-host-routines.rst b/source/elements/oneMath/source/domains/rng/host_api/rng-host-routines.rst similarity index 74% rename from source/elements/oneMKL/source/domains/rng/host_api/rng-host-routines.rst rename to source/elements/oneMath/source/domains/rng/host_api/rng-host-routines.rst index 0531602019..d63e54d2c3 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/rng-host-routines.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/rng-host-routines.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_manual_offload_routines: +.. _onemath_rng_manual_offload_routines: Random Number Generators Host Routines ====================================== @@ -13,36 +13,36 @@ RNG domain contains two classes types: - Engines (basic random number generators) classes, which holds the state of generator and is a source of independent and identically distributed random variables. - Refer to :ref:`onemkl_rng_engines_basic_random_number_generators` + Refer to :ref:`onemath_rng_engines_basic_random_number_generators` for a detailed description. - Distribution classes templates (transformation classes) for different types of statistical distributions, for example, uniform, normal (Gaussian), binomial, etc. These classes contain all of the distribution’s parameters - (including generation method). Refer to :ref:`onemkl_rng_distributions` for + (including generation method). Refer to :ref:`onemath_rng_distributions` for a detailed description of the distributions. The RNG domain also contains two types of free functions: - Generation routines. The current routines are used to obtain random numbers from a given engine with proper statistics defined by a - given distribution. Refer to the :ref:`onemkl_rng_generate_routine` + given distribution. Refer to the :ref:`onemath_rng_generate_routine` section for a detailed description. - - Service routines. The routines are used to modify the engine state. Refer to :ref:`onemkl_rng_service_routines` for a + - Service routines. The routines are used to modify the engine state. Refer to :ref:`onemath_rng_service_routines` for a description of these routines. Engine classes work with both generation and service routines. Distribution classes are used in -generation routines only. Refer to the :ref:`onemkl_rng_usage_model` +generation routines only. Refer to the :ref:`onemath_rng_usage_model` section for the description of typical RNG scenario. .. toctree:: :hidden: - onemkl-rng-usage-model.rst + onemath-rng-usage-model.rst generate-routine.rst engines-basic-random-number-generators.rst service-routines.rst distributions.rst ../bibliography.rst -**Parent topic:** :ref:`onemkl_rng` \ No newline at end of file +**Parent topic:** :ref:`onemath_rng` \ No newline at end of file diff --git a/source/elements/oneMKL/source/domains/rng/host_api/service-routines.rst b/source/elements/oneMath/source/domains/rng/host_api/service-routines.rst similarity index 66% rename from source/elements/oneMKL/source/domains/rng/host_api/service-routines.rst rename to source/elements/oneMath/source/domains/rng/host_api/service-routines.rst index 08c0c072d1..8c5d98231a 100644 --- a/source/elements/oneMKL/source/domains/rng/host_api/service-routines.rst +++ b/source/elements/oneMath/source/domains/rng/host_api/service-routines.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_service_routines: +.. _onemath_rng_service_routines: Host Service Routines ===================== @@ -19,17 +19,17 @@ Host Service Routines * - Routine - Description - * - \ :ref:`onemkl_rng_leapfrog`\ + * - \ :ref:`onemath_rng_leapfrog`\ - Proceed state of engine by the leapfrog method to generate a subsequence of the original sequence - * - \ :ref:`onemkl_rng_skip_ahead`\ + * - \ :ref:`onemath_rng_skip_ahead`\ - Proceed state of engine by the skip-ahead method to skip a given number of elements from the original sequence - **Parent topic:** :ref:`onemkl_rng_manual_offload_routines` + **Parent topic:** :ref:`onemath_rng_manual_offload_routines` .. toctree:: :hidden: - mkl-rng-leapfrog - mkl-rng-skip_ahead + onemath-rng-leapfrog + onemath-rng-skip_ahead diff --git a/source/elements/oneMKL/source/domains/rng/onemkl-rng-overview.rst b/source/elements/oneMath/source/domains/rng/onemath-rng-overview.rst similarity index 83% rename from source/elements/oneMKL/source/domains/rng/onemkl-rng-overview.rst rename to source/elements/oneMath/source/domains/rng/onemath-rng-overview.rst index ddf440a33c..f96fb1d155 100755 --- a/source/elements/oneMKL/source/domains/rng/onemkl-rng-overview.rst +++ b/source/elements/oneMath/source/domains/rng/onemath-rng-overview.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_rng_overview: +.. _onemath_rng_overview: Random Number Generators (RNG) ============================== @@ -40,9 +40,9 @@ In computational statistics, random variate generation is usually made in two st RNG domain supports two execution models: - #. :ref:`Host API`, which is aligned with the rest of oneMKL domains - :ref:`oneMKL domains`. - #. :ref:`Device API`, which is specific for RNG domain. These APIs + #. :ref:`Host API`, which is aligned with the rest of oneMath domains + :ref:`oneMath domains`. + #. :ref:`Device API`, which is specific for RNG domain. These APIs are designed to be callable from the User's kernels as well as Host code. @@ -52,4 +52,4 @@ RNG domain supports two execution models: host_api/rng-host-routines.rst device_api/device-routines.rst -**Parent topic:** :ref:`onemkl_rng` +**Parent topic:** :ref:`onemath_rng` diff --git a/source/elements/oneMKL/source/domains/sparse_linear_algebra.inc.rst b/source/elements/oneMath/source/domains/sparse_linear_algebra.inc.rst similarity index 85% rename from source/elements/oneMKL/source/domains/sparse_linear_algebra.inc.rst rename to source/elements/oneMath/source/domains/sparse_linear_algebra.inc.rst index b48583bd72..bd7b33c948 100644 --- a/source/elements/oneMKL/source/domains/sparse_linear_algebra.inc.rst +++ b/source/elements/oneMath/source/domains/sparse_linear_algebra.inc.rst @@ -2,17 +2,17 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_linear_algebra: +.. _onemath_sparse_linear_algebra: Sparse Linear Algebra ---------------------- .. container:: - The oneAPI Math Kernel Library provides a C++ interface to a set of Sparse + The |onemath_full_name| provides a C++ interface to a set of Sparse Linear Algebra routines using SYCL. - :ref:`onemkl_spblas` provides basic operations on sparse vectors and + :ref:`onemath_spblas` provides basic operations on sparse vectors and matrices. Most operations are split into three stages: query of the external workspace size, optimization stage and execution. For a given configuration, the first two stages would typically be called once for a set of input diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/data_handles.rst b/source/elements/oneMath/source/domains/spblas/data_types/data_handles.rst similarity index 65% rename from source/elements/oneMKL/source/domains/spblas/data_types/data_handles.rst rename to source/elements/oneMath/source/domains/spblas/data_types/data_handles.rst index dfcf922121..1afd22fdb2 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/data_handles.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/data_handles.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_data_handles: +.. _onemath_sparse_data_handles: Data handles ============ -.. _onemkl_sparse_dense_vector_handle: +.. _onemath_sparse_dense_vector_handle: Dense vector handle ------------------- @@ -16,7 +16,7 @@ Dense vector handle .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { struct dense_vector_handle; using dense_vector_handle_t = dense_vector_handle*; @@ -33,11 +33,11 @@ Dense vector handle See related functions: - - :ref:`onemkl_sparse_init_dense_vector` - - :ref:`onemkl_sparse_set_dense_vector_data` - - :ref:`onemkl_sparse_release_dense_vector` + - :ref:`onemath_sparse_init_dense_vector` + - :ref:`onemath_sparse_set_dense_vector_data` + - :ref:`onemath_sparse_release_dense_vector` -.. _onemkl_sparse_dense_matrix_handle: +.. _onemath_sparse_dense_matrix_handle: Dense matrix handle ------------------- @@ -46,7 +46,7 @@ Dense matrix handle .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { struct dense_matrix_handle; using dense_matrix_handle_t = dense_matrix_handle*; @@ -63,11 +63,11 @@ Dense matrix handle See related functions: - - :ref:`onemkl_sparse_init_dense_matrix` - - :ref:`onemkl_sparse_set_dense_matrix_data` - - :ref:`onemkl_sparse_release_dense_matrix` + - :ref:`onemath_sparse_init_dense_matrix` + - :ref:`onemath_sparse_set_dense_matrix_data` + - :ref:`onemath_sparse_release_dense_matrix` -.. _onemkl_sparse_matrix_handle: +.. _onemath_sparse_matrix_handle: Sparse matrix handle -------------------- @@ -76,7 +76,7 @@ Sparse matrix handle .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { struct matrix_handle; using matrix_handle_t = matrix_handle*; @@ -93,14 +93,14 @@ Sparse matrix handle See related functions: - - :ref:`onemkl_sparse_init_coo_matrix` - - :ref:`onemkl_sparse_init_csr_matrix` - - :ref:`onemkl_sparse_set_coo_matrix_data` - - :ref:`onemkl_sparse_set_csr_matrix_data` - - :ref:`onemkl_sparse_set_matrix_property` - - :ref:`onemkl_sparse_release_sparse_matrix` + - :ref:`onemath_sparse_init_coo_matrix` + - :ref:`onemath_sparse_init_csr_matrix` + - :ref:`onemath_sparse_set_coo_matrix_data` + - :ref:`onemath_sparse_set_csr_matrix_data` + - :ref:`onemath_sparse_set_matrix_property` + - :ref:`onemath_sparse_release_sparse_matrix` - See a description of the supported :ref:`sparse formats`. + See a description of the supported :ref:`sparse formats`. .. toctree:: :hidden: @@ -119,4 +119,4 @@ Sparse matrix handle set_matrix_property format-descriptions -**Parent topic:** :ref:`onemkl_spblas` +**Parent topic:** :ref:`onemath_spblas` diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/format-descriptions.rst b/source/elements/oneMath/source/domains/spblas/data_types/format-descriptions.rst similarity index 96% rename from source/elements/oneMKL/source/domains/spblas/data_types/format-descriptions.rst rename to source/elements/oneMath/source/domains/spblas/data_types/format-descriptions.rst index 33ab4b153a..286bbb8d18 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/format-descriptions.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/format-descriptions.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_format_descriptions: +.. _onemath_sparse_format_descriptions: Sparse storage formats ====================== @@ -13,12 +13,12 @@ Compressed Sparse Row (CSR) format. In this specification, "non-zero" elements or "non-zero" entries refer to explicitly defined elements or entries which may take any value supported by the -the `:ref:data type`. Undefined elements or +the `:ref:data type`. Undefined elements or entries are implicitly zeros. .. container:: section - .. _onemkl_sparse_coo: + .. _onemath_sparse_coo: .. rubric:: COO @@ -87,7 +87,7 @@ one-based indexing): .. container:: section - .. _onemkl_sparse_csr: + .. _onemath_sparse_csr: .. rubric:: CSR @@ -152,4 +152,4 @@ zero-based indexing): | val | 1 | 2 | -1 | 4 | 3 | +------------+------------+-----------+-----------+-----------+-----------+ -**Parent topic:** :ref:`onemkl_sparse_data_handles` +**Parent topic:** :ref:`onemath_sparse_data_handles` diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/init_coo_matrix.rst b/source/elements/oneMath/source/domains/spblas/data_types/init_coo_matrix.rst similarity index 75% rename from source/elements/oneMKL/source/domains/spblas/data_types/init_coo_matrix.rst rename to source/elements/oneMath/source/domains/spblas/data_types/init_coo_matrix.rst index 7f955e388f..4c6c9cf1e7 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/init_coo_matrix.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/init_coo_matrix.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_init_coo_matrix: +.. _onemath_sparse_init_coo_matrix: init_coo_matrix =============== @@ -11,7 +11,7 @@ Initializes a ``matrix_handle_t`` object with the provided COO data. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::init_coo_matrix`` function initializes the +The ``oneapi::math::sparse::init_coo_matrix`` function initializes the ``matrix_handle_t`` object with the provided data. In the case of buffers, the reference count of the provided buffer is @@ -21,19 +21,19 @@ with ``set_coo_matrix_data``. In the case of USM, the object does not take ownership of the data. -The ``oneapi::mkl::sparse::init_coo_matrix`` function defined below takes in the +The ``oneapi::math::sparse::init_coo_matrix`` function defined below takes in the number of non-zero elements in the sparse matrix as an argument. However, in certain math operations where the output is a sparse matrix, e.g., sparse matrix addition (sparse matrix + sparse matrix = sparse matrix), and multiplication of two sparse matrices, the number of non-zero elements in the output sparse matrix are not known in advance and must be calculated as part of the operation API. -Such APIs are currently not part of the oneMKL Specification, but will be added +Such APIs are currently not part of the oneMath Specification, but will be added in the future. This behavior is currently left to be implementation-defined, but -may be clarified in the oneMKL Specification in the future. +may be clarified in the oneMath Specification in the future. -See :ref:`onemkl_sparse_matrix_handle`. +See :ref:`onemath_sparse_matrix_handle`. -.. _onemkl_sparse_init_coo_matrix_buffer: +.. _onemath_sparse_init_coo_matrix_buffer: init_coo_matrix (Buffer version) -------------------------------- @@ -42,11 +42,11 @@ init_coo_matrix (Buffer version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void init_coo_matrix (sycl::queue &queue, - oneapi::mkl::sparse::matrix_handle_t *p_smhandle, + oneapi::math::sparse::matrix_handle_t *p_smhandle, std::int64_t num_rows, std::int64_t num_cols, std::int64_t nnz, @@ -62,10 +62,10 @@ init_coo_matrix (Buffer version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. + See :ref:`supported template types`. indexType - See :ref:`supported template types`. + See :ref:`supported template types`. .. container:: section @@ -90,22 +90,22 @@ init_coo_matrix (Buffer version) index Indicates how input arrays are indexed. The possible options are described - in :ref:`onemkl_enum_index_base` enum class. + in :ref:`onemath_enum_index_base` enum class. row_ind Buffer of length at least ``nnz`` containing the row indices in - ``index``-based numbering. Refer to :ref:`onemkl_sparse_coo` format for + ``index``-based numbering. Refer to :ref:`onemath_sparse_coo` format for detailed description of ``row_ind``. col_ind Buffer of length at least ``nnz`` containing the column indices in - ``index``-based numbering. Refer to :ref:`onemkl_sparse_coo` format for + ``index``-based numbering. Refer to :ref:`onemath_sparse_coo` format for detailed description of ``col_ind``. val Buffer of length at least ``nnz``. Contains the data of the input matrix which is not implicitly zero. The remaining input values are implicit - zeros. Refer to :ref:`onemkl_sparse_coo` format for detailed description + zeros. Refer to :ref:`onemath_sparse_coo` format for detailed description of ``val``. .. container:: section @@ -134,12 +134,12 @@ init_coo_matrix (Buffer version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::host_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::host_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_init_coo_matrix_usm: +.. _onemath_sparse_init_coo_matrix_usm: init_coo_matrix (USM version) ----------------------------- @@ -148,11 +148,11 @@ init_coo_matrix (USM version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void init_coo_matrix (sycl::queue &queue, - oneapi::mkl::sparse::matrix_handle_t *p_smhandle, + oneapi::math::sparse::matrix_handle_t *p_smhandle, std::int64_t num_rows, std::int64_t num_cols, std::int64_t nnz, @@ -168,10 +168,10 @@ init_coo_matrix (USM version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. + See :ref:`supported template types`. indexType - See :ref:`supported template types`. + See :ref:`supported template types`. .. container:: section @@ -196,24 +196,24 @@ init_coo_matrix (USM version) index Indicates how input arrays are indexed. The possible options are described - in :ref:`onemkl_enum_index_base` enum class. + in :ref:`onemath_enum_index_base` enum class. row_ind USM pointer of length at least ``nnz`` containing the row indices in - ``index``-based numbering. Refer to :ref:`onemkl_sparse_coo` format for + ``index``-based numbering. Refer to :ref:`onemath_sparse_coo` format for detailed description of ``row_ind``. The data must be accessible on the device. col_ind USM pointer of length at least ``nnz`` containing the column indices in - ``index``-based numbering. Refer to :ref:`onemkl_sparse_coo` format for + ``index``-based numbering. Refer to :ref:`onemath_sparse_coo` format for detailed description of ``col_ind``. The data must be accessible on the device. val USM pointer of length at least ``nnz``. Contains the data of the input matrix which is not implicitly zero. The remaining input values are - implicit zeros. Refer to :ref:`onemkl_sparse_coo` format for detailed + implicit zeros. Refer to :ref:`onemath_sparse_coo` format for detailed description of ``val``. The data must be accessible on the device. Using a USM pointer with a smaller allocated memory size is undefined behavior. @@ -243,9 +243,9 @@ init_coo_matrix (USM version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::host_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::host_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_sparse_data_handles` +**Parent topic:** :ref:`onemath_sparse_data_handles` diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/init_csr_matrix.rst b/source/elements/oneMath/source/domains/spblas/data_types/init_csr_matrix.rst similarity index 75% rename from source/elements/oneMKL/source/domains/spblas/data_types/init_csr_matrix.rst rename to source/elements/oneMath/source/domains/spblas/data_types/init_csr_matrix.rst index cf8a14eb21..72e44d78c4 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/init_csr_matrix.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/init_csr_matrix.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_init_csr_matrix: +.. _onemath_sparse_init_csr_matrix: init_csr_matrix =============== @@ -12,7 +12,7 @@ Initializes a ``matrix_handle_t`` object with the provided Compressed Sparse Row .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::init_csr_matrix`` function initializes the +The ``oneapi::math::sparse::init_csr_matrix`` function initializes the ``matrix_handle_t`` object with the provided data. In the case of buffers, the reference count of the provided buffer is @@ -22,19 +22,19 @@ with ``set_csr_matrix_data``. In the case of USM, the object does not take ownership of the data. -The ``oneapi::mkl::sparse::init_csr_matrix`` function defined below takes in the +The ``oneapi::math::sparse::init_csr_matrix`` function defined below takes in the number of non-zero elements in the sparse matrix as an argument. However, in certain math operations where the output is a sparse matrix, e.g., sparse matrix addition (sparse matrix + sparse matrix = sparse matrix), and multiplication of two sparse matrices, the number of non-zero elements in the output sparse matrix are not known in advance and must be calculated as part of the operation API. -Such APIs are currently not part of the oneMKL Specification, but will be added +Such APIs are currently not part of the oneMath Specification, but will be added in the future. This behavior is currently left to be implementation-defined, but -may be clarified in the oneMKL Specification in the future. +may be clarified in the oneMath Specification in the future. -See :ref:`onemkl_sparse_matrix_handle`. +See :ref:`onemath_sparse_matrix_handle`. -.. _onemkl_sparse_init_csr_matrix_buffer: +.. _onemath_sparse_init_csr_matrix_buffer: init_csr_matrix (Buffer version) -------------------------------- @@ -43,11 +43,11 @@ init_csr_matrix (Buffer version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void init_csr_matrix (sycl::queue &queue, - oneapi::mkl::sparse::matrix_handle_t *p_smhandle, + oneapi::math::sparse::matrix_handle_t *p_smhandle, std::int64_t num_rows, std::int64_t num_cols, std::int64_t nnz, @@ -63,10 +63,10 @@ init_csr_matrix (Buffer version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. + See :ref:`supported template types`. indexType - See :ref:`supported template types`. + See :ref:`supported template types`. .. container:: section @@ -91,21 +91,21 @@ init_csr_matrix (Buffer version) index Indicates how input arrays are indexed. The possible options are described - in :ref:`onemkl_enum_index_base` enum class. + in :ref:`onemath_enum_index_base` enum class. row_ptr Buffer of length at least ``num_rows+1``. Refer to - :ref:`onemkl_sparse_csr` format for detailed description of ``row_ptr``. + :ref:`onemath_sparse_csr` format for detailed description of ``row_ptr``. col_ind Buffer of length at least ``nnz`` containing the column indices in - ``index``-based numbering. Refer to :ref:`onemkl_sparse_csr` format for + ``index``-based numbering. Refer to :ref:`onemath_sparse_csr` format for detailed description of ``col_ind``. val Buffer of length at least ``nnz``. Contains the data of the input matrix which is not implicitly zero. The remaining input values are implicit - zeros. Refer to :ref:`onemkl_sparse_csr` format for detailed description + zeros. Refer to :ref:`onemath_sparse_csr` format for detailed description of ``val``. .. container:: section @@ -134,12 +134,12 @@ init_csr_matrix (Buffer version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::host_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::host_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_init_csr_matrix_usm: +.. _onemath_sparse_init_csr_matrix_usm: init_csr_matrix (USM version) ----------------------------- @@ -148,11 +148,11 @@ init_csr_matrix (USM version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void init_csr_matrix (sycl::queue &queue, - oneapi::mkl::sparse::matrix_handle_t *p_smhandle, + oneapi::math::sparse::matrix_handle_t *p_smhandle, std::int64_t num_rows, std::int64_t num_cols, std::int64_t nnz, @@ -168,10 +168,10 @@ init_csr_matrix (USM version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. + See :ref:`supported template types`. indexType - See :ref:`supported template types`. + See :ref:`supported template types`. .. container:: section @@ -196,23 +196,23 @@ init_csr_matrix (USM version) index Indicates how input arrays are indexed. The possible options are described - in :ref:`onemkl_enum_index_base` enum class. + in :ref:`onemath_enum_index_base` enum class. row_ptr USM pointer of length at least ``num_rows+1``. Refer to - :ref:`onemkl_sparse_csr` format for detailed description of ``row_ptr``. + :ref:`onemath_sparse_csr` format for detailed description of ``row_ptr``. The data must be accessible on the device. col_ind USM pointer of length at least ``nnz`` containing the column indices in - ``index``-based numbering. Refer to :ref:`onemkl_sparse_csr` format for + ``index``-based numbering. Refer to :ref:`onemath_sparse_csr` format for detailed description of ``col_ind``. The data must be accessible on the device. val USM pointer of length at least ``nnz``. Contains the data of the input matrix which is not implicitly zero. The remaining input values are - implicit zeros. Refer to :ref:`onemkl_sparse_csr` format for detailed + implicit zeros. Refer to :ref:`onemath_sparse_csr` format for detailed description of ``val``. The data must be accessible on the device. Using a USM pointer with a smaller allocated memory size is undefined behavior. @@ -242,9 +242,9 @@ init_csr_matrix (USM version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::host_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::host_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_sparse_data_handles` +**Parent topic:** :ref:`onemath_sparse_data_handles` diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/init_dense_matrix.rst b/source/elements/oneMath/source/domains/spblas/data_types/init_dense_matrix.rst similarity index 79% rename from source/elements/oneMKL/source/domains/spblas/data_types/init_dense_matrix.rst rename to source/elements/oneMath/source/domains/spblas/data_types/init_dense_matrix.rst index 15c37b4986..e5a59424bc 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/init_dense_matrix.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/init_dense_matrix.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_init_dense_matrix: +.. _onemath_sparse_init_dense_matrix: init_dense_matrix ================= @@ -11,7 +11,7 @@ Initializes a ``dense_matrix_handle_t`` object with the provided data. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::init_dense_matrix`` function initializes the +The ``oneapi::math::sparse::init_dense_matrix`` function initializes the ``dense_matrix_handle_t`` object with the provided data. In the case of buffers, the reference count of the provided buffer is @@ -21,9 +21,9 @@ with ``set_dense_matrix_data``. In the case of USM, the object does not take ownership of the data. -See :ref:`onemkl_sparse_dense_matrix_handle`. +See :ref:`onemath_sparse_dense_matrix_handle`. -.. _onemkl_sparse_init_dense_matrix_buffer: +.. _onemath_sparse_init_dense_matrix_buffer: init_dense_matrix (Buffer version) ---------------------------------- @@ -32,11 +32,11 @@ init_dense_matrix (Buffer version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void init_dense_matrix (sycl::queue &queue, - oneapi::mkl::sparse::dense_matrix_handle_t *p_dmhandle, + oneapi::math::sparse::dense_matrix_handle_t *p_dmhandle, std::int64_t num_rows, std::int64_t num_cols, std::int64_t ld, @@ -50,7 +50,7 @@ init_dense_matrix (Buffer version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. + See :ref:`supported template types`. .. container:: section @@ -100,12 +100,12 @@ init_dense_matrix (Buffer version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::host_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::host_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_init_dense_matrix_usm: +.. _onemath_sparse_init_dense_matrix_usm: init_dense_matrix (USM version) ------------------------------- @@ -114,11 +114,11 @@ init_dense_matrix (USM version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void init_dense_matrix (sycl::queue &queue, - oneapi::mkl::sparse::dense_matrix_handle_t *p_dmhandle, + oneapi::math::sparse::dense_matrix_handle_t *p_dmhandle, std::int64_t num_rows, std::int64_t num_cols, std::int64_t ld, @@ -132,7 +132,7 @@ init_dense_matrix (USM version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. + See :ref:`supported template types`. .. container:: section @@ -183,9 +183,9 @@ init_dense_matrix (USM version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::host_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::host_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_sparse_data_handles` +**Parent topic:** :ref:`onemath_sparse_data_handles` diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/init_dense_vector.rst b/source/elements/oneMath/source/domains/spblas/data_types/init_dense_vector.rst similarity index 74% rename from source/elements/oneMKL/source/domains/spblas/data_types/init_dense_vector.rst rename to source/elements/oneMath/source/domains/spblas/data_types/init_dense_vector.rst index 50b6de6c78..4d72c1be13 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/init_dense_vector.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/init_dense_vector.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_init_dense_vector: +.. _onemath_sparse_init_dense_vector: init_dense_vector ================= @@ -11,7 +11,7 @@ Initializes a ``dense_vector_handle_t`` object with the provided data. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::init_dense_vector`` function initializes the +The ``oneapi::math::sparse::init_dense_vector`` function initializes the ``dense_vector_handle_t`` object with the provided data. In the case of buffers, the reference count of the provided buffer is @@ -21,9 +21,9 @@ with ``set_dense_vector_data``. In the case of USM, the object does not take ownership of the data. -See :ref:`onemkl_sparse_dense_vector_handle`. +See :ref:`onemath_sparse_dense_vector_handle`. -.. _onemkl_sparse_init_dense_vector_buffer: +.. _onemath_sparse_init_dense_vector_buffer: init_dense_vector (Buffer version) ---------------------------------- @@ -32,11 +32,11 @@ init_dense_vector (Buffer version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void init_dense_vector (sycl::queue &queue, - oneapi::mkl::sparse::dense_vector_handle_t *p_dvhandle, + oneapi::math::sparse::dense_vector_handle_t *p_dvhandle, std::int64_t size, sycl::buffer val); @@ -47,7 +47,7 @@ init_dense_vector (Buffer version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. + See :ref:`supported template types`. .. container:: section @@ -85,12 +85,12 @@ init_dense_vector (Buffer version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::host_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::host_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_init_dense_vector_usm: +.. _onemath_sparse_init_dense_vector_usm: init_dense_vector (USM version) ------------------------------- @@ -99,11 +99,11 @@ init_dense_vector (USM version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void init_dense_vector (sycl::queue &queue, - oneapi::mkl::sparse::dense_vector_handle_t *p_dvhandle, + oneapi::math::sparse::dense_vector_handle_t *p_dvhandle, std::int64_t size, dataType *val); @@ -114,7 +114,7 @@ init_dense_vector (USM version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. + See :ref:`supported template types`. .. container:: section @@ -153,9 +153,9 @@ init_dense_vector (USM version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::host_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::host_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_sparse_data_handles` +**Parent topic:** :ref:`onemath_sparse_data_handles` diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/release_dense_matrix.rst b/source/elements/oneMath/source/domains/spblas/data_types/release_dense_matrix.rst similarity index 68% rename from source/elements/oneMKL/source/domains/spblas/data_types/release_dense_matrix.rst rename to source/elements/oneMath/source/domains/spblas/data_types/release_dense_matrix.rst index 2d77606e11..69ab4e79cf 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/release_dense_matrix.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/release_dense_matrix.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_release_dense_matrix: +.. _onemath_sparse_release_dense_matrix: release_dense_matrix ==================== @@ -11,7 +11,7 @@ Destroys a ``dense_matrix_handle_t`` object. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::release_dense_matrix`` function frees the resources +The ``oneapi::math::sparse::release_dense_matrix`` function frees the resources allocated for the handle. If a buffer was provided, its reference count is decremented. @@ -22,10 +22,10 @@ If a USM pointer was provided, the data is not free'd. .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { sycl::event release_dense_matrix (sycl::queue &queue, - oneapi::mkl::sparse::dense_matrix_handle_t dmhandle, + oneapi::math::sparse::dense_matrix_handle_t dmhandle, const std::vector &dependencies = {}); } @@ -38,7 +38,7 @@ If a USM pointer was provided, the data is not free'd. The SYCL command queue which will be used for SYCL kernels execution. dmhandle - Handle initialized with :ref:`onemkl_sparse_init_dense_matrix`. + Handle initialized with :ref:`onemath_sparse_init_dense_matrix`. dependencies List of events to depend on before starting asynchronous tasks that access @@ -60,8 +60,8 @@ If a USM pointer was provided, the data is not free'd. implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_sparse_data_handles` +**Parent topic:** :ref:`onemath_sparse_data_handles` diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/release_dense_vector.rst b/source/elements/oneMath/source/domains/spblas/data_types/release_dense_vector.rst similarity index 68% rename from source/elements/oneMKL/source/domains/spblas/data_types/release_dense_vector.rst rename to source/elements/oneMath/source/domains/spblas/data_types/release_dense_vector.rst index 73b1860489..41bc6ffc1a 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/release_dense_vector.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/release_dense_vector.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_release_dense_vector: +.. _onemath_sparse_release_dense_vector: release_dense_vector ==================== @@ -11,7 +11,7 @@ Destroys a ``dense_vector_handle_t`` object. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::release_dense_vector`` function frees the resources +The ``oneapi::math::sparse::release_dense_vector`` function frees the resources allocated for the handle. If a buffer was provided, its reference count is decremented. @@ -22,10 +22,10 @@ If a USM pointer was provided, the data is not free'd. .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { sycl::event release_dense_vector (sycl::queue &queue, - oneapi::mkl::sparse::dense_vector_handle_t dvhandle, + oneapi::math::sparse::dense_vector_handle_t dvhandle, const std::vector &dependencies = {}); } @@ -38,7 +38,7 @@ If a USM pointer was provided, the data is not free'd. The SYCL command queue which will be used for SYCL kernels execution. dvhandle - Handle initialized with :ref:`onemkl_sparse_init_dense_vector`. + Handle initialized with :ref:`onemath_sparse_init_dense_vector`. dependencies List of events to depend on before starting asynchronous tasks that access @@ -60,8 +60,8 @@ If a USM pointer was provided, the data is not free'd. implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_sparse_data_handles` +**Parent topic:** :ref:`onemath_sparse_data_handles` diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/release_sparse_matrix.rst b/source/elements/oneMath/source/domains/spblas/data_types/release_sparse_matrix.rst similarity index 67% rename from source/elements/oneMKL/source/domains/spblas/data_types/release_sparse_matrix.rst rename to source/elements/oneMath/source/domains/spblas/data_types/release_sparse_matrix.rst index d1d549335f..7448e215e8 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/release_sparse_matrix.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/release_sparse_matrix.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_release_sparse_matrix: +.. _onemath_sparse_release_sparse_matrix: release_sparse_matrix ===================== @@ -11,7 +11,7 @@ Destroys a ``matrix_handle_t`` object. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::release_sparse_matrix`` function frees the resources +The ``oneapi::math::sparse::release_sparse_matrix`` function frees the resources allocated for the handle. If a buffer was provided, its reference count is decremented. @@ -22,10 +22,10 @@ If a USM pointer was provided, the data is not free'd. .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { sycl::event release_sparse_matrix (sycl::queue &queue, - oneapi::mkl::sparse::matrix_handle_t smhandle, + oneapi::math::sparse::matrix_handle_t smhandle, const std::vector &dependencies = {}); } @@ -38,8 +38,8 @@ If a USM pointer was provided, the data is not free'd. The SYCL command queue which will be used for SYCL kernels execution. smhandle - Handle initialized with :ref:`onemkl_sparse_init_csr_matrix` or - :ref:`onemkl_sparse_init_coo_matrix`. + Handle initialized with :ref:`onemath_sparse_init_csr_matrix` or + :ref:`onemath_sparse_init_coo_matrix`. dependencies List of events to depend on before starting asynchronous tasks that access @@ -61,8 +61,8 @@ If a USM pointer was provided, the data is not free'd. implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_sparse_data_handles` \ No newline at end of file +**Parent topic:** :ref:`onemath_sparse_data_handles` \ No newline at end of file diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/set_coo_matrix_data.rst b/source/elements/oneMath/source/domains/spblas/data_types/set_coo_matrix_data.rst similarity index 72% rename from source/elements/oneMKL/source/domains/spblas/data_types/set_coo_matrix_data.rst rename to source/elements/oneMath/source/domains/spblas/data_types/set_coo_matrix_data.rst index a12311d319..832fa23d14 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/set_coo_matrix_data.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/set_coo_matrix_data.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_set_coo_matrix_data: +.. _onemath_sparse_set_coo_matrix_data: set_coo_matrix_data =================== @@ -11,7 +11,7 @@ Reset the data of a ``matrix_handle_t`` object with the provided COO data. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::set_coo_matrix_data`` function sets new data to the +The ``oneapi::math::sparse::set_coo_matrix_data`` function sets new data to the ``matrix_handle_t`` object with the provided data. In the case of buffers, the reference count of the provided buffer is @@ -21,9 +21,9 @@ with ``set_coo_matrix_data``. In the case of USM, the object does not take ownership of the data. -Also see :ref:`onemkl_sparse_init_coo_matrix`. +Also see :ref:`onemath_sparse_init_coo_matrix`. -.. _onemkl_sparse_set_coo_matrix_data_buffer: +.. _onemath_sparse_set_coo_matrix_data_buffer: set_coo_matrix_data (Buffer version) ------------------------------------ @@ -32,11 +32,11 @@ set_coo_matrix_data (Buffer version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void set_coo_matrix_data (sycl::queue &queue, - oneapi::mkl::sparse::matrix_handle_t smhandle, + oneapi::math::sparse::matrix_handle_t smhandle, std::int64_t num_rows, std::int64_t num_cols, std::int64_t nnz, @@ -52,11 +52,11 @@ set_coo_matrix_data (Buffer version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. Must + See :ref:`supported template types`. Must be the same type as was used when creating the ``matrix_handle_t``. indexType - See :ref:`supported template types`. Must + See :ref:`supported template types`. Must be the same type as was used when creating the ``matrix_handle_t``. .. container:: section @@ -67,7 +67,7 @@ set_coo_matrix_data (Buffer version) The SYCL command queue which will be used for SYCL kernels execution. smhandle - Handle already initialized with :ref:`onemkl_sparse_init_coo_matrix`. + Handle already initialized with :ref:`onemath_sparse_init_coo_matrix`. num_rows Number of rows of the provided data ``val``. Must be at least 0. @@ -81,22 +81,22 @@ set_coo_matrix_data (Buffer version) index Indicates how input arrays are indexed. The possible options are described - in :ref:`onemkl_enum_index_base` enum class. + in :ref:`onemath_enum_index_base` enum class. row_ind Buffer of length at least ``nnz`` containing the row indices in - ``index``-based numbering. Refer to :ref:`onemkl_sparse_coo` format for + ``index``-based numbering. Refer to :ref:`onemath_sparse_coo` format for detailed description of ``row_ind``. col_ind Buffer of length at least ``nnz`` containing the column indices in - ``index``-based numbering. Refer to :ref:`onemkl_sparse_coo` format for + ``index``-based numbering. Refer to :ref:`onemath_sparse_coo` format for detailed description of ``col_ind``. val Buffer of length at least ``nnz``. Contains the data of the input matrix which is not implicitly zero. The remaining input values are implicit - zeros. Refer to :ref:`onemkl_sparse_coo` format for detailed description + zeros. Refer to :ref:`onemath_sparse_coo` format for detailed description of ``val``. .. container:: section @@ -116,12 +116,12 @@ set_coo_matrix_data (Buffer version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::uninitialized` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::uninitialized` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_set_coo_matrix_data_usm: +.. _onemath_sparse_set_coo_matrix_data_usm: set_coo_matrix_data (USM version) --------------------------------- @@ -130,11 +130,11 @@ set_coo_matrix_data (USM version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void set_coo_matrix_data (sycl::queue &queue, - oneapi::mkl::sparse::matrix_handle_t smhandle, + oneapi::math::sparse::matrix_handle_t smhandle, std::int64_t num_rows, std::int64_t num_cols, std::int64_t nnz, @@ -150,11 +150,11 @@ set_coo_matrix_data (USM version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. Must + See :ref:`supported template types`. Must be the same type as was used when creating the ``matrix_handle_t``. indexType - See :ref:`supported template types`. Must + See :ref:`supported template types`. Must be the same type as was used when creating the ``matrix_handle_t``. .. container:: section @@ -165,7 +165,7 @@ set_coo_matrix_data (USM version) The SYCL command queue which will be used for SYCL kernels execution. smhandle - Handle already initialized with :ref:`onemkl_sparse_init_coo_matrix`. + Handle already initialized with :ref:`onemath_sparse_init_coo_matrix`. num_rows Number of rows of the provided data ``val``. Must be at least 0. @@ -179,24 +179,24 @@ set_coo_matrix_data (USM version) index Indicates how input arrays are indexed. The possible options are described - in :ref:`onemkl_enum_index_base` enum class. + in :ref:`onemath_enum_index_base` enum class. row_ind USM pointer of length at least ``nnz`` containing the row indices in - ``index``-based numbering. Refer to :ref:`onemkl_sparse_coo` format for + ``index``-based numbering. Refer to :ref:`onemath_sparse_coo` format for detailed description of ``row_ind``. The data must be accessible on the device. col_ind USM pointer of length at least ``nnz`` containing the column indices in - ``index``-based numbering. Refer to :ref:`onemkl_sparse_coo` format for + ``index``-based numbering. Refer to :ref:`onemath_sparse_coo` format for detailed description of ``col_ind``. The data must be accessible on the device. val USM pointer of length at least ``nnz``. Contains the data of the input matrix which is not implicitly zero. The remaining input values are - implicit zeros. Refer to :ref:`onemkl_sparse_coo` format for detailed + implicit zeros. Refer to :ref:`onemath_sparse_coo` format for detailed description of ``val``. The data must be accessible on the device. Using a USM pointer with a smaller allocated memory size is undefined behavior. @@ -217,9 +217,9 @@ set_coo_matrix_data (USM version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::uninitialized` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::uninitialized` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_sparse_data_handles` +**Parent topic:** :ref:`onemath_sparse_data_handles` diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/set_csr_matrix_data.rst b/source/elements/oneMath/source/domains/spblas/data_types/set_csr_matrix_data.rst similarity index 72% rename from source/elements/oneMKL/source/domains/spblas/data_types/set_csr_matrix_data.rst rename to source/elements/oneMath/source/domains/spblas/data_types/set_csr_matrix_data.rst index 8b95277559..49a13ac684 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/set_csr_matrix_data.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/set_csr_matrix_data.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_set_csr_matrix_data: +.. _onemath_sparse_set_csr_matrix_data: set_csr_matrix_data =================== @@ -11,7 +11,7 @@ Reset the data of a ``matrix_handle_t`` object with the provided CSR data. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::set_csr_matrix_data`` function sets new data to the +The ``oneapi::math::sparse::set_csr_matrix_data`` function sets new data to the ``matrix_handle_t`` object with the provided data. In the case of buffers, the reference count of the provided buffer is @@ -21,9 +21,9 @@ with ``set_csr_matrix_data``. In the case of USM, the object does not take ownership of the data. -Also see :ref:`onemkl_sparse_init_csr_matrix`. +Also see :ref:`onemath_sparse_init_csr_matrix`. -.. _onemkl_sparse_set_csr_matrix_data_buffer: +.. _onemath_sparse_set_csr_matrix_data_buffer: set_csr_matrix_data (Buffer version) ------------------------------------ @@ -32,11 +32,11 @@ set_csr_matrix_data (Buffer version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void set_csr_matrix_data (sycl::queue &queue, - oneapi::mkl::sparse::matrix_handle_t smhandle, + oneapi::math::sparse::matrix_handle_t smhandle, std::int64_t num_rows, std::int64_t num_cols, std::int64_t nnz, @@ -52,11 +52,11 @@ set_csr_matrix_data (Buffer version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. Must + See :ref:`supported template types`. Must be the same type as was used when creating the ``matrix_handle_t``. indexType - See :ref:`supported template types`. Must + See :ref:`supported template types`. Must be the same type as was used when creating the ``matrix_handle_t``. .. container:: section @@ -67,7 +67,7 @@ set_csr_matrix_data (Buffer version) The SYCL command queue which will be used for SYCL kernels execution. smhandle - Handle already initialized with :ref:`onemkl_sparse_init_csr_matrix`. + Handle already initialized with :ref:`onemath_sparse_init_csr_matrix`. num_rows Number of rows of the provided data ``val``. Must be at least 0. @@ -81,21 +81,21 @@ set_csr_matrix_data (Buffer version) index Indicates how input arrays are indexed. The possible options are described - in :ref:`onemkl_enum_index_base` enum class. + in :ref:`onemath_enum_index_base` enum class. row_ptr Buffer of length at least ``num_rows+1``. Refer to - :ref:`onemkl_sparse_csr` format for detailed description of ``row_ptr``. + :ref:`onemath_sparse_csr` format for detailed description of ``row_ptr``. col_ind Buffer of length at least ``nnz`` containing the column indices in - ``index``-based numbering. Refer to :ref:`onemkl_sparse_csr` format for + ``index``-based numbering. Refer to :ref:`onemath_sparse_csr` format for detailed description of ``col_ind``. val Buffer of length at least ``nnz``. Contains the data of the input matrix which is not implicitly zero. The remaining input values are implicit - zeros. Refer to :ref:`onemkl_sparse_csr` format for detailed description + zeros. Refer to :ref:`onemath_sparse_csr` format for detailed description of ``val``. .. container:: section @@ -115,12 +115,12 @@ set_csr_matrix_data (Buffer version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::uninitialized` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::uninitialized` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_set_csr_matrix_data_usm: +.. _onemath_sparse_set_csr_matrix_data_usm: set_csr_matrix_data (USM version) --------------------------------- @@ -129,11 +129,11 @@ set_csr_matrix_data (USM version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void set_csr_matrix_data (sycl::queue &queue, - oneapi::mkl::sparse::matrix_handle_t smhandle, + oneapi::math::sparse::matrix_handle_t smhandle, std::int64_t num_rows, std::int64_t num_cols, std::int64_t nnz, @@ -149,11 +149,11 @@ set_csr_matrix_data (USM version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. Must + See :ref:`supported template types`. Must be the same type as was used when creating the ``matrix_handle_t``. indexType - See :ref:`supported template types`. Must + See :ref:`supported template types`. Must be the same type as was used when creating the ``matrix_handle_t``. .. container:: section @@ -164,7 +164,7 @@ set_csr_matrix_data (USM version) The SYCL command queue which will be used for SYCL kernels execution. smhandle - Handle already initialized with :ref:`onemkl_sparse_init_csr_matrix`. + Handle already initialized with :ref:`onemath_sparse_init_csr_matrix`. num_rows Number of rows of the provided data ``val``. Must be at least 0. @@ -178,23 +178,23 @@ set_csr_matrix_data (USM version) index Indicates how input arrays are indexed. The possible options are described - in :ref:`onemkl_enum_index_base` enum class. + in :ref:`onemath_enum_index_base` enum class. row_ptr USM pointer of length at least ``num_rows+1``. Refer to - :ref:`onemkl_sparse_csr` format for detailed description of ``row_ptr``. + :ref:`onemath_sparse_csr` format for detailed description of ``row_ptr``. The data must be accessible on the device. col_ind USM pointer of length at least ``nnz`` containing the column indices in - ``index``-based numbering. Refer to :ref:`onemkl_sparse_csr` format for + ``index``-based numbering. Refer to :ref:`onemath_sparse_csr` format for detailed description of ``col_ind``. The data must be accessible on the device. val USM pointer of length at least ``nnz``. Contains the data of the input matrix which is not implicitly zero. The remaining input values are - implicit zeros. Refer to :ref:`onemkl_sparse_csr` format for detailed + implicit zeros. Refer to :ref:`onemath_sparse_csr` format for detailed description of ``val``. The data must be accessible on the device. Using a USM pointer with a smaller allocated memory size is undefined behavior. @@ -215,9 +215,9 @@ set_csr_matrix_data (USM version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::uninitialized` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::uninitialized` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_sparse_data_handles` +**Parent topic:** :ref:`onemath_sparse_data_handles` diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/set_dense_matrix_data.rst b/source/elements/oneMath/source/domains/spblas/data_types/set_dense_matrix_data.rst similarity index 74% rename from source/elements/oneMKL/source/domains/spblas/data_types/set_dense_matrix_data.rst rename to source/elements/oneMath/source/domains/spblas/data_types/set_dense_matrix_data.rst index 0eab72f6b8..fca0be2f22 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/set_dense_matrix_data.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/set_dense_matrix_data.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_set_dense_matrix_data: +.. _onemath_sparse_set_dense_matrix_data: set_dense_matrix_data ===================== @@ -11,7 +11,7 @@ Reset the data of a ``dense_matrix_handle_t`` object. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::set_dense_matrix_data`` function sets new data to the +The ``oneapi::math::sparse::set_dense_matrix_data`` function sets new data to the ``dense_matrix_handle_t`` object with the provided data. In the case of buffers, the reference count of the provided buffer is @@ -21,9 +21,9 @@ with ``set_dense_matrix_data``. In the case of USM, the object does not take ownership of the data. -Also see :ref:`onemkl_sparse_init_dense_matrix`. +Also see :ref:`onemath_sparse_init_dense_matrix`. -.. _onemkl_sparse_set_dense_matrix_data_buffer: +.. _onemath_sparse_set_dense_matrix_data_buffer: set_dense_matrix_data (Buffer version) -------------------------------------- @@ -32,11 +32,11 @@ set_dense_matrix_data (Buffer version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void set_dense_matrix_data (sycl::queue &queue, - oneapi::mkl::sparse::dense_matrix_handle_t dmhandle, + oneapi::math::sparse::dense_matrix_handle_t dmhandle, std::int64_t num_rows, std::int64_t num_cols, std::int64_t ld, @@ -50,7 +50,7 @@ set_dense_matrix_data (Buffer version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. Must + See :ref:`supported template types`. Must be the same type as was used when creating the ``dense_matrix_handle_t``. .. container:: section @@ -61,7 +61,7 @@ set_dense_matrix_data (Buffer version) The SYCL command queue which will be used for SYCL kernels execution. dmhandle - Handle already initialized with :ref:`onemkl_sparse_init_dense_matrix`. + Handle already initialized with :ref:`onemath_sparse_init_dense_matrix`. num_rows Number of rows of the provided data ``val``. Must be at least 0. @@ -90,12 +90,12 @@ set_dense_matrix_data (Buffer version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::uninitialized` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::uninitialized` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_set_dense_matrix_data_usm: +.. _onemath_sparse_set_dense_matrix_data_usm: set_dense_matrix_data (USM version) ----------------------------------- @@ -104,11 +104,11 @@ set_dense_matrix_data (USM version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void set_dense_matrix_data (sycl::queue &queue, - oneapi::mkl::sparse::dense_matrix_handle_t dmhandle, + oneapi::math::sparse::dense_matrix_handle_t dmhandle, std::int64_t num_rows, std::int64_t num_cols, std::int64_t ld, @@ -122,7 +122,7 @@ set_dense_matrix_data (USM version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. Must + See :ref:`supported template types`. Must be the same type as was used when creating the ``dense_matrix_handle_t``. .. container:: section @@ -133,7 +133,7 @@ set_dense_matrix_data (USM version) The SYCL command queue which will be used for SYCL kernels execution. dmhandle - Handle already initialized with :ref:`onemkl_sparse_init_dense_matrix`. + Handle already initialized with :ref:`onemath_sparse_init_dense_matrix`. num_rows Number of rows of the provided data ``val``. Must be at least 1. @@ -164,9 +164,9 @@ set_dense_matrix_data (USM version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::uninitialized` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::uninitialized` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_sparse_data_handles` +**Parent topic:** :ref:`onemath_sparse_data_handles` diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/set_dense_vector_data.rst b/source/elements/oneMath/source/domains/spblas/data_types/set_dense_vector_data.rst similarity index 66% rename from source/elements/oneMKL/source/domains/spblas/data_types/set_dense_vector_data.rst rename to source/elements/oneMath/source/domains/spblas/data_types/set_dense_vector_data.rst index c882f07079..7b92e4ccd2 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/set_dense_vector_data.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/set_dense_vector_data.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_set_dense_vector_data: +.. _onemath_sparse_set_dense_vector_data: set_dense_vector_data ===================== @@ -11,7 +11,7 @@ Reset the data of a ``dense_vector_handle_t`` object. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::set_dense_vector_data`` function sets new data to the +The ``oneapi::math::sparse::set_dense_vector_data`` function sets new data to the ``dense_vector_handle_t`` object. In the case of buffers, the reference count of the provided buffer is @@ -21,9 +21,9 @@ with ``set_dense_vector_data``. In the case of USM, the object does not take ownership of the data. -Also see :ref:`onemkl_sparse_init_dense_vector`. +Also see :ref:`onemath_sparse_init_dense_vector`. -.. _onemkl_sparse_set_dense_vector_data_buffer: +.. _onemath_sparse_set_dense_vector_data_buffer: set_dense_vector_data (Buffer version) -------------------------------------- @@ -32,11 +32,11 @@ set_dense_vector_data (Buffer version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void set_dense_vector_data (sycl::queue &queue, - oneapi::mkl::sparse::dense_vector_handle_t dvhandle, + oneapi::math::sparse::dense_vector_handle_t dvhandle, std::int64_t size, sycl::buffer val); @@ -47,7 +47,7 @@ set_dense_vector_data (Buffer version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. Must + See :ref:`supported template types`. Must be the same type as was used when creating the ``dense_vector_handle_t``. .. container:: section @@ -58,7 +58,7 @@ set_dense_vector_data (Buffer version) The SYCL command queue which will be used for SYCL kernels execution. dvhandle - Handle already initialized with :ref:`onemkl_sparse_init_dense_vector`. + Handle already initialized with :ref:`onemath_sparse_init_dense_vector`. size Number of elements of the provided data ``val``. Must be at least 0. @@ -75,12 +75,12 @@ set_dense_vector_data (Buffer version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::uninitialized` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::uninitialized` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_set_dense_vector_data_usm: +.. _onemath_sparse_set_dense_vector_data_usm: set_dense_vector_data (USM version) ----------------------------------- @@ -89,11 +89,11 @@ set_dense_vector_data (USM version) .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { template void set_dense_vector_data (sycl::queue &queue, - oneapi::mkl::sparse::dense_vector_handle_t dvhandle, + oneapi::math::sparse::dense_vector_handle_t dvhandle, std::int64_t size, dataType *val); @@ -104,7 +104,7 @@ set_dense_vector_data (USM version) .. rubric:: Template parameters dataType - See :ref:`supported template types`. Must + See :ref:`supported template types`. Must be the same type as was used when creating the ``dense_vector_handle_t``. .. container:: section @@ -115,7 +115,7 @@ set_dense_vector_data (USM version) The SYCL command queue which will be used for SYCL kernels execution. dvhandle - Handle already initialized with :ref:`onemkl_sparse_init_dense_vector`. + Handle already initialized with :ref:`onemath_sparse_init_dense_vector`. size Number of elements of the provided data ``val``. Must be at least 1. @@ -134,9 +134,9 @@ set_dense_vector_data (USM version) implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::uninitialized` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::uninitialized` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_sparse_data_handles` +**Parent topic:** :ref:`onemath_sparse_data_handles` diff --git a/source/elements/oneMKL/source/domains/spblas/data_types/set_matrix_property.rst b/source/elements/oneMath/source/domains/spblas/data_types/set_matrix_property.rst similarity index 78% rename from source/elements/oneMKL/source/domains/spblas/data_types/set_matrix_property.rst rename to source/elements/oneMath/source/domains/spblas/data_types/set_matrix_property.rst index 4e2014b7f3..a277c3c910 100644 --- a/source/elements/oneMKL/source/domains/spblas/data_types/set_matrix_property.rst +++ b/source/elements/oneMath/source/domains/spblas/data_types/set_matrix_property.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_set_matrix_property: +.. _onemath_sparse_set_matrix_property: set_matrix_property =================== @@ -14,7 +14,7 @@ Matrix properties .. code:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { enum class matrix_property { symmetric, @@ -25,7 +25,7 @@ Matrix properties } Matrix properties are optional and "strong" guarantees. Unlike - :ref:`onemkl_sparse_matrix_view`, the user must ensure that the handle's data + :ref:`onemath_sparse_matrix_view`, the user must ensure that the handle's data holds all the given properties. A property can be set as a hint for backends to optimize some operations. Multiple properties can be set to the same handle. @@ -69,7 +69,7 @@ details the property for each matrix format: - Description * - CSR - Setting this property for a matrix using the CSR format will throw a - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` exception. * - COO - Guarantees that the indices are sorted by rows in ascending order. @@ -82,17 +82,17 @@ Set a property to a ``matrix_handle_t`` object. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::set_matrix_property`` function sets a property to a +The ``oneapi::math::sparse::set_matrix_property`` function sets a property to a matrix handle. .. rubric:: Syntax .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { bool set_matrix_property (sycl::queue &queue, - oneapi::mkl::sparse::matrix_handle_t smhandle, + oneapi::math::sparse::matrix_handle_t smhandle, matrix_property property); } @@ -126,9 +126,9 @@ matrix handle. implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::uninitialized` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::uninitialized` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_sparse_data_handles` +**Parent topic:** :ref:`onemath_sparse_data_handles` diff --git a/source/elements/oneMKL/source/domains/spblas/matrix_view.rst b/source/elements/oneMath/source/domains/spblas/matrix_view.rst similarity index 83% rename from source/elements/oneMKL/source/domains/spblas/matrix_view.rst rename to source/elements/oneMath/source/domains/spblas/matrix_view.rst index 0c0bb6535e..e7f9e8c6e8 100644 --- a/source/elements/oneMKL/source/domains/spblas/matrix_view.rst +++ b/source/elements/oneMath/source/domains/spblas/matrix_view.rst @@ -2,12 +2,12 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_matrix_view_and_descr: +.. _onemath_sparse_matrix_view_and_descr: Matrix view =========== -.. _onemkl_sparse_matrix_descriptor: +.. _onemath_sparse_matrix_descriptor: matrix_descr ------------ @@ -16,7 +16,7 @@ matrix_descr .. code:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { enum class matrix_descr { general, @@ -51,7 +51,7 @@ matrix_descr * - ``diagonal`` - View as diagonal, use only main diagonal values. -.. _onemkl_sparse_matrix_view: +.. _onemath_sparse_matrix_view: matrix_view ----------- @@ -60,7 +60,7 @@ matrix_view .. code:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { struct matrix_view { matrix_descr type_view = matrix_descr::general; @@ -81,8 +81,8 @@ matrix_view The matrix view holds information to specify which part of the matrix should be read without changing the matrix's data. - See :ref:`onemkl_sparse_matrix_descriptor`, :ref:`onemkl_enum_uplo` and - :ref:`onemkl_enum_diag` for a description of the members. + See :ref:`onemath_sparse_matrix_descriptor`, :ref:`onemath_enum_uplo` and + :ref:`onemath_enum_diag` for a description of the members. Each operation documents which combination of ``type_view``, ``uplo_view`` and ``diag_view`` are valid. @@ -91,7 +91,7 @@ matrix_view .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { matrix_view::matrix_view () = default; @@ -108,7 +108,7 @@ matrix_view .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { matrix_view::matrix_view(matrix_descr type_view); @@ -122,4 +122,4 @@ matrix_view the other members are initialized to the same value as the default constructor. -**Parent topic:** :ref:`onemkl_spblas` +**Parent topic:** :ref:`onemath_spblas` diff --git a/source/elements/oneMKL/source/domains/spblas/operations/spmm.rst b/source/elements/oneMath/source/domains/spblas/operations/spmm.rst similarity index 67% rename from source/elements/oneMKL/source/domains/spblas/operations/spmm.rst rename to source/elements/oneMath/source/domains/spblas/operations/spmm.rst index 08b64595ee..4b9366fa93 100644 --- a/source/elements/oneMKL/source/domains/spblas/operations/spmm.rst +++ b/source/elements/oneMath/source/domains/spblas/operations/spmm.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_spmm_header: +.. _onemath_sparse_spmm_header: spmm ==== @@ -11,7 +11,7 @@ Computes a sparse matrix by dense matrix product. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::spmm`` routine computes a sparse matrix by dense +The ``oneapi::math::sparse::spmm`` routine computes a sparse matrix by dense matrix product defined as: .. math:: @@ -28,12 +28,12 @@ matrix product defined as: .. math:: - \text{op}(A) = \begin{cases} A,& \text{oneapi::mkl::transpose::nontrans}\\ - A^\mathsf{T},& \text{oneapi::mkl::transpose::trans}\\ - A^\mathsf{H},& \text{oneapi::mkl::transpose::conjtrans} + \text{op}(A) = \begin{cases} A,& \text{oneapi::math::transpose::nontrans}\\ + A^\mathsf{T},& \text{oneapi::math::transpose::trans}\\ + A^\mathsf{H},& \text{oneapi::math::transpose::conjtrans} \end{cases} -.. _onemkl_sparse_spmm_descr: +.. _onemath_sparse_spmm_descr: spmm_descr ---------- @@ -42,7 +42,7 @@ spmm_descr .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { struct spmm_descr; using spmm_descr_t = spmm_descr*; @@ -59,7 +59,7 @@ spmm_descr stages of the spmm operation to house relevant state, optimizations and workspaces. -.. _onemkl_sparse_init_spmm_descr: +.. _onemath_sparse_init_spmm_descr: init_spmm_descr --------------- @@ -68,10 +68,10 @@ init_spmm_descr .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { void init_spmm_descr (sycl::queue &queue, - oneapi::mkl::sparse::spmm_descr_t *p_spmm_descr); + oneapi::math::sparse::spmm_descr_t *p_spmm_descr); } @@ -103,12 +103,12 @@ init_spmm_descr implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::host_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::host_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_release_spmm_descr: +.. _onemath_sparse_release_spmm_descr: release_spmm_descr ------------------ @@ -117,10 +117,10 @@ release_spmm_descr .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { sycl::event release_spmm_descr (sycl::queue &queue, - oneapi::mkl::sparse::spmm_descr_t spmm_descr, + oneapi::math::sparse::spmm_descr_t spmm_descr, const std::vector &dependencies = {}); } @@ -155,11 +155,11 @@ release_spmm_descr implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_spmm_alg: +.. _onemath_sparse_spmm_alg: spmm_alg -------- @@ -168,7 +168,7 @@ spmm_alg .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { enum class spmm_alg { default_alg, @@ -195,7 +195,7 @@ spmm_alg implementation-defined and must be documented in the library implementing the oneAPI specification. -.. _onemkl_sparse_spmm: +.. _onemath_sparse_spmm: spmm ---- @@ -204,63 +204,63 @@ spmm .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { void spmm_buffer_size( sycl::queue &queue, - oneapi::mkl::transpose opA, - oneapi::mkl::transpose opB, + oneapi::math::transpose opA, + oneapi::math::transpose opB, const void* alpha, - oneapi::mkl::sparse::matrix_view A_view, - oneapi::mkl::sparse::matrix_handle_t A_handle, - oneapi::mkl::sparse::dense_matrix_handle_t B_handle, + oneapi::math::sparse::matrix_view A_view, + oneapi::math::sparse::matrix_handle_t A_handle, + oneapi::math::sparse::dense_matrix_handle_t B_handle, const void* beta, - oneapi::mkl::sparse::dense_matrix_handle_t C_handle, - oneapi::mkl::sparse::spmm_alg alg, - oneapi::mkl::sparse::spmm_descr_t spmm_descr, + oneapi::math::sparse::dense_matrix_handle_t C_handle, + oneapi::math::sparse::spmm_alg alg, + oneapi::math::sparse::spmm_descr_t spmm_descr, std::size_t &temp_buffer_size); void spmm_optimize( sycl::queue &queue, - oneapi::mkl::transpose opA, - oneapi::mkl::transpose opB, + oneapi::math::transpose opA, + oneapi::math::transpose opB, const void* alpha, - oneapi::mkl::sparse::matrix_view A_view, - oneapi::mkl::sparse::matrix_handle_t A_handle, - oneapi::mkl::sparse::dense_matrix_handle_t B_handle, + oneapi::math::sparse::matrix_view A_view, + oneapi::math::sparse::matrix_handle_t A_handle, + oneapi::math::sparse::dense_matrix_handle_t B_handle, const void* beta, - oneapi::mkl::sparse::dense_matrix_handle_t C_handle, - oneapi::mkl::sparse::spmm_alg alg, - oneapi::mkl::sparse::spmm_descr_t spmm_descr, + oneapi::math::sparse::dense_matrix_handle_t C_handle, + oneapi::math::sparse::spmm_alg alg, + oneapi::math::sparse::spmm_descr_t spmm_descr, sycl::buffer workspace); sycl::event spmm_optimize( sycl::queue &queue, - oneapi::mkl::transpose opA, - oneapi::mkl::transpose opB, + oneapi::math::transpose opA, + oneapi::math::transpose opB, const void* alpha, - oneapi::mkl::sparse::matrix_view A_view, - oneapi::mkl::sparse::matrix_handle_t A_handle, - oneapi::mkl::sparse::dense_matrix_handle_t B_handle, + oneapi::math::sparse::matrix_view A_view, + oneapi::math::sparse::matrix_handle_t A_handle, + oneapi::math::sparse::dense_matrix_handle_t B_handle, const void* beta, - oneapi::mkl::sparse::dense_matrix_handle_t C_handle, - oneapi::mkl::sparse::spmm_alg alg, - oneapi::mkl::sparse::spmm_descr_t spmm_descr, + oneapi::math::sparse::dense_matrix_handle_t C_handle, + oneapi::math::sparse::spmm_alg alg, + oneapi::math::sparse::spmm_descr_t spmm_descr, void* workspace, const std::vector &dependencies = {}); sycl::event spmm( sycl::queue &queue, - oneapi::mkl::transpose opA, - oneapi::mkl::transpose opB, + oneapi::math::transpose opA, + oneapi::math::transpose opB, const void* alpha, - oneapi::mkl::sparse::matrix_view A_view, - oneapi::mkl::sparse::matrix_handle_t A_handle, - oneapi::mkl::sparse::dense_matrix_handle_t B_handle, + oneapi::math::sparse::matrix_view A_view, + oneapi::math::sparse::matrix_handle_t A_handle, + oneapi::math::sparse::dense_matrix_handle_t B_handle, const void* beta, - oneapi::mkl::sparse::dense_matrix_handle_t C_handle, - oneapi::mkl::sparse::spmm_alg alg, - oneapi::mkl::sparse::spmm_descr_t spmm_descr, + oneapi::math::sparse::dense_matrix_handle_t C_handle, + oneapi::math::sparse::spmm_alg alg, + oneapi::math::sparse::spmm_descr_t spmm_descr, const std::vector &dependencies = {}); } @@ -275,11 +275,11 @@ spmm some of the descriptor's data such as the ``workspace``. - In the general case, not calling the functions in the order specified above is undefined behavior. Not calling ``spmm_buffer_size`` or - ``spmm_optimize`` at least once with a given descriptor will throw a - :ref:`oneapi::mkl::uninitialized` + ``spmm_optimize`` at least once with a given descriptor will throw an + :ref:`oneapi::math::uninitialized` exception. Calling ``spmm`` with arguments not matching ``spmm_optimize`` will throw a - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` exception, unless stated otherwise. - The data of the dense handles ``B_handle`` and ``C_handle`` and the scalars ``alpha`` and ``beta`` can be reset before each call to ``spmm``. Changing @@ -299,11 +299,11 @@ spmm opA Specifies operation ``op()`` on the input matrix A. The possible options - are described in :ref:`onemkl_enum_transpose` enum class. + are described in :ref:`onemath_enum_transpose` enum class. opB Specifies operation ``op()`` on the input matrix B. The possible options - are described in :ref:`onemkl_enum_transpose` enum class. + are described in :ref:`onemath_enum_transpose` enum class. alpha Host or USM pointer representing :math:`\alpha`. The USM allocation can be @@ -315,7 +315,7 @@ spmm A_view Specifies which part of the handle should be read as described by - :ref:`onemkl_sparse_matrix_view`. The ``type_view`` field must be + :ref:`onemath_sparse_matrix_view`. The ``type_view`` field must be ``matrix_descr::general`` and the ``uplo_view`` and ``diag_view`` fields are ignored. @@ -337,10 +337,10 @@ spmm Dense matrix handle object representing :math:`C`. alg - Specifies the :ref:`spmm algorithm` to use. + Specifies the :ref:`spmm algorithm` to use. spmm_descr - Initialized :ref:`spmm descriptor`. + Initialized :ref:`spmm descriptor`. temp_buffer_size Output buffer size in bytes. @@ -350,7 +350,7 @@ spmm ``temp_buffer_size`` bytes and the address aligned on the size of the handles' data type. | If it is a buffer, its lifetime is extended until the :ref:`spmm - descriptor` is released or the workspace is + descriptor` is released or the workspace is reset by ``spmm_optimize``. The workspace cannot be a sub-buffer. | If it is a USM pointer, it must not be free'd until the corresponding ``spmm`` has completed. The data must be accessible on the device. @@ -387,11 +387,11 @@ spmm implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::computation_error` - | :ref:`oneapi::mkl::device_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::uninitialized` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::computation_error` + | :ref:`oneapi::math::device_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::uninitialized` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_spblas` +**Parent topic:** :ref:`onemath_spblas` diff --git a/source/elements/oneMKL/source/domains/spblas/operations/spmv.rst b/source/elements/oneMath/source/domains/spblas/operations/spmv.rst similarity index 68% rename from source/elements/oneMKL/source/domains/spblas/operations/spmv.rst rename to source/elements/oneMath/source/domains/spblas/operations/spmv.rst index cbcc0a0269..2580c6e8b3 100644 --- a/source/elements/oneMKL/source/domains/spblas/operations/spmv.rst +++ b/source/elements/oneMath/source/domains/spblas/operations/spmv.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_spmv_header: +.. _onemath_sparse_spmv_header: spmv ==== @@ -11,7 +11,7 @@ Computes a sparse matrix by dense vector product. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::spmv`` routine computes a sparse matrix by dense +The ``oneapi::math::sparse::spmv`` routine computes a sparse matrix by dense vector product defined as: .. math:: @@ -28,12 +28,12 @@ vector product defined as: .. math:: - \text{op}(A) = \begin{cases} A,& \text{oneapi::mkl::transpose::nontrans}\\ - A^\mathsf{T},& \text{oneapi::mkl::transpose::trans}\\ - A^\mathsf{H},& \text{oneapi::mkl::transpose::conjtrans} + \text{op}(A) = \begin{cases} A,& \text{oneapi::math::transpose::nontrans}\\ + A^\mathsf{T},& \text{oneapi::math::transpose::trans}\\ + A^\mathsf{H},& \text{oneapi::math::transpose::conjtrans} \end{cases} -.. _onemkl_sparse_spmv_descr: +.. _onemath_sparse_spmv_descr: spmv_descr ---------- @@ -42,7 +42,7 @@ spmv_descr .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { struct spmv_descr; using spmv_descr_t = spmv_descr*; @@ -59,7 +59,7 @@ spmv_descr stages of the spmv operation to house relevant state, optimizations and workspaces. -.. _onemkl_sparse_init_spmv_descr: +.. _onemath_sparse_init_spmv_descr: init_spmv_descr --------------- @@ -68,10 +68,10 @@ init_spmv_descr .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { void init_spmv_descr (sycl::queue &queue, - oneapi::mkl::sparse::spmv_descr_t *p_spmv_descr); + oneapi::math::sparse::spmv_descr_t *p_spmv_descr); } @@ -103,12 +103,12 @@ init_spmv_descr implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::host_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::host_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_release_spmv_descr: +.. _onemath_sparse_release_spmv_descr: release_spmv_descr ------------------ @@ -117,10 +117,10 @@ release_spmv_descr .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { sycl::event release_spmv_descr (sycl::queue &queue, - oneapi::mkl::sparse::spmv_descr_t spmv_descr, + oneapi::math::sparse::spmv_descr_t spmv_descr, const std::vector &dependencies = {}); } @@ -155,11 +155,11 @@ release_spmv_descr implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_spmv_alg: +.. _onemath_sparse_spmv_alg: spmv_alg -------- @@ -168,7 +168,7 @@ spmv_alg .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { enum class spmv_alg { default_alg, @@ -193,7 +193,7 @@ spmv_alg implementation-defined and must be documented in the library implementing the oneAPI specification. -.. _onemkl_sparse_spmv: +.. _onemath_sparse_spmv: spmv ---- @@ -202,59 +202,59 @@ spmv .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { void spmv_buffer_size( sycl::queue &queue, - oneapi::mkl::transpose opA, + oneapi::math::transpose opA, const void* alpha, - oneapi::mkl::sparse::matrix_view A_view, - oneapi::mkl::sparse::matrix_handle_t A_handle, - oneapi::mkl::sparse::dense_vector_handle_t x_handle, + oneapi::math::sparse::matrix_view A_view, + oneapi::math::sparse::matrix_handle_t A_handle, + oneapi::math::sparse::dense_vector_handle_t x_handle, const void* beta, - oneapi::mkl::sparse::dense_vector_handle_t y_handle, - oneapi::mkl::sparse::spmv_alg alg, - oneapi::mkl::sparse::spmv_descr_t spmv_descr, + oneapi::math::sparse::dense_vector_handle_t y_handle, + oneapi::math::sparse::spmv_alg alg, + oneapi::math::sparse::spmv_descr_t spmv_descr, std::size_t &temp_buffer_size); void spmv_optimize( sycl::queue &queue, - oneapi::mkl::transpose opA, + oneapi::math::transpose opA, const void* alpha, - oneapi::mkl::sparse::matrix_view A_view, - oneapi::mkl::sparse::matrix_handle_t A_handle, - oneapi::mkl::sparse::dense_vector_handle_t x_handle, + oneapi::math::sparse::matrix_view A_view, + oneapi::math::sparse::matrix_handle_t A_handle, + oneapi::math::sparse::dense_vector_handle_t x_handle, const void* beta, - oneapi::mkl::sparse::dense_vector_handle_t y_handle, - oneapi::mkl::sparse::spmv_alg alg, - oneapi::mkl::sparse::spmv_descr_t spmv_descr, + oneapi::math::sparse::dense_vector_handle_t y_handle, + oneapi::math::sparse::spmv_alg alg, + oneapi::math::sparse::spmv_descr_t spmv_descr, sycl::buffer workspace); sycl::event spmv_optimize( sycl::queue &queue, - oneapi::mkl::transpose opA, + oneapi::math::transpose opA, const void* alpha, - oneapi::mkl::sparse::matrix_view A_view, - oneapi::mkl::sparse::matrix_handle_t A_handle, - oneapi::mkl::sparse::dense_vector_handle_t x_handle, + oneapi::math::sparse::matrix_view A_view, + oneapi::math::sparse::matrix_handle_t A_handle, + oneapi::math::sparse::dense_vector_handle_t x_handle, const void* beta, - oneapi::mkl::sparse::dense_vector_handle_t y_handle, - oneapi::mkl::sparse::spmv_alg alg, - oneapi::mkl::sparse::spmv_descr_t spmv_descr, + oneapi::math::sparse::dense_vector_handle_t y_handle, + oneapi::math::sparse::spmv_alg alg, + oneapi::math::sparse::spmv_descr_t spmv_descr, void* workspace, const std::vector &dependencies = {}); sycl::event spmv( sycl::queue &queue, - oneapi::mkl::transpose opA, + oneapi::math::transpose opA, const void* alpha, - oneapi::mkl::sparse::matrix_view A_view, - oneapi::mkl::sparse::matrix_handle_t A_handle, - oneapi::mkl::sparse::dense_vector_handle_t x_handle, + oneapi::math::sparse::matrix_view A_view, + oneapi::math::sparse::matrix_handle_t A_handle, + oneapi::math::sparse::dense_vector_handle_t x_handle, const void* beta, - oneapi::mkl::sparse::dense_vector_handle_t y_handle, - oneapi::mkl::sparse::spmv_alg alg, - oneapi::mkl::sparse::spmv_descr_t spmv_descr, + oneapi::math::sparse::dense_vector_handle_t y_handle, + oneapi::math::sparse::spmv_alg alg, + oneapi::math::sparse::spmv_descr_t spmv_descr, const std::vector &dependencies = {}); } @@ -269,11 +269,11 @@ spmv some of the descriptor's data such as the ``workspace``. - In the general case, not calling the functions in the order specified above is undefined behavior. Not calling ``spmv_buffer_size`` or - ``spmv_optimize`` at least once with a given descriptor will throw a - :ref:`oneapi::mkl::uninitialized` + ``spmv_optimize`` at least once with a given descriptor will throw an + :ref:`oneapi::math::uninitialized` exception. Calling ``spmv`` with arguments not matching ``spmv_optimize`` will throw a - :ref:`oneapi::mkl::invalid_argument` + :ref:`oneapi::math::invalid_argument` exception, unless stated otherwise. - The data of the dense handles ``x_handle`` and ``y_handle`` and the scalars ``alpha`` and ``beta`` can be reset before each call to ``spmv``. Changing @@ -293,7 +293,7 @@ spmv opA Specifies operation ``op()`` on the input matrix. The possible options are - described in :ref:`onemkl_enum_transpose` enum class. + described in :ref:`onemath_enum_transpose` enum class. alpha Host or USM pointer representing :math:`\alpha`. The USM allocation can be @@ -305,7 +305,7 @@ spmv A_view Specifies which part of the handle should be read as described by - :ref:`onemkl_sparse_matrix_view`. The ``type_view`` field cannot be + :ref:`onemath_sparse_matrix_view`. The ``type_view`` field cannot be ``matrix_descr::diagonal``. The ``diag_view`` field can be ``diag::unit`` if and only if ``type_view`` is ``matrix_descr::triangular``. @@ -327,10 +327,10 @@ spmv Dense vector handle object representing :math:`y`. alg - Specifies the :ref:`spmv algorithm` to use. + Specifies the :ref:`spmv algorithm` to use. spmv_descr - Initialized :ref:`spmv descriptor`. + Initialized :ref:`spmv descriptor`. temp_buffer_size Output buffer size in bytes. @@ -340,7 +340,7 @@ spmv ``temp_buffer_size`` bytes and the address aligned on the size of the handles' data type. | If it is a buffer, its lifetime is extended until the :ref:`spmv - descriptor` is released or the workspace is + descriptor` is released or the workspace is reset by ``spmv_optimize``. The workspace cannot be a sub-buffer. | If it is a USM pointer, it must not be free'd until the corresponding ``spmv`` has completed. The data must be accessible on the device. @@ -377,11 +377,11 @@ spmv implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::computation_error` - | :ref:`oneapi::mkl::device_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::uninitialized` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::computation_error` + | :ref:`oneapi::math::device_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::uninitialized` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_spblas` +**Parent topic:** :ref:`onemath_spblas` diff --git a/source/elements/oneMKL/source/domains/spblas/operations/spsv.rst b/source/elements/oneMath/source/domains/spblas/operations/spsv.rst similarity index 66% rename from source/elements/oneMKL/source/domains/spblas/operations/spsv.rst rename to source/elements/oneMath/source/domains/spblas/operations/spsv.rst index 146088b633..4d1d743fbe 100644 --- a/source/elements/oneMKL/source/domains/spblas/operations/spsv.rst +++ b/source/elements/oneMath/source/domains/spblas/operations/spsv.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_spsv_header: +.. _onemath_sparse_spsv_header: spsv ==== @@ -12,7 +12,7 @@ triangular sparse matrix. .. rubric:: Description and Assumptions -The ``oneapi::mkl::sparse::spsv`` routine solves a system of linear equations +The ``oneapi::math::sparse::spsv`` routine solves a system of linear equations for a square matrix: .. math:: @@ -28,12 +28,12 @@ for a square matrix: .. math:: - \text{op}(A) = \begin{cases} A,& \text{oneapi::mkl::transpose::nontrans}\\ - A^\mathsf{T},& \text{oneapi::mkl::transpose::trans}\\ - A^\mathsf{H},& \text{oneapi::mkl::transpose::conjtrans} + \text{op}(A) = \begin{cases} A,& \text{oneapi::math::transpose::nontrans}\\ + A^\mathsf{T},& \text{oneapi::math::transpose::trans}\\ + A^\mathsf{H},& \text{oneapi::math::transpose::conjtrans} \end{cases} -.. _onemkl_sparse_spsv_descr: +.. _onemath_sparse_spsv_descr: spsv_descr ---------- @@ -42,7 +42,7 @@ spsv_descr .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { struct spsv_descr; using spsv_descr_t = spsv_descr*; @@ -59,7 +59,7 @@ spsv_descr stages of the spsv operation to house relevant state, optimizations and workspaces. -.. _onemkl_sparse_init_spsv_descr: +.. _onemath_sparse_init_spsv_descr: init_spsv_descr --------------- @@ -68,10 +68,10 @@ init_spsv_descr .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { void init_spsv_descr (sycl::queue &queue, - oneapi::mkl::sparse::spsv_descr_t *p_spsv_descr); + oneapi::math::sparse::spsv_descr_t *p_spsv_descr); } @@ -103,12 +103,12 @@ init_spsv_descr implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::host_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::host_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_release_spsv_descr: +.. _onemath_sparse_release_spsv_descr: release_spsv_descr ------------------ @@ -117,10 +117,10 @@ release_spsv_descr .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { sycl::event release_spsv_descr (sycl::queue &queue, - oneapi::mkl::sparse::spsv_descr_t spsv_descr, + oneapi::math::sparse::spsv_descr_t spsv_descr, const std::vector &dependencies = {}); } @@ -155,11 +155,11 @@ release_spsv_descr implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::unsupported_device` -.. _onemkl_sparse_spsv_alg: +.. _onemath_sparse_spsv_alg: spsv_alg -------- @@ -168,7 +168,7 @@ spsv_alg .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { enum class spsv_alg { default_alg, @@ -188,7 +188,7 @@ spsv_alg implementation-defined and must be documented in the library implementing the oneAPI specification. -.. _onemkl_sparse_spsv: +.. _onemath_sparse_spsv: spsv ---- @@ -197,55 +197,55 @@ spsv .. code-block:: cpp - namespace oneapi::mkl::sparse { + namespace oneapi::math::sparse { void spsv_buffer_size( sycl::queue &queue, - oneapi::mkl::transpose opA, + oneapi::math::transpose opA, const void* alpha, - oneapi::mkl::sparse::matrix_view A_view, - oneapi::mkl::sparse::matrix_handle_t A_handle, - oneapi::mkl::sparse::dense_vector_handle_t x_handle, - oneapi::mkl::sparse::dense_vector_handle_t y_handle, - oneapi::mkl::sparse::spsv_alg alg, - oneapi::mkl::sparse::spsv_descr_t spsv_descr, + oneapi::math::sparse::matrix_view A_view, + oneapi::math::sparse::matrix_handle_t A_handle, + oneapi::math::sparse::dense_vector_handle_t x_handle, + oneapi::math::sparse::dense_vector_handle_t y_handle, + oneapi::math::sparse::spsv_alg alg, + oneapi::math::sparse::spsv_descr_t spsv_descr, std::size_t &temp_buffer_size); void spsv_optimize( sycl::queue &queue, - oneapi::mkl::transpose opA, + oneapi::math::transpose opA, const void* alpha, - oneapi::mkl::sparse::matrix_view A_view, - oneapi::mkl::sparse::matrix_handle_t A_handle, - oneapi::mkl::sparse::dense_vector_handle_t x_handle, - oneapi::mkl::sparse::dense_vector_handle_t y_handle, - oneapi::mkl::sparse::spsv_alg alg, - oneapi::mkl::sparse::spsv_descr_t spsv_descr, + oneapi::math::sparse::matrix_view A_view, + oneapi::math::sparse::matrix_handle_t A_handle, + oneapi::math::sparse::dense_vector_handle_t x_handle, + oneapi::math::sparse::dense_vector_handle_t y_handle, + oneapi::math::sparse::spsv_alg alg, + oneapi::math::sparse::spsv_descr_t spsv_descr, sycl::buffer workspace); sycl::event spsv_optimize( sycl::queue &queue, - oneapi::mkl::transpose opA, + oneapi::math::transpose opA, const void* alpha, - oneapi::mkl::sparse::matrix_view A_view, - oneapi::mkl::sparse::matrix_handle_t A_handle, - oneapi::mkl::sparse::dense_vector_handle_t x_handle, - oneapi::mkl::sparse::dense_vector_handle_t y_handle, - oneapi::mkl::sparse::spsv_alg alg, - oneapi::mkl::sparse::spsv_descr_t spsv_descr, + oneapi::math::sparse::matrix_view A_view, + oneapi::math::sparse::matrix_handle_t A_handle, + oneapi::math::sparse::dense_vector_handle_t x_handle, + oneapi::math::sparse::dense_vector_handle_t y_handle, + oneapi::math::sparse::spsv_alg alg, + oneapi::math::sparse::spsv_descr_t spsv_descr, void* workspace, const std::vector &dependencies = {}); sycl::event spsv( sycl::queue &queue, - oneapi::mkl::transpose opA, + oneapi::math::transpose opA, const void* alpha, - oneapi::mkl::sparse::matrix_view A_view, - oneapi::mkl::sparse::matrix_handle_t A_handle, - oneapi::mkl::sparse::dense_vector_handle_t x_handle, - oneapi::mkl::sparse::dense_vector_handle_t y_handle, - oneapi::mkl::sparse::spsv_alg alg, - oneapi::mkl::sparse::spsv_descr_t spsv_descr, + oneapi::math::sparse::matrix_view A_view, + oneapi::math::sparse::matrix_handle_t A_handle, + oneapi::math::sparse::dense_vector_handle_t x_handle, + oneapi::math::sparse::dense_vector_handle_t y_handle, + oneapi::math::sparse::spsv_alg alg, + oneapi::math::sparse::spsv_descr_t spsv_descr, const std::vector &dependencies = {}); } @@ -261,10 +261,10 @@ spsv - In the general case, not calling the functions in the order specified above is undefined behavior. Not calling ``spsv_buffer_size`` or ``spsv_optimize`` at least once with a given descriptor will throw a - :ref:`oneapi::mkl::uninitialized` + :ref:`oneapi::math::uninitialized` exception. Calling ``spsv`` with arguments not matching ``spsv_optimize`` - will throw a - :ref:`oneapi::mkl::invalid_argument` + will throw an + :ref:`oneapi::math::invalid_argument` exception, unless stated otherwise. - The data of the dense handle ``x_handle`` and scalar ``alpha`` can be reset before each call to ``spsv``. Changing the data of the sparse handle @@ -284,7 +284,7 @@ spsv opA Specifies operation ``op()`` on the input matrix. The possible options are - described in :ref:`onemkl_enum_transpose` enum class. + described in :ref:`onemath_enum_transpose` enum class. alpha Host or USM pointer representing :math:`\alpha`. The USM allocation can be @@ -293,7 +293,7 @@ spsv A_view Specifies which part of the handle should be read as described by - :ref:`onemkl_sparse_matrix_view`. The ``type_view`` field must be + :ref:`onemath_sparse_matrix_view`. The ``type_view`` field must be ``matrix_descr::triangular``. The ``diag_view`` field can be ``diag::nonunit`` or ``diag::unit``. @@ -307,10 +307,10 @@ spsv Dense vector handle object representing :math:`y`. alg - Specifies the :ref:`spsv algorithm` to use. + Specifies the :ref:`spsv algorithm` to use. spsv_descr - Initialized :ref:`spsv descriptor`. + Initialized :ref:`spsv descriptor`. temp_buffer_size Output buffer size in bytes. @@ -320,7 +320,7 @@ spsv ``temp_buffer_size`` bytes and the address aligned on the size of the handles' data type. | If it is a buffer, its lifetime is extended until the :ref:`spsv - descriptor` is released or the workspace is + descriptor` is released or the workspace is reset by ``spsv_optimize``. The workspace cannot be a sub-buffer. | If it is a USM pointer, it must not be free'd until the corresponding ``spsv`` has completed. The data must be accessible on the device. @@ -357,11 +357,11 @@ spsv implementation-specific exception(s) in case of error conditions not covered here. - | :ref:`oneapi::mkl::computation_error` - | :ref:`oneapi::mkl::device_bad_alloc` - | :ref:`oneapi::mkl::invalid_argument` - | :ref:`oneapi::mkl::unimplemented` - | :ref:`oneapi::mkl::uninitialized` - | :ref:`oneapi::mkl::unsupported_device` + | :ref:`oneapi::math::computation_error` + | :ref:`oneapi::math::device_bad_alloc` + | :ref:`oneapi::math::invalid_argument` + | :ref:`oneapi::math::unimplemented` + | :ref:`oneapi::math::uninitialized` + | :ref:`oneapi::math::unsupported_device` -**Parent topic:** :ref:`onemkl_spblas` +**Parent topic:** :ref:`onemath_spblas` diff --git a/source/elements/oneMKL/source/domains/spblas/spblas.rst b/source/elements/oneMath/source/domains/spblas/spblas.rst similarity index 73% rename from source/elements/oneMKL/source/domains/spblas/spblas.rst rename to source/elements/oneMath/source/domains/spblas/spblas.rst index eef2b3fb49..a5093af8ab 100644 --- a/source/elements/oneMKL/source/domains/spblas/spblas.rst +++ b/source/elements/oneMath/source/domains/spblas/spblas.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_spblas: +.. _onemath_spblas: Sparse BLAS =========== @@ -18,13 +18,13 @@ Sparse BLAS * - Routines and Objects - Description - * - :ref:`onemkl_sparse_data_handles` + * - :ref:`onemath_sparse_data_handles` - Matrix and vector handle types - * - :ref:`onemkl_sparse_spmm_header` + * - :ref:`onemath_sparse_spmm_header` - Compute the product of a sparse matrix with a dense matrix - * - :ref:`onemkl_sparse_spmv_header` + * - :ref:`onemath_sparse_spmv_header` - Compute the product of a sparse matrix with a dense vector - * - :ref:`onemkl_sparse_spsv_header` + * - :ref:`onemath_sparse_spsv_header` - Solve a triangular sparse linear system .. toctree:: @@ -37,4 +37,4 @@ Sparse BLAS matrix_view supported-types -**Parent topic:** :ref:`onemkl_sparse_linear_algebra` +**Parent topic:** :ref:`onemath_sparse_linear_algebra` diff --git a/source/elements/oneMKL/source/domains/spblas/supported-types.rst b/source/elements/oneMath/source/domains/spblas/supported-types.rst similarity index 74% rename from source/elements/oneMKL/source/domains/spblas/supported-types.rst rename to source/elements/oneMath/source/domains/spblas/supported-types.rst index 858f1a6999..0268d65d99 100644 --- a/source/elements/oneMKL/source/domains/spblas/supported-types.rst +++ b/source/elements/oneMath/source/domains/spblas/supported-types.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_sparse_supported_types: +.. _onemath_sparse_supported_types: Supported template types ======================== @@ -24,11 +24,11 @@ Supported template types -   ``dataType`` is used to describe the precision (i.e. number of bits) and domain -(i.e. real or complex) of the :ref:`data handles ` +(i.e. real or complex) of the :ref:`data handles ` and the operations using them. ``indexType`` is used to describe the range of integer types such as indices, -offsets or sizes of the :ref:`data handles ` and the +offsets or sizes of the :ref:`data handles ` and the operations using them. -**Parent topic:** :ref:`onemkl_spblas` +**Parent topic:** :ref:`onemath_spblas` diff --git a/source/elements/oneMath/source/domains/stats.inc.rst b/source/elements/oneMath/source/domains/stats.inc.rst new file mode 100755 index 0000000000..cd23bd2a75 --- /dev/null +++ b/source/elements/oneMath/source/domains/stats.inc.rst @@ -0,0 +1,15 @@ +.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation +.. +.. SPDX-License-Identifier: CC-BY-4.0 + +.. _onemath_stats: + +Summary Statistics +------------------- + +The oneMath provides a set of :ref:`Summary Statistics routines ` that compute basic statistical estimates for single and double precision multi-dimensional datasets. + +.. toctree:: + :hidden: + + stats/onemath_stats_overview.rst \ No newline at end of file diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_central_moment.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_central_moment.rst similarity index 79% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_central_moment.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_central_moment.rst index e4f6efae5a..4a88ec7c2c 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_central_moment.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_central_moment.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_central_moment: +.. _onemath_stats_central_moment: central_moment ============== Entry point to compute central moments up to the 4th order. -.. _onemkl_stats_central_moment_description: +.. _onemath_stats_central_moment_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::central_moment function is used to compute an array of central moments up to the 4th order (central moments for each dataset's dimension). +The oneapi::math::stats::central_moment function is used to compute an array of central moments up to the 4th order (central moments for each dataset's dimension). -:ref:`onemkl_stats_central_moment` supports the following precisions for data: +:ref:`onemath_stats_central_moment` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::central_moment function is used to compute an array of c * - ``double`` -.. _onemkl_stats_central_moment_buffer: +.. _onemath_stats_central_moment_buffer: central_moment (buffer version) ------------------------------- @@ -34,8 +34,8 @@ central_moment (buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { - template void central_moment(sycl::queue& queue, const dataset>& data, @@ -51,14 +51,14 @@ central_moment (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -87,10 +87,10 @@ central_moment (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when central_moment_2.get_count() == 0 & central_moment_3.get_count() == 0 & central_moment_4.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_central_moment_usm: +.. _onemath_stats_central_moment_usm: central_moment (USM version) ---------------------------- @@ -100,7 +100,7 @@ central_moment (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event central_moment(sycl::queue& queue, const dataset& data, Type* central_moment_2, @@ -115,14 +115,14 @@ central_moment (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -155,7 +155,7 @@ central_moment (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when central_moment_2 == nullptr & central_moment_3 == nullptr & central_moment_4 == nullptr, or dataset object is invalid .. container:: section @@ -166,5 +166,5 @@ central_moment (USM version) -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_central_moment_user_mean.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_central_moment_user_mean.rst similarity index 82% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_central_moment_user_mean.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_central_moment_user_mean.rst index 02e6c11159..7288feda4a 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_central_moment_user_mean.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_central_moment_user_mean.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_central_moment_user_mean: +.. _onemath_stats_central_moment_user_mean: central_moment with provided mean ================================= Entry point to compute central moments up to the 4th order with the provided mean values. -.. _onemkl_stats_central_moment_user_mean_description: +.. _onemath_stats_central_moment_user_mean_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::central_moment function is used to compute an array of central moments up to the 4th order (central moments for each dataset's dimension) with the provided mean values. +The oneapi::math::stats::central_moment function is used to compute an array of central moments up to the 4th order (central moments for each dataset's dimension) with the provided mean values. -:ref:`onemkl_stats_central_moment_user_mean` supports the following precisions for data: +:ref:`onemath_stats_central_moment_user_mean` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::central_moment function is used to compute an array of c * - ``double`` -.. _onemkl_stats_central_moment_user_mean_buffer: +.. _onemath_stats_central_moment_user_mean_buffer: central_moment with provided mean (buffer version) -------------------------------------------------- @@ -34,7 +34,7 @@ central_moment with provided mean (buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void central_moment(sycl::queue& queue, sycl::buffer mean, @@ -51,13 +51,13 @@ central_moment with provided mean (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -89,11 +89,11 @@ central_moment with provided mean (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when central_moment_2.get_count() == 0 & central_moment_3.get_count() == 0 & central_moment_4.get_count() == 0, or mean.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_central_moment_user_mean_usm: +.. _onemath_stats_central_moment_user_mean_usm: central_moment with provided mean (USM version) ----------------------------------------------- @@ -102,7 +102,7 @@ central_moment with provided mean (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event central_moment(sycl::queue& queue, Type* mean, @@ -120,13 +120,13 @@ central_moment with provided mean (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -161,7 +161,7 @@ central_moment with provided mean (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when central_moment_2 == nullptr & central_moment_3 == nullptr & central_moment_4 == nullptr or mean == nullptr, or dataset object is invalid .. container:: section @@ -171,5 +171,5 @@ central_moment with provided mean (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_central_sum.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_central_sum.rst similarity index 81% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_central_sum.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_central_sum.rst index 7f6f70adc4..ccce90f454 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_central_sum.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_central_sum.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_central_sum: +.. _onemath_stats_central_sum: central_sum =========== Entry point to compute central sums up to the 4th order. -.. _onemkl_stats_central_sum_description: +.. _onemath_stats_central_sum_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::central_sum function is used to compute an array of central sums up to the 4th order (central sums for each dataset's dimension). +The oneapi::math::stats::central_sum function is used to compute an array of central sums up to the 4th order (central sums for each dataset's dimension). -:ref:`onemkl_stats_central_sum` supports the following precisions for data: +:ref:`onemath_stats_central_sum` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::central_sum function is used to compute an array of cent * - ``double`` -.. _onemkl_stats_central_sum_buffer: +.. _onemath_stats_central_sum_buffer: central_sum (Buffer version) ---------------------------- @@ -34,7 +34,7 @@ central_sum (Buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void central_sum(sycl::queue& queue, const dataset>& data, @@ -50,14 +50,14 @@ central_sum (Buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -86,10 +86,10 @@ central_sum (Buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when central_sum_2.get_count() == 0 & central_sum_3.get_count() == 0 & central_sum_4.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_central_sum_usm: +.. _onemath_stats_central_sum_usm: central_sum (USM version) ------------------------- @@ -98,7 +98,7 @@ central_sum (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event central_sum( sycl::queue& queue, @@ -116,14 +116,14 @@ central_sum (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -155,7 +155,7 @@ central_sum (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when central_sum_2 == nullptr & central_sum_3 == nullptr & central_sum_4 == nullptr, or dataset object is invalid .. container:: section @@ -165,5 +165,5 @@ central_sum (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_central_sum_user_mean.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_central_sum_user_mean.rst similarity index 83% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_central_sum_user_mean.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_central_sum_user_mean.rst index cf36eda7e8..14b67f9af4 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_central_sum_user_mean.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_central_sum_user_mean.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_central_sum_user_mean: +.. _onemath_stats_central_sum_user_mean: central_sum with provided mean ============================== Entry point to compute central sums up to the 4th order with the provided mean values. -.. _onemkl_stats_central_sum_user_mean_description: +.. _onemath_stats_central_sum_user_mean_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::central_sum function is used to compute an array of central sums up to the 4th order (central sums for each dataset's dimension) with the provided mean values. +The oneapi::math::stats::central_sum function is used to compute an array of central sums up to the 4th order (central sums for each dataset's dimension) with the provided mean values. -:ref:`onemkl_stats_central_sum_user_mean` supports the following precisions for data: +:ref:`onemath_stats_central_sum_user_mean` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::central_sum function is used to compute an array of cent * - ``double`` -.. _onemkl_stats_central_sum_user_mean_buffer: +.. _onemath_stats_central_sum_user_mean_buffer: central_sum with provided mean (buffer version) ----------------------------------------------- @@ -34,7 +34,7 @@ central_sum with provided mean (buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void central_sum(sycl::queue& queue, sycl::buffer mean, @@ -51,13 +51,13 @@ central_sum with provided mean (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -89,10 +89,10 @@ central_sum with provided mean (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when central_sum_2.get_count() == 0 & central_sum_3.get_count() == 0 & central_sum_4.get_count() == 0, or mean.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_central_sum_user_mean_usm: +.. _onemath_stats_central_sum_user_mean_usm: central_sum with provided mean (USM version) --------------------------------------------- @@ -101,7 +101,7 @@ central_sum with provided mean (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event central_sum(sycl::queue& queue, Type* mean, @@ -119,13 +119,13 @@ central_sum with provided mean (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -160,7 +160,7 @@ central_sum with provided mean (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when central_sum_2 == nullptr & central_sum_3 == nullptr & central_sum_4 == nullptr, or mean == nullptr, or dataset object is invalid .. container:: section @@ -170,5 +170,5 @@ central_sum with provided mean (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_dataset.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_dataset.rst similarity index 85% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_dataset.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_dataset.rst index 56b2353935..bba3d9d32d 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_dataset.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_dataset.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_dataset: +.. _onemath_stats_dataset: dataset ======= The structure consolidates the information of a multi-dimensional dataset. -.. _onemkl_stats_dataset_description: +.. _onemath_stats_dataset_description: .. rubric:: Description -The ``dataset`` struct object is used in :ref:`onemkl_stats_routines` as a multi-dimensional data storage. ``dataset`` struct contains information about observations matrix and its size (dimensions x observations), observations weights and indices for dimensions (defines dimensions to be processed). +The ``dataset`` struct object is used in :ref:`onemath_stats_routines` as a multi-dimensional data storage. ``dataset`` struct contains information about observations matrix and its size (dimensions x observations), observations weights and indices for dimensions (defines dimensions to be processed). -.. _onemkl_stats_dataset_syntax_buffer: +.. _onemath_stats_dataset_syntax_buffer: structure dataset (Buffer version) ---------------------------------- @@ -24,7 +24,7 @@ structure dataset (Buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template struct dataset> { @@ -56,11 +56,11 @@ structure dataset (Buffer version) .. container:: section - oneapi::mkl::stats::layout ObservationsLayout + oneapi::math::stats::layout ObservationsLayout Type of the multi-dimensional data layout. Supported types: - * ``oneapi::mkl::stats::layout::row_major`` - * ``oneapi::mkl::stats::layout::col_major`` + * ``oneapi::math::stats::layout::row_major`` + * ``oneapi::math::stats::layout::col_major`` .. container:: section @@ -106,10 +106,10 @@ structure dataset (Buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when `n_dims_` :math:`\leq 0`, or `n_observations_` :math:`\leq 0`, or `observations_.get_count() == 0` -.. _onemkl_stats_dataset_syntax_usm: +.. _onemath_stats_dataset_syntax_usm: structure dataset (USM version) ------------------------------- @@ -118,7 +118,7 @@ structure dataset (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template struct dataset { explicit dataset(std::int64_t n_dims_, std::int64_t n_observations_, Type* observations_, @@ -148,11 +148,11 @@ structure dataset (USM version) .. container:: section - oneapi::mkl::stats::layout ObservationsLayout + oneapi::math::stats::layout ObservationsLayout Type of the multi-dimensional data layout. Supported types: - * ``oneapi::mkl::stats::layout::row_major`` - * ``oneapi::mkl::stats::layout::col_major`` + * ``oneapi::math::stats::layout::row_major`` + * ``oneapi::math::stats::layout::col_major`` .. container:: section @@ -198,8 +198,8 @@ structure dataset (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when `n_dims_` :math:`\leq 0`, or `n_observations_` :math:`\leq 0`, or `observations_ == nullptr` -**Parent topic:** :ref:`onemkl_stats` +**Parent topic:** :ref:`onemath_stats` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_kurtosis.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_kurtosis.rst similarity index 77% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_kurtosis.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_kurtosis.rst index 1c5e65b747..3551c3c678 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_kurtosis.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_kurtosis.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_kurtosis: +.. _onemath_stats_kurtosis: kurtosis ======== Entry point to compute kurtosis. -.. _onemkl_stats_kurtosis_description: +.. _onemath_stats_kurtosis_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::kurtosis function is used to compute a kurtosis array (kurtosis for each dataset's dimension). +The oneapi::math::stats::kurtosis function is used to compute a kurtosis array (kurtosis for each dataset's dimension). -:ref:`onemkl_stats_kurtosis` supports the following precisions for data: +:ref:`onemath_stats_kurtosis` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::kurtosis function is used to compute a kurtosis array (k * - ``double`` -.. _onemkl_stats_kurtosis_buffer: +.. _onemath_stats_kurtosis_buffer: kurtosis (buffer version) ------------------------- @@ -34,7 +34,7 @@ kurtosis (buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void kurtosis(sycl::queue& queue, const dataset>& data, @@ -48,14 +48,14 @@ kurtosis (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -78,10 +78,10 @@ kurtosis (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when kurtosis.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_kurtosis_usm: +.. _onemath_stats_kurtosis_usm: kurtosis (USM version) ---------------------- @@ -90,7 +90,7 @@ kurtosis (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event kurtosis(sycl::queue& queue, const dataset& data, @@ -105,14 +105,14 @@ kurtosis (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -138,7 +138,7 @@ kurtosis (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when kurtosis == nullptr, or dataset object is invalid .. container:: section @@ -148,5 +148,5 @@ kurtosis (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_kurtosis_user_mean.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_kurtosis_user_mean.rst similarity index 76% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_kurtosis_user_mean.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_kurtosis_user_mean.rst index e09193e156..6d70aeb6b1 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_kurtosis_user_mean.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_kurtosis_user_mean.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_kurtosis_user_mean: +.. _onemath_stats_kurtosis_user_mean: kurtosis with provided mean =========================== Entry point to compute kurtosis with the provided mean values. -.. _onemkl_stats_kurtosis_user_mean_description: +.. _onemath_stats_kurtosis_user_mean_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::kurtosis function is used to compute an array of kurtosis (kurtosis for each dataset's dimension) with the provided mean values. +The oneapi::math::stats::kurtosis function is used to compute an array of kurtosis (kurtosis for each dataset's dimension) with the provided mean values. -:ref:`onemkl_stats_kurtosis_user_mean` supports the following precisions for data: +:ref:`onemath_stats_kurtosis_user_mean` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::kurtosis function is used to compute an array of kurtosi * - ``double`` -.. _onemkl_stats_kurtosis_user_mean_buffer: +.. _onemath_stats_kurtosis_user_mean_buffer: kurtosis with provided mean (buffer version) -------------------------------------------- @@ -34,12 +34,12 @@ kurtosis with provided mean (buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template - void oneapi::mkl::stats::kurtosis(sycl::queue& queue, + void oneapi::math::stats::kurtosis(sycl::queue& queue, sycl::buffer mean, - const oneapi::mkl::stats::dataset, ObservationsLayout>& data, + const oneapi::math::stats::dataset, ObservationsLayout>& data, sycl::buffer kurtosis); } @@ -50,13 +50,13 @@ kurtosis with provided mean (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -82,10 +82,10 @@ kurtosis with provided mean (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when kurtosis.get_count() == 0, or mean.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_kurtosis_user_mean_usm: +.. _onemath_stats_kurtosis_user_mean_usm: kurtosis with provided mean (USM version) ----------------------------------------- @@ -94,7 +94,7 @@ kurtosis with provided mean (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event kurtosis(sycl::queue& queue, Type* mean, @@ -110,13 +110,13 @@ kurtosis with provided mean (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -145,7 +145,7 @@ kurtosis with provided mean (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when kurtosis == nullptr, or mean == nullptr, or dataset object is invalid .. container:: section @@ -155,5 +155,5 @@ kurtosis with provided mean (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_make_dataset.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_make_dataset.rst similarity index 83% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_make_dataset.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_make_dataset.rst index bb6ff601a8..0c42d69ed4 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_make_dataset.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_make_dataset.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_make_dataset: +.. _onemath_stats_make_dataset: make_dataset ============ Entry point to create a dataset from the provided parameters. -.. _onemkl_stats_make_dataset_description: +.. _onemath_stats_make_dataset_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::make_dataset function is used to create a dataset from the provided storage of the observations matrix, the number of dimensions and observations, and other parameters. +The oneapi::math::stats::make_dataset function is used to create a dataset from the provided storage of the observations matrix, the number of dimensions and observations, and other parameters. -:ref:`onemkl_stats_make_dataset` supports the following precisions for data: +:ref:`onemath_stats_make_dataset` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::make_dataset function is used to create a dataset from t * - ``double`` -.. _onemkl_stats_make_dataset_buffer: +.. _onemath_stats_make_dataset_buffer: make_dataset (buffer version) ----------------------------- @@ -34,7 +34,7 @@ make_dataset (buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template dataset, ObservationsLayout> make_dataset( std::int64_t n_dims, @@ -49,7 +49,7 @@ make_dataset (buffer version) .. rubric:: Template Parameters ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. Type Data precision. @@ -77,7 +77,7 @@ make_dataset (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math: `n_dims \leq 0`, or :math: `n_observations \leq 0`, or observations.get_count() == 0 .. container:: section @@ -87,7 +87,7 @@ make_dataset (buffer version) Dataset holding specified parameters. -.. _onemkl_stats_make_dataset_usm: +.. _onemath_stats_make_dataset_usm: make_dataset (USM version) -------------------------- @@ -96,7 +96,7 @@ make_dataset (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template dataset make_dataset(std::nt64_t n_dims, std::int64_t n_observations, @@ -108,7 +108,7 @@ make_dataset (USM version) .. rubric:: Template Parameters ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. Type Data precision. @@ -136,7 +136,7 @@ make_dataset (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when :math:`n\_dims \leq 0`, or :math:`n\_observations \leq 0`, or observations == nullptr .. container:: section @@ -146,4 +146,4 @@ make_dataset (USM version) Dataset holding specified parameters. -**Parent topic:** :ref:`onemkl_stats_service_routines` +**Parent topic:** :ref:`onemath_stats_service_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_max.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_max.rst similarity index 80% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_max.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_max.rst index 52feb64ae6..48e3e88e66 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_max.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_max.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_max: +.. _onemath_stats_max: max === Entry point to compute max values. -.. _onemkl_stats_max_description: +.. _onemath_stats_max_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::max function is used to compute a max values arrays (max value for each dataset's dimension). +The oneapi::math::stats::max function is used to compute a max values arrays (max value for each dataset's dimension). -:ref:`onemkl_stats_max` supports the following precisions for data: +:ref:`onemath_stats_max` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::max function is used to compute a max values arrays (max * - ``double`` -.. _onemkl_stats_max_buffer: +.. _onemath_stats_max_buffer: max (buffer version) -------------------- @@ -34,7 +34,7 @@ max (buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void max(sycl::queue& queue, const dataset>& data, @@ -48,13 +48,13 @@ max (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -77,10 +77,10 @@ max (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when max.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_max_usm: +.. _onemath_stats_max_usm: max (USM version) ----------------- @@ -89,7 +89,7 @@ max (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event max(sycl::queue& queue, const dataset& data, @@ -104,13 +104,13 @@ max (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -136,7 +136,7 @@ max (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when max == nullptr, or dataset object is invalid .. container:: section @@ -146,5 +146,5 @@ max (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_mean.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_mean.rst similarity index 77% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_mean.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_mean.rst index cd2982e00b..993f06175d 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_mean.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_mean.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_mean: +.. _onemath_stats_mean: mean ==== Entry point to compute mean values. -.. _onemkl_stats_mean_description: +.. _onemath_stats_mean_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::mean function is used to compute a mean array (mean value for each dataset's dimension). +The oneapi::math::stats::mean function is used to compute a mean array (mean value for each dataset's dimension). -:ref:`onemkl_stats_mean` supports the following precisions for data: +:ref:`onemath_stats_mean` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::mean function is used to compute a mean array (mean valu * - ``double`` -.. _onemkl_stats_mean_buffer: +.. _onemath_stats_mean_buffer: mean (buffer version) --------------------- @@ -34,7 +34,7 @@ mean (buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void mean(sycl::queue& queue, const dataset>& data, @@ -48,14 +48,14 @@ mean (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -78,10 +78,10 @@ mean (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when mean.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_mean_usm: +.. _onemath_stats_mean_usm: mean (USM version) ------------------ @@ -90,7 +90,7 @@ mean (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event mean(sycl::queue& queue, const dataset& data, @@ -105,14 +105,14 @@ mean (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -138,7 +138,7 @@ mean (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when mean == nullptr, or dataset object is invalid .. container:: section @@ -148,5 +148,5 @@ mean (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_min.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_min.rst similarity index 80% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_min.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_min.rst index cdf0c95409..93c90d4ce8 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_min.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_min.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_min: +.. _onemath_stats_min: min === Entry point to compute min values. -.. _onemkl_stats_min_description: +.. _onemath_stats_min_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::min function is used to compute min arrays (min value for each dataset's dimension). +The oneapi::math::stats::min function is used to compute min arrays (min value for each dataset's dimension). -:ref:`onemkl_stats_min` supports the following precisions for data: +:ref:`onemath_stats_min` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::min function is used to compute min arrays (min value fo * - ``double`` -.. _onemkl_stats_min_buffer: +.. _onemath_stats_min_buffer: min (buffer version) -------------------- @@ -34,7 +34,7 @@ min (buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void min(sycl::queue& queue, const dataset>& data, @@ -48,13 +48,13 @@ min (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -77,10 +77,10 @@ min (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when min.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_min_usm: +.. _onemath_stats_min_usm: min (USM version) ----------------- @@ -89,7 +89,7 @@ min (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event min(sycl::queue& queue, const dataset& data, @@ -104,13 +104,13 @@ min (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -136,7 +136,7 @@ min (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when min == nullptr, or dataset object is invalid .. container:: section @@ -146,5 +146,5 @@ min (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_min_max.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_min_max.rst similarity index 80% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_min_max.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_min_max.rst index a8bb27cce7..23440e16db 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_min_max.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_min_max.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_min_max: +.. _onemath_stats_min_max: min_max ======= Entry point to compute min and max values. -.. _onemkl_stats_min_max_description: +.. _onemath_stats_min_max_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::min_max function is used to compute min and max arrays (min and max values for each dataset's dimension). +The oneapi::math::stats::min_max function is used to compute min and max arrays (min and max values for each dataset's dimension). -:ref:`onemkl_stats_min_max` supports the following precisions for data: +:ref:`onemath_stats_min_max` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::min_max function is used to compute min and max arrays ( * - ``double`` -.. _onemkl_stats_min_max_buffer: +.. _onemath_stats_min_max_buffer: min_max (buffer version) ------------------------ @@ -34,7 +34,7 @@ min_max (buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void min_max(sycl::queue& queue, const dataset>& data, @@ -49,13 +49,13 @@ min_max (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -81,10 +81,10 @@ min_max (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when min.get_count() == 0, or max.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_min_max_usm: +.. _onemath_stats_min_max_usm: min_max (USM version) --------------------- @@ -93,7 +93,7 @@ min_max (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event min_max(sycl::queue& queue, const dataset& data, @@ -109,13 +109,13 @@ min_max (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -144,7 +144,7 @@ min_max (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when min == nullptr, or max == nullptr, or dataset object is invalid .. container:: section @@ -154,5 +154,5 @@ min_max (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_overview.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_overview.rst similarity index 65% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_overview.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_overview.rst index 00af7efe12..19cc45c933 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_overview.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_overview.rst @@ -2,31 +2,31 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_overview: +.. _onemath_stats_overview: Summary Statistics ================== .. rubric:: Definitions -The oneMKL Summary Statistics domains consists of: +The oneMath Summary Statistics domains consists of: - * Dataset structure. The structure consolidates the information of a multi-dimensional dataset (see detailed description in :ref:`onemkl_stats_dataset`). - * Computation routines. The routines are represented as free functions (see detailed description for each routine in :ref:`onemkl_stats_routines`): + * Dataset structure. The structure consolidates the information of a multi-dimensional dataset (see detailed description in :ref:`onemath_stats_dataset`). + * Computation routines. The routines are represented as free functions (see detailed description for each routine in :ref:`onemath_stats_routines`): * Raw and central sums / moments up to the fourth order * Variation coefficient * Skewness and excess kurtosis (further referred as kurtosis) * Minimum and maximum -Refer to :ref:`onemkl_stats_usage_model`. +Refer to :ref:`onemath_stats_usage_model`. .. toctree:: :hidden: - onemkl_stats_usage_model.rst - onemkl_stats_dataset.rst - onemkl_stats_routines.rst - onemkl_stats_service_routines.rst + onemath_stats_usage_model.rst + onemath_stats_dataset.rst + onemath_stats_routines.rst + onemath_stats_service_routines.rst -**Parent topic:** :ref:`onemkl_stats` \ No newline at end of file +**Parent topic:** :ref:`onemath_stats` \ No newline at end of file diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_raw_moment.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_raw_moment.rst similarity index 80% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_raw_moment.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_raw_moment.rst index 7220e00e29..3414fbbdad 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_raw_moment.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_raw_moment.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_raw_moment: +.. _onemath_stats_raw_moment: raw_moment ========== Entry point to compute raw moments up to the 4th order. -.. _onemkl_stats_raw_moment_description: +.. _onemath_stats_raw_moment_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::raw_moment function is used to compute array of raw moments up to the 4th order (raw moments for each dataset's dimension). +The oneapi::math::stats::raw_moment function is used to compute array of raw moments up to the 4th order (raw moments for each dataset's dimension). -:ref:`onemkl_stats_raw_moment` supports the following precisions for data: +:ref:`onemath_stats_raw_moment` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,16 +25,16 @@ The oneapi::mkl::stats::raw_moment function is used to compute array of raw mome * - ``double`` -.. _onemkl_stats_raw_moment_buffer: +.. _onemath_stats_raw_moment_buffer: -oneapi::mkl::stats::raw_moment (buffer version) ------------------------------------------------ +oneapi::math::stats::raw_moment (buffer version) +------------------------------------------------ .. rubric:: Syntax .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void raw_moment(sycl::queue& queue, const dataset>& data, @@ -51,14 +51,14 @@ oneapi::mkl::stats::raw_moment (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -90,10 +90,10 @@ oneapi::mkl::stats::raw_moment (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when mean.get_count() == 0 & raw_moment_2.get_count() == 0 & raw_moment_3.get_count() == 0 & raw_moment_4.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_raw_moment_usm: +.. _onemath_stats_raw_moment_usm: raw_moment (USM version) ------------------------ @@ -102,7 +102,7 @@ raw_moment (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event raw_moment( sycl::queue& queue, @@ -121,14 +121,14 @@ raw_moment (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -163,7 +163,7 @@ raw_moment (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when mean == nullptr & raw_moment_2 == nullptr & raw_moment_3 == nullptr & raw_moment_4 == nullptr, or dataset object is invalid .. container:: section @@ -173,5 +173,5 @@ raw_moment (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_raw_sum.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_raw_sum.rst similarity index 82% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_raw_sum.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_raw_sum.rst index 453ee45cd3..dffe1ddf46 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_raw_sum.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_raw_sum.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_raw_sum: +.. _onemath_stats_raw_sum: raw_sum ======= Entry point to compute raw sums up to the 4th order. -.. _onemkl_stats_raw_sum_description: +.. _onemath_stats_raw_sum_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::raw_sum function is used to compute an array of raw sums up to the 4th order (raw sums for each dataset's dimension). +The oneapi::math::stats::raw_sum function is used to compute an array of raw sums up to the 4th order (raw sums for each dataset's dimension). -:ref:`onemkl_stats_raw_sum` supports the following precisions for data: +:ref:`onemath_stats_raw_sum` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::raw_sum function is used to compute an array of raw sums * - ``double`` -.. _onemkl_stats_raw_sum_buffer: +.. _onemath_stats_raw_sum_buffer: raw_sum (Buffer version) ------------------------ @@ -34,7 +34,7 @@ raw_sum (Buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void raw_sum(sycl::queue& queue, const dataset>& data, @@ -51,14 +51,14 @@ raw_sum (Buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -90,10 +90,10 @@ raw_sum (Buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when sum.get_count() == 0 & raw_sum_2.get_count() == 0 & raw_sum_3.get_count() == 0 & raw_sum_4.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_raw_sum_usm: +.. _onemath_stats_raw_sum_usm: raw_sum (USM version) --------------------- @@ -102,7 +102,7 @@ raw_sum (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event raw_sum(sycl::queue& queue, const dataset& data, @@ -120,14 +120,14 @@ raw_sum (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -162,7 +162,7 @@ raw_sum (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when sum == nullptr & raw_sum_2 == nullptr & raw_sum_3 == nullptr & raw_sum_4 == nullptr, or dataset object is invalid .. container:: section @@ -172,5 +172,5 @@ raw_sum (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMath/source/domains/stats/onemath_stats_routines.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_routines.rst new file mode 100755 index 0000000000..7cf9822c49 --- /dev/null +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_routines.rst @@ -0,0 +1,76 @@ +.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation +.. +.. SPDX-License-Identifier: CC-BY-4.0 + +.. _onemath_stats_routines: + +Summary Statistics Routines +=========================== + +The oneMath Summary Statistics routines calculate next estimates: + +.. container:: + + .. container:: tablenoborder + + .. list-table:: + :header-rows: 1 + + * - Routine + - Description + * - :ref:`onemath_stats_raw_sum` + - Raw sums up to the fourth order + * - :ref:`onemath_stats_central_sum` + - Central sums up to the fourth order + * - :ref:`onemath_stats_central_sum_user_mean` + - Central sums up to the fourth order with provided mean + * - :ref:`onemath_stats_mean` + - Mean value + * - :ref:`onemath_stats_raw_moment` + - Raw moments up to the fourth order + * - :ref:`onemath_stats_central_moment` + - Central moments up to the fourth order + * - :ref:`onemath_stats_central_moment_user_mean` + - Central moments up to the fourth order with provided mean + * - :ref:`onemath_stats_variation` + - Variation coefficient + * - :ref:`onemath_stats_variation_user_mean` + - Variation coefficient with provided mean + * - :ref:`onemath_stats_skewness` + - Skewness value + * - :ref:`onemath_stats_skewness_user_mean` + - Skewness value with provided mean + * - :ref:`onemath_stats_kurtosis` + - Kurtosis value + * - :ref:`onemath_stats_kurtosis_user_mean` + - Kurtosis value with provided mean + * - :ref:`onemath_stats_min` + - Min value + * - :ref:`onemath_stats_max` + - Max value + * - :ref:`onemath_stats_min_max` + - Min and max values +   + **Parent topic:** :ref:`onemath_stats` + + + +.. toctree:: + :hidden: + + onemath_stats_raw_sum + onemath_stats_central_sum + onemath_stats_central_sum_user_mean + onemath_stats_mean + onemath_stats_raw_moment + onemath_stats_central_moment + onemath_stats_central_moment_user_mean + onemath_stats_variation + onemath_stats_variation_user_mean + onemath_stats_skewness + onemath_stats_skewness_user_mean + onemath_stats_kurtosis + onemath_stats_kurtosis_user_mean + onemath_stats_min + onemath_stats_max + onemath_stats_min_max \ No newline at end of file diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_service_routines.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_service_routines.rst similarity index 67% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_service_routines.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_service_routines.rst index aae6a421ee..7e2ca9710e 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_service_routines.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_service_routines.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_service_routines: +.. _onemath_stats_service_routines: Service Routines ================ @@ -19,14 +19,14 @@ Service Routines * - Routine - Description - * - \ :ref:`onemkl_stats_make_dataset`\ + * - \ :ref:`onemath_stats_make_dataset`\ - Creates a dataset from the provided parameters - **Parent topic:** :ref:`onemkl_stats` + **Parent topic:** :ref:`onemath_stats` .. toctree:: :hidden: - onemkl_stats_make_dataset + onemath_stats_make_dataset diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_skewness.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_skewness.rst similarity index 77% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_skewness.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_skewness.rst index d8ab16d8bd..7a03202da4 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_skewness.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_skewness.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_skewness: +.. _onemath_stats_skewness: skewness ======== Entry point to compute skewness. -.. _onemkl_stats_skewness_description: +.. _onemath_stats_skewness_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::skewness function is used to compute a skewness array (skewness for each dataset's dimension). +The oneapi::math::stats::skewness function is used to compute a skewness array (skewness for each dataset's dimension). -:ref:`onemkl_stats_skewness` supports the following precisions for data: +:ref:`onemath_stats_skewness` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::skewness function is used to compute a skewness array (s * - ``double`` -.. _onemkl_stats_skewness_buffer: +.. _onemath_stats_skewness_buffer: skewness (buffer version) ------------------------- @@ -34,7 +34,7 @@ skewness (buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void skewness(sycl::queue& queue, const dataset>& data, @@ -48,14 +48,14 @@ skewness (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -78,10 +78,10 @@ skewness (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when skewness.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_skewness_usm: +.. _onemath_stats_skewness_usm: skewness (USM version) ---------------------- @@ -90,7 +90,7 @@ skewness (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event skewness(sycl::queue& queue, const dataset& data, @@ -105,14 +105,14 @@ skewness (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -138,7 +138,7 @@ skewness (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when skewness == nullptr, or dataset object is invalid .. container:: section @@ -148,5 +148,5 @@ skewness (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_skewness_user_mean.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_skewness_user_mean.rst similarity index 80% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_skewness_user_mean.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_skewness_user_mean.rst index 93429aabc0..94570e4df8 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_skewness_user_mean.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_skewness_user_mean.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_skewness_user_mean: +.. _onemath_stats_skewness_user_mean: skewness with provided mean =========================== Entry point to compute skewness with the provided mean values. -.. _onemkl_stats_skewness_user_mean_description: +.. _onemath_stats_skewness_user_mean_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::skewness function is used to compute an array of skewness (skewness for each dataset's dimension) with the provided mean values. +The oneapi::math::stats::skewness function is used to compute an array of skewness (skewness for each dataset's dimension) with the provided mean values. -:ref:`onemkl_stats_skewness_user_mean` supports the following precisions for data: +:ref:`onemath_stats_skewness_user_mean` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::skewness function is used to compute an array of skewnes * - ``double`` -.. _onemkl_stats_skewness_user_mean_buffer: +.. _onemath_stats_skewness_user_mean_buffer: skewness with provided mean (buffer version) -------------------------------------------- @@ -34,7 +34,7 @@ skewness with provided mean (buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void skewness(sycl::queue& queue, sycl::buffer mean, @@ -49,13 +49,13 @@ skewness with provided mean (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -81,10 +81,10 @@ skewness with provided mean (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when skewness.get_count() == 0, or mean.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_skewness_user_mean_usm: +.. _onemath_stats_skewness_user_mean_usm: skewness with provided mean (USM version) ----------------------------------------- @@ -93,7 +93,7 @@ skewness with provided mean (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event skewness(sycl::queue& queue, Type* mean, @@ -109,13 +109,13 @@ skewness with provided mean (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -144,7 +144,7 @@ skewness with provided mean (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when skewness == nullptr, or mean == nullptr, or dataset object is invalid .. container:: section @@ -154,5 +154,5 @@ skewness with provided mean (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_usage_model.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_usage_model.rst similarity index 65% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_usage_model.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_usage_model.rst index bb6d634ab3..487f2af9e3 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_usage_model.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_usage_model.rst @@ -2,10 +2,10 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_usage_model: +.. _onemath_stats_usage_model: -oneMKL Summary Statistics Usage Model -===================================== +oneMath Summary Statistics Usage Model +====================================== .. rubric:: Description @@ -17,7 +17,7 @@ A typical algorithm for summary statistics is as follows: #. Call the summary statistics routine to calculate the appropriate estimate. -The following example demonstrates how to calculate mean values for a 3-dimensional dataset filled with random numbers. For dataset creation, the :ref:`onemkl_stats_make_dataset` helper function is used. +The following example demonstrates how to calculate mean values for a 3-dimensional dataset filled with random numbers. For dataset creation, the :ref:`onemath_stats_make_dataset` helper function is used. USM-based example @@ -25,7 +25,7 @@ USM-based example .. code-block:: cpp - #include "oneapi/mkl/stats.hpp" + #include "oneapi/math/stats.hpp" int main() { sycl::queue queue; @@ -36,11 +36,11 @@ USM-based example // allocate Unified Shared Memory for the dataset of the size n_observations * n_dims and fill it with any data // allocate Unified Shared Memory for the mean output of the size n_dims - // create oneapi::mkl::stats::dataset - auto dataset = oneapi::mkl::stats::make_dataset(n_dims, n_observations, dataset_ptr); + // create oneapi::math::stats::dataset + auto dataset = oneapi::math::stats::make_dataset(n_dims, n_observations, dataset_ptr); // call statistics computation routine - auto event = oneapi::mkl::stats::mean(queue, dataset, mean_ptr); + auto event = oneapi::math::stats::mean(queue, dataset, mean_ptr); // wait until computations are completed event.wait(); @@ -48,4 +48,4 @@ USM-based example // ... } -**Parent topic:** :ref:`onemkl_stats` +**Parent topic:** :ref:`onemath_stats` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_variation.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_variation.rst similarity index 77% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_variation.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_variation.rst index cf5e148619..61b2d6b146 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_variation.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_variation.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_variation: +.. _onemath_stats_variation: variation ========= Entry point to compute variation. -.. _onemkl_stats_variation_description: +.. _onemath_stats_variation_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::variation function is used to compute a variation array (variation for each dataset's dimension). +The oneapi::math::stats::variation function is used to compute a variation array (variation for each dataset's dimension). -:ref:`onemkl_stats_variation` supports the following precisions for data: +:ref:`onemath_stats_variation` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,7 +25,7 @@ The oneapi::mkl::stats::variation function is used to compute a variation array * - ``double`` -.. _onemkl_stats_variation_buffer: +.. _onemath_stats_variation_buffer: variation (buffer version) -------------------------- @@ -34,7 +34,7 @@ variation (buffer version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void variation(sycl::queue& queue, const dataset>& data, @@ -48,14 +48,14 @@ variation (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -78,10 +78,10 @@ variation (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when variation.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_variation_usm: +.. _onemath_stats_variation_usm: variation (USM version) ----------------------- @@ -90,7 +90,7 @@ variation (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event variation(sycl::queue& queue, const dataset& data, @@ -105,14 +105,14 @@ variation (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` - * ``oneapi::mkl::stats::method::one_pass`` + * ``oneapi::math::stats::method::fast`` + * ``oneapi::math::stats::method::one_pass`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -138,7 +138,7 @@ variation (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when variation == nullptr, or dataset object is invalid .. container:: section @@ -148,5 +148,5 @@ variation (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/stats/onemkl_stats_variation_user_mean.rst b/source/elements/oneMath/source/domains/stats/onemath_stats_variation_user_mean.rst similarity index 77% rename from source/elements/oneMKL/source/domains/stats/onemkl_stats_variation_user_mean.rst rename to source/elements/oneMath/source/domains/stats/onemath_stats_variation_user_mean.rst index dcec77f5bd..eb424e0a6e 100755 --- a/source/elements/oneMKL/source/domains/stats/onemkl_stats_variation_user_mean.rst +++ b/source/elements/oneMath/source/domains/stats/onemath_stats_variation_user_mean.rst @@ -2,20 +2,20 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_stats_variation_user_mean: +.. _onemath_stats_variation_user_mean: variation with provided mean ============================ Entry point to compute variation with the provided mean values. -.. _onemkl_stats_variation_user_mean_description: +.. _onemath_stats_variation_user_mean_description: .. rubric:: Description and Assumptions -The oneapi::mkl::stats::variation function is used to compute an array of variation (variation for each dataset's dimension) with the provided mean values. +The oneapi::math::stats::variation function is used to compute an array of variation (variation for each dataset's dimension) with the provided mean values. -:ref:`onemkl_stats_variation_user_mean` supports the following precisions for data: +:ref:`onemath_stats_variation_user_mean` supports the following precisions for data: .. list-table:: :header-rows: 1 @@ -25,16 +25,16 @@ The oneapi::mkl::stats::variation function is used to compute an array of variat * - ``double`` -.. _onemkl_stats_variation_user_mean_buffer: +.. _onemath_stats_variation_user_mean_buffer: -oneapi::mkl::stats::variation (buffer version) ----------------------------------------------- +oneapi::math::stats::variation (buffer version) +----------------------------------------------- .. rubric:: Syntax .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template void variation(sycl::queue& queue, sycl::buffer mean, const dataset>& data, @@ -48,13 +48,13 @@ oneapi::mkl::stats::variation (buffer version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -81,10 +81,10 @@ oneapi::mkl::stats::variation (buffer version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when variation.get_count() == 0, or mean.get_count() == 0, or dataset object is invalid -.. _onemkl_stats_variation_user_mean_usm: +.. _onemath_stats_variation_user_mean_usm: variation with provided mean (USM version) ------------------------------------------ @@ -93,7 +93,7 @@ variation with provided mean (USM version) .. code-block:: cpp - namespace oneapi::mkl::stats { + namespace oneapi::math::stats { template sycl::event variation(sycl::queue& queue, Type* mean, @@ -109,13 +109,13 @@ variation with provided mean (USM version) Method Method which is used for estimate computation. The specific values are as follows: - * ``oneapi::mkl::stats::method::fast`` + * ``oneapi::math::stats::method::fast`` Type Data precision. ObservationsLayout - Data layout. The specific values are described in :ref:`onemkl_stats_dataset`. + Data layout. The specific values are described in :ref:`onemath_stats_dataset`. .. container:: section @@ -144,7 +144,7 @@ variation with provided mean (USM version) .. rubric:: Throws - oneapi::mkl::invalid_argument + oneapi::math::invalid_argument Exception is thrown when variation == nullptr, or mean == nullptr, or dataset object is invalid .. container:: section @@ -153,5 +153,5 @@ variation with provided mean (USM version) Output event to wait on to ensure computation is complete. -**Parent topic:** :ref:`onemkl_stats_routines` +**Parent topic:** :ref:`onemath_stats_routines` diff --git a/source/elements/oneMKL/source/domains/value_or_pointer.rst b/source/elements/oneMath/source/domains/value_or_pointer.rst similarity index 81% rename from source/elements/oneMKL/source/domains/value_or_pointer.rst rename to source/elements/oneMath/source/domains/value_or_pointer.rst index aef22f5a3e..2cfaa626d9 100644 --- a/source/elements/oneMKL/source/domains/value_or_pointer.rst +++ b/source/elements/oneMath/source/domains/value_or_pointer.rst @@ -9,7 +9,7 @@ Scalar Arguments in BLAS .. container:: - The USM version of oneMKL BLAS routines for DPC++ will accept either + The USM version of oneMath BLAS routines for DPC++ will accept either a scalar (for example ``float``) or pointer (``float*``) for parameters that represent a single fixed value (not a vector or matrix). These parameters are often named ``alpha`` or ``beta`` in BLAS. @@ -27,14 +27,14 @@ Scalar Arguments in BLAS float *alpha_ptr = sycl::malloc_shared(1, queue); float *beta_ptr = sycl::malloc_shared(1, queue); // fill alpha_ptr and beta_ptr with desired values - oneapi::mkl::blas::column_major::gemv(queue, trans, m, n, alpha_ptr, lda, x, incx, beta_ptr, + oneapi::math::blas::column_major::gemv(queue, trans, m, n, alpha_ptr, lda, x, incx, beta_ptr, y, incy).wait(); or with literal values: .. code-block:: - oneapi::mkl::blas::column_major::gemv(queue, trans, m, n, 2, lda, x, incx, 2.7, + oneapi::math::blas::column_major::gemv(queue, trans, m, n, 2, lda, x, incx, 2.7, y, incy).wait(); Users can even mix scalar and pointer parameters in a single call: @@ -42,7 +42,7 @@ Scalar Arguments in BLAS .. code-block:: float *alpha_ptr = sycl::malloc_shared(1, queue); - oneapi::mkl::blas::column_major::gemv(queue, trans, m, n, alpha_ptr, lda, x, incx, 2.7, + oneapi::math::blas::column_major::gemv(queue, trans, m, n, alpha_ptr, lda, x, incx, 2.7, y, incy).wait(); Pointers provided for scalar parameters may be SYCL-managed pointers @@ -60,21 +60,21 @@ Scalar Arguments in BLAS :name: wrapper-time :class: sectiontitle - The USM version of oneMKL BLAS routines use a templated + The USM version of oneMath BLAS routines use a templated ``value_or_pointer`` wrapper to enable either pointers or values to be passed to routines that take a scalar parameter. In general, users should not explicitly use this type in their code. There is no need to construct an object of type - ``value_or_pointer`` in order to use the oneMKL functions that + ``value_or_pointer`` in order to use the oneMath functions that include it in their function signatures. Instead, values and pointers in user code will be implicitly converted to this type when a user - calls a oneMKL function. + calls a oneMath function. The ``value_or_pointer`` wrapper has two constructors, one that converts a value of type ``T`` (or anything convertible to ``T``) to ``value_or_pointer``, and another that converts a pointer to ``T`` - to ``value_or_pointer``. Internally, the oneMKL functions can + to ``value_or_pointer``. Internally, the oneMath functions can behave slightly differently depending on whether the underlying data is a value or a pointer, and if it points to host-side memory or device-side memory, but these uses should be transparent to users. @@ -85,7 +85,7 @@ Scalar Arguments in BLAS :name: dependencies :class: sectiontitle - For scalar parameters passed to oneMKL BLAS routines as pointers, the + For scalar parameters passed to oneMath BLAS routines as pointers, the timing of pointer dereferencing depends on whether it is a USM-managed pointer or a raw pointer. @@ -100,5 +100,5 @@ Scalar Arguments in BLAS function is called and it may not be assigned asynchronously. - **Parent topic:** :ref:`onemkl_dense_linear_algebra` + **Parent topic:** :ref:`onemath_dense_linear_algebra` diff --git a/source/elements/oneMKL/source/domains/vector_math.inc.rst b/source/elements/oneMath/source/domains/vector_math.inc.rst similarity index 78% rename from source/elements/oneMKL/source/domains/vector_math.inc.rst rename to source/elements/oneMath/source/domains/vector_math.inc.rst index 2cbf8856ec..b48314ca14 100644 --- a/source/elements/oneMKL/source/domains/vector_math.inc.rst +++ b/source/elements/oneMath/source/domains/vector_math.inc.rst @@ -2,14 +2,14 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_inc: +.. _onemath_vm_inc: Vector Math ----------- .. container:: - oneMKL :ref:`Vector Mathematics functions ` (VM) compute a mathematical + oneMath :ref:`Vector Mathematics functions ` (VM) compute a mathematical function of each of the vector elements. VM includes a set of functions (arithmetic, power, trigonometric, exponential, hyperbolic, special, and rounding) that operate on vectors of real diff --git a/source/elements/oneMKL/source/domains/vm/abs.rst b/source/elements/oneMath/source/domains/vm/abs.rst similarity index 83% rename from source/elements/oneMKL/source/domains/vm/abs.rst rename to source/elements/oneMath/source/domains/vm/abs.rst index efdd97cefb..d51df9e284 100644 --- a/source/elements/oneMKL/source/domains/vm/abs.rst +++ b/source/elements/oneMath/source/domains/vm/abs.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_abs: +.. _onemath_vm_abs: abs === @@ -27,16 +27,16 @@ abs .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event abs( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -46,7 +46,7 @@ abs .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event abs( sycl::queue& exec_queue, @@ -54,9 +54,9 @@ abs const T *a, R* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -155,9 +155,9 @@ abs mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -181,9 +181,9 @@ abs mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -216,7 +216,7 @@ abs .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -224,6 +224,6 @@ abs .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/acos.rst b/source/elements/oneMath/source/domains/vm/acos.rst similarity index 83% rename from source/elements/oneMKL/source/domains/vm/acos.rst rename to source/elements/oneMath/source/domains/vm/acos.rst index 40e714851e..50701280f2 100644 --- a/source/elements/oneMKL/source/domains/vm/acos.rst +++ b/source/elements/oneMath/source/domains/vm/acos.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_acos: +.. _onemath_vm_acos: acos ==== @@ -27,17 +27,17 @@ acos .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event acos( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ acos .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event acos( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ acos const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -110,13 +110,13 @@ acos -   * - \|a\| > 1 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -231,14 +231,14 @@ acos mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -264,14 +264,14 @@ acos mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -306,7 +306,7 @@ acos .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -314,6 +314,6 @@ acos .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/acosh.rst b/source/elements/oneMath/source/domains/vm/acosh.rst similarity index 83% rename from source/elements/oneMKL/source/domains/vm/acosh.rst rename to source/elements/oneMath/source/domains/vm/acosh.rst index e6e3afa2ba..f05a17cc7a 100644 --- a/source/elements/oneMKL/source/domains/vm/acosh.rst +++ b/source/elements/oneMath/source/domains/vm/acosh.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_acosh: +.. _onemath_vm_acosh: acosh ===== @@ -27,17 +27,17 @@ acosh .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event acosh( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ acosh .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event acosh( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ acosh const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -102,10 +102,10 @@ acosh -   * - a < +1 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - +∞ -   @@ -223,14 +223,14 @@ acosh mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -256,14 +256,14 @@ acosh mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -298,7 +298,7 @@ acosh .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -306,4 +306,4 @@ acosh .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/acospi.rst b/source/elements/oneMath/source/domains/vm/acospi.rst similarity index 77% rename from source/elements/oneMKL/source/domains/vm/acospi.rst rename to source/elements/oneMath/source/domains/vm/acospi.rst index fb1a9fed46..85292a6ce3 100644 --- a/source/elements/oneMKL/source/domains/vm/acospi.rst +++ b/source/elements/oneMath/source/domains/vm/acospi.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_acospi: +.. _onemath_vm_acospi: acospi ====== @@ -27,17 +27,17 @@ acospi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event acospi( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ acospi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event acospi( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ acospi const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -110,13 +110,13 @@ acospi -   * - \|\ ``a``\ \| > 1 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - - ∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -151,14 +151,14 @@ acospi mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -184,14 +184,14 @@ acospi mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -226,7 +226,7 @@ acospi .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -234,6 +234,6 @@ acospi .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/add.rst b/source/elements/oneMath/source/domains/vm/add.rst similarity index 81% rename from source/elements/oneMKL/source/domains/vm/add.rst rename to source/elements/oneMath/source/domains/vm/add.rst index 9e6d20dba9..54ccab1a82 100644 --- a/source/elements/oneMKL/source/domains/vm/add.rst +++ b/source/elements/oneMath/source/domains/vm/add.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_add: +.. _onemath_vm_add: add === @@ -28,7 +28,7 @@ add .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event add( sycl::queue& exec_queue, @@ -36,10 +36,10 @@ add sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -49,7 +49,7 @@ add .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event add( sycl::queue& exec_queue, @@ -58,10 +58,10 @@ add const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -157,8 +157,8 @@ add are finite numbers, but the real or imaginary part of the computed result is so large that it does not fit the target precision. In this case, the function returns ∞ in that part of the result, and sets the - VM status code to ``oneapi::mkl::vm::status::overflow`` (overriding any possible - ``oneapi::mkl::vm::status::accuracy_warning`` status). + VM status code to ``oneapi::math::vm::status::overflow`` (overriding any possible + ``oneapi::math::vm::status::accuracy_warning`` status). .. container:: section @@ -189,14 +189,14 @@ add mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -226,14 +226,14 @@ add mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -268,7 +268,7 @@ add .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -276,6 +276,6 @@ add .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/arg.rst b/source/elements/oneMath/source/domains/vm/arg.rst similarity index 84% rename from source/elements/oneMKL/source/domains/vm/arg.rst rename to source/elements/oneMath/source/domains/vm/arg.rst index 42d718771b..cdc6fcb2eb 100644 --- a/source/elements/oneMKL/source/domains/vm/arg.rst +++ b/source/elements/oneMath/source/domains/vm/arg.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_arg: +.. _onemath_vm_arg: arg === @@ -27,16 +27,16 @@ arg .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event arg( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -46,7 +46,7 @@ arg .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event arg( sycl::queue& exec_queue, @@ -54,9 +54,9 @@ arg const T *a, R* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -84,7 +84,7 @@ arg The arg(a) function computes argument of vector elements. - See :ref:`onemkl_vm_special_value_notations` for the conventions used in the + See :ref:`onemath_vm_special_value_notations` for the conventions used in the table below. @@ -199,9 +199,9 @@ arg mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -225,9 +225,9 @@ arg mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -260,7 +260,7 @@ arg .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -268,6 +268,6 @@ arg .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/asin.rst b/source/elements/oneMath/source/domains/vm/asin.rst similarity index 77% rename from source/elements/oneMKL/source/domains/vm/asin.rst rename to source/elements/oneMath/source/domains/vm/asin.rst index 6b2313184b..dc71c44700 100644 --- a/source/elements/oneMKL/source/domains/vm/asin.rst +++ b/source/elements/oneMath/source/domains/vm/asin.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_asin: +.. _onemath_vm_asin: asin ==== @@ -27,17 +27,17 @@ asin .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event asin( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ asin .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event asin( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ asin const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -110,13 +110,13 @@ asin -   * - \|a\| > 1 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -158,14 +158,14 @@ asin mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -191,14 +191,14 @@ asin mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -233,7 +233,7 @@ asin .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -241,6 +241,6 @@ asin .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/asinh.rst b/source/elements/oneMath/source/domains/vm/asinh.rst similarity index 87% rename from source/elements/oneMKL/source/domains/vm/asinh.rst rename to source/elements/oneMath/source/domains/vm/asinh.rst index c0d13ff837..467252788a 100644 --- a/source/elements/oneMKL/source/domains/vm/asinh.rst +++ b/source/elements/oneMath/source/domains/vm/asinh.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_asinh: +.. _onemath_vm_asinh: asinh ===== @@ -27,16 +27,16 @@ asinh .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event asinh( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -46,7 +46,7 @@ asinh .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event asinh( sycl::queue& exec_queue, @@ -54,9 +54,9 @@ asinh const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -227,9 +227,9 @@ asinh mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -253,9 +253,9 @@ asinh mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -288,7 +288,7 @@ asinh .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -296,6 +296,6 @@ asinh .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/asinpi.rst b/source/elements/oneMath/source/domains/vm/asinpi.rst similarity index 77% rename from source/elements/oneMKL/source/domains/vm/asinpi.rst rename to source/elements/oneMath/source/domains/vm/asinpi.rst index ec0b242b98..611c514ee9 100644 --- a/source/elements/oneMKL/source/domains/vm/asinpi.rst +++ b/source/elements/oneMath/source/domains/vm/asinpi.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_asinpi: +.. _onemath_vm_asinpi: asinpi ====== @@ -27,17 +27,17 @@ asinpi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event asinpi( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ asinpi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event asinpi( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ asinpi const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -110,13 +110,13 @@ asinpi -   * - \|\ ``a``\ \| > 1 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -151,14 +151,14 @@ asinpi mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -184,14 +184,14 @@ asinpi mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -226,7 +226,7 @@ asinpi .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -234,6 +234,6 @@ asinpi .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/atan.rst b/source/elements/oneMath/source/domains/vm/atan.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/atan.rst rename to source/elements/oneMath/source/domains/vm/atan.rst index 0e7f6d9801..58ecf73e59 100644 --- a/source/elements/oneMKL/source/domains/vm/atan.rst +++ b/source/elements/oneMath/source/domains/vm/atan.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_atan: +.. _onemath_vm_atan: atan ==== @@ -27,16 +27,16 @@ atan .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event atan( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -46,7 +46,7 @@ atan .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event atan( sycl::queue& exec_queue, @@ -54,9 +54,9 @@ atan const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -150,9 +150,9 @@ atan mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -176,9 +176,9 @@ atan mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -211,7 +211,7 @@ atan .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -219,6 +219,6 @@ atan .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/atan2.rst b/source/elements/oneMath/source/domains/vm/atan2.rst similarity index 89% rename from source/elements/oneMKL/source/domains/vm/atan2.rst rename to source/elements/oneMath/source/domains/vm/atan2.rst index e5395ecd4a..e2c4eb0d53 100644 --- a/source/elements/oneMKL/source/domains/vm/atan2.rst +++ b/source/elements/oneMath/source/domains/vm/atan2.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_atan2: +.. _onemath_vm_atan2: atan2 ===== @@ -27,7 +27,7 @@ atan2 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event atan2( sycl::queue& exec_queue, @@ -35,9 +35,9 @@ atan2 sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ atan2 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event atan2( sycl::queue& exec_queue, @@ -56,9 +56,9 @@ atan2 const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -295,9 +295,9 @@ atan2 mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -325,9 +325,9 @@ atan2 mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -360,7 +360,7 @@ atan2 .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -368,6 +368,6 @@ atan2 .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/atan2pi.rst b/source/elements/oneMath/source/domains/vm/atan2pi.rst similarity index 89% rename from source/elements/oneMKL/source/domains/vm/atan2pi.rst rename to source/elements/oneMath/source/domains/vm/atan2pi.rst index 697eacf787..8c6b8a1baf 100644 --- a/source/elements/oneMKL/source/domains/vm/atan2pi.rst +++ b/source/elements/oneMath/source/domains/vm/atan2pi.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_atan2pi: +.. _onemath_vm_atan2pi: atan2pi ======= @@ -28,7 +28,7 @@ atan2pi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event atan2pi( sycl::queue& exec_queue, @@ -36,9 +36,9 @@ atan2pi sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ atan2pi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event atan2pi( sycl::queue& exec_queue, @@ -57,9 +57,9 @@ atan2pi const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -298,9 +298,9 @@ atan2pi mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -328,9 +328,9 @@ atan2pi mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -363,7 +363,7 @@ atan2pi .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -371,6 +371,6 @@ atan2pi .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/atanh.rst b/source/elements/oneMath/source/domains/vm/atanh.rst similarity index 80% rename from source/elements/oneMKL/source/domains/vm/atanh.rst rename to source/elements/oneMath/source/domains/vm/atanh.rst index 52d629c963..21af54b931 100644 --- a/source/elements/oneMKL/source/domains/vm/atanh.rst +++ b/source/elements/oneMath/source/domains/vm/atanh.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_atanh: +.. _onemath_vm_atanh: atanh ===== @@ -27,17 +27,17 @@ atanh .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event atanh( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ atanh .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event atanh( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ atanh const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -99,19 +99,19 @@ atanh - Status code * - +1 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -1 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - \|a\| > 1 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - +∞ - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -199,7 +199,7 @@ atanh Notes: - - ``atanh(±1±i*0)=±∞±i*0``, and oneapi::mkl::vm::status::sing error is generated + - ``atanh(±1±i*0)=±∞±i*0``, and oneapi::math::vm::status::sing error is generated - ``atanh(CONJ(a))=CONJ(atanh(a))`` @@ -232,14 +232,14 @@ atanh mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -265,14 +265,14 @@ atanh mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -307,7 +307,7 @@ atanh .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -315,6 +315,6 @@ atanh .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/atanpi.rst b/source/elements/oneMath/source/domains/vm/atanpi.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/atanpi.rst rename to source/elements/oneMath/source/domains/vm/atanpi.rst index d02ee7f198..def0e9896e 100644 --- a/source/elements/oneMKL/source/domains/vm/atanpi.rst +++ b/source/elements/oneMath/source/domains/vm/atanpi.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_atanpi: +.. _onemath_vm_atanpi: atanpi ====== @@ -27,16 +27,16 @@ atanpi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event atanpi( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -46,7 +46,7 @@ atanpi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event atanpi( sycl::queue& exec_queue, @@ -54,9 +54,9 @@ atanpi const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -143,9 +143,9 @@ atanpi mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -169,9 +169,9 @@ atanpi mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -204,7 +204,7 @@ atanpi .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -212,6 +212,6 @@ atanpi .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/bibliography.rst b/source/elements/oneMath/source/domains/vm/bibliography.rst similarity index 93% rename from source/elements/oneMKL/source/domains/vm/bibliography.rst rename to source/elements/oneMath/source/domains/vm/bibliography.rst index a72a095e18..a6b8bc6414 100644 --- a/source/elements/oneMKL/source/domains/vm/bibliography.rst +++ b/source/elements/oneMath/source/domains/vm/bibliography.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_bibliography: +.. _onemath_vm_bibliography: Bibliography ============ diff --git a/source/elements/oneMKL/source/domains/vm/cbrt.rst b/source/elements/oneMath/source/domains/vm/cbrt.rst similarity index 81% rename from source/elements/oneMKL/source/domains/vm/cbrt.rst rename to source/elements/oneMath/source/domains/vm/cbrt.rst index 7787b944f1..b579d0a424 100644 --- a/source/elements/oneMKL/source/domains/vm/cbrt.rst +++ b/source/elements/oneMath/source/domains/vm/cbrt.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_cbrt: +.. _onemath_vm_cbrt: cbrt ==== @@ -27,16 +27,16 @@ cbrt .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cbrt( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -46,7 +46,7 @@ cbrt .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cbrt( sycl::queue& exec_queue, @@ -54,9 +54,9 @@ cbrt const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -141,9 +141,9 @@ cbrt mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -167,9 +167,9 @@ cbrt mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -202,7 +202,7 @@ cbrt .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -210,6 +210,6 @@ cbrt .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/cdfnorm.rst b/source/elements/oneMath/source/domains/vm/cdfnorm.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/cdfnorm.rst rename to source/elements/oneMath/source/domains/vm/cdfnorm.rst index dbb122284f..bb709fe527 100644 --- a/source/elements/oneMKL/source/domains/vm/cdfnorm.rst +++ b/source/elements/oneMath/source/domains/vm/cdfnorm.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_cdfnorm: +.. _onemath_vm_cdfnorm: cdfnorm ======= @@ -28,17 +28,17 @@ cdfnorm .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cdfnorm( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ cdfnorm .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cdfnorm( sycl::queue& exec_queue, @@ -56,10 +56,10 @@ cdfnorm const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -136,7 +136,7 @@ cdfnorm - Status code * - a < underflow - +0 - - ``oneapi::mkl::vm::status::underflow`` + - ``oneapi::math::vm::status::underflow`` * - +∞ - +1 -   @@ -177,14 +177,14 @@ cdfnorm mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -210,14 +210,14 @@ cdfnorm mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -252,7 +252,7 @@ cdfnorm .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -260,6 +260,6 @@ cdfnorm .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` .. |image0| image:: ../equations/error_functions_plot.jpg diff --git a/source/elements/oneMKL/source/domains/vm/cdfnorminv.rst b/source/elements/oneMath/source/domains/vm/cdfnorminv.rst similarity index 78% rename from source/elements/oneMKL/source/domains/vm/cdfnorminv.rst rename to source/elements/oneMath/source/domains/vm/cdfnorminv.rst index 00364c03a7..790debdae3 100644 --- a/source/elements/oneMKL/source/domains/vm/cdfnorminv.rst +++ b/source/elements/oneMath/source/domains/vm/cdfnorminv.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_cdfnorminv: +.. _onemath_vm_cdfnorminv: cdfnorminv ========== @@ -28,17 +28,17 @@ cdfnorminv .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cdfnorminv( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ cdfnorminv .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cdfnorminv( sycl::queue& exec_queue, @@ -56,10 +56,10 @@ cdfnorminv const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -144,25 +144,25 @@ cdfnorminv -   * - +1 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - +0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - a < -0 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - a > +1 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -197,14 +197,14 @@ cdfnorminv mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -230,14 +230,14 @@ cdfnorminv mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -272,7 +272,7 @@ cdfnorminv .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -280,7 +280,7 @@ cdfnorminv .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/ceil.rst b/source/elements/oneMath/source/domains/vm/ceil.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/ceil.rst rename to source/elements/oneMath/source/domains/vm/ceil.rst index 1484392823..7ffd89e318 100644 --- a/source/elements/oneMKL/source/domains/vm/ceil.rst +++ b/source/elements/oneMath/source/domains/vm/ceil.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_ceil: +.. _onemath_vm_ceil: ceil ==== @@ -28,16 +28,16 @@ ceil .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event ceil( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ ceil .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event ceil( sycl::queue& exec_queue, @@ -55,9 +55,9 @@ ceil const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -147,9 +147,9 @@ ceil mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -173,9 +173,9 @@ ceil mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -208,7 +208,7 @@ ceil .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -216,4 +216,4 @@ ceil .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/cis.rst b/source/elements/oneMath/source/domains/vm/cis.rst similarity index 78% rename from source/elements/oneMKL/source/domains/vm/cis.rst rename to source/elements/oneMath/source/domains/vm/cis.rst index 8c417f36b8..f5c9bf4da0 100644 --- a/source/elements/oneMKL/source/domains/vm/cis.rst +++ b/source/elements/oneMath/source/domains/vm/cis.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_cis: +.. _onemath_vm_cis: cis === @@ -28,17 +28,17 @@ cis .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cis( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ cis .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cis( sycl::queue& exec_queue, @@ -56,10 +56,10 @@ cis const T *a, R* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -107,10 +107,10 @@ cis -   * - + ∞ - QNAN+i·QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - - ∞ - QNAN+i·QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN+i·QNAN -   @@ -145,14 +145,14 @@ cis mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -178,14 +178,14 @@ cis mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -220,7 +220,7 @@ cis .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -228,6 +228,6 @@ cis .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/clear_status.rst b/source/elements/oneMath/source/domains/vm/clear_status.rst similarity index 71% rename from source/elements/oneMKL/source/domains/vm/clear_status.rst rename to source/elements/oneMath/source/domains/vm/clear_status.rst index a99eb52089..c824610d4a 100644 --- a/source/elements/oneMKL/source/domains/vm/clear_status.rst +++ b/source/elements/oneMath/source/domains/vm/clear_status.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_clear_status: +.. _onemath_vm_clear_status: clear_status ============ @@ -11,7 +11,7 @@ clear_status .. container:: - Resets the global VM status to ``oneapi::mkl::vm::status::success`` and returns the + Resets the global VM status to ``oneapi::math::vm::status::success`` and returns the previous VM status code. @@ -25,12 +25,12 @@ clear_status .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { - oneapi::mkl::vm::status clear_status( + oneapi::math::vm::status clear_status( sycl::queue& exec_queue); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm .. rubric:: Description @@ -38,7 +38,7 @@ clear_status The clear_status function sets the VM status code to - ``oneapi::mkl::vm::status::success`` and returns the previous VM status code + ``oneapi::math::vm::status::success`` and returns the previous VM status code for a given queue. @@ -55,23 +55,23 @@ clear_status - Description * - Successful Execution - - * - ``oneapi::mkl::vm::status::success`` + * - ``oneapi::math::vm::status::success`` - VM function execution completed successfully - * - ``oneapi::mkl::vm::status::not_defined`` + * - ``oneapi::math::vm::status::not_defined`` - VM status not defined * - Warnings - - * - ``oneapi::mkl::vm::status::accuracy_warning`` + * - ``oneapi::math::vm::status::accuracy_warning`` - VM function execution completed successfully in a different accuracy mode * - Computational status codes - - * - ``oneapi::mkl::vm::status::errdom`` + * - ``oneapi::math::vm::status::errdom`` - Values are out of a range of definition producing invalid (QNaN) result - * - ``oneapi::mkl::vm::status::sing`` + * - ``oneapi::math::vm::status::sing`` - Values cause divide-by-zero (singularity) computational errors and produce and invalid (QNaN or Inf) result - * - ``oneapi::mkl::vm::status::overflow`` + * - ``oneapi::math::vm::status::overflow`` - An overflow happened during the calculation process - * - ``oneapi::mkl::vm::status::underflow`` + * - ``oneapi::math::vm::status::underflow`` - An underflow happened during the calculation process @@ -104,6 +104,6 @@ clear_status .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_service_functions` + **Parent topic:** :ref:`onemath_vm_service_functions` diff --git a/source/elements/oneMKL/source/domains/vm/conj.rst b/source/elements/oneMath/source/domains/vm/conj.rst similarity index 79% rename from source/elements/oneMKL/source/domains/vm/conj.rst rename to source/elements/oneMath/source/domains/vm/conj.rst index 9f0d38438d..6687925467 100644 --- a/source/elements/oneMKL/source/domains/vm/conj.rst +++ b/source/elements/oneMath/source/domains/vm/conj.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_conj: +.. _onemath_vm_conj: conj ==== @@ -27,16 +27,16 @@ conj .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event conj( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -46,7 +46,7 @@ conj .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event conj( sycl::queue& exec_queue, @@ -54,9 +54,9 @@ conj const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -112,9 +112,9 @@ conj mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -138,9 +138,9 @@ conj mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -173,7 +173,7 @@ conj .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -181,6 +181,6 @@ conj .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/copysign.rst b/source/elements/oneMath/source/domains/vm/copysign.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/copysign.rst rename to source/elements/oneMath/source/domains/vm/copysign.rst index 43ea5184fc..57b1571a0e 100644 --- a/source/elements/oneMKL/source/domains/vm/copysign.rst +++ b/source/elements/oneMath/source/domains/vm/copysign.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_copysign: +.. _onemath_vm_copysign: copysign ======== @@ -28,7 +28,7 @@ copysign .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event copysign( sycl::queue& exec_queue, @@ -36,9 +36,9 @@ copysign sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ copysign .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event copysign( sycl::queue& exec_queue, @@ -57,9 +57,9 @@ copysign const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -141,9 +141,9 @@ copysign mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -171,9 +171,9 @@ copysign mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -206,7 +206,7 @@ copysign .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -214,6 +214,6 @@ copysign .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/cos.rst b/source/elements/oneMath/source/domains/vm/cos.rst similarity index 80% rename from source/elements/oneMKL/source/domains/vm/cos.rst rename to source/elements/oneMath/source/domains/vm/cos.rst index a6d4930a56..bad09164b4 100644 --- a/source/elements/oneMKL/source/domains/vm/cos.rst +++ b/source/elements/oneMath/source/domains/vm/cos.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_cos: +.. _onemath_vm_cos: cos === @@ -27,17 +27,17 @@ cos .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cos( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ cos .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cos( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ cos const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -114,10 +114,10 @@ cos -   * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -159,14 +159,14 @@ cos mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -192,14 +192,14 @@ cos mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -234,7 +234,7 @@ cos .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -242,6 +242,6 @@ cos .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/cosd.rst b/source/elements/oneMath/source/domains/vm/cosd.rst similarity index 80% rename from source/elements/oneMKL/source/domains/vm/cosd.rst rename to source/elements/oneMath/source/domains/vm/cosd.rst index 4b234ce093..994854d7ee 100644 --- a/source/elements/oneMKL/source/domains/vm/cosd.rst +++ b/source/elements/oneMath/source/domains/vm/cosd.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_cosd: +.. _onemath_vm_cosd: cosd ==== @@ -27,17 +27,17 @@ cosd .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cosd( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ cosd .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cosd( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ cosd const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -116,10 +116,10 @@ cosd -   * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -154,14 +154,14 @@ cosd mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -187,14 +187,14 @@ cosd mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -229,7 +229,7 @@ cosd .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -237,6 +237,6 @@ cosd .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/cosh.rst b/source/elements/oneMath/source/domains/vm/cosh.rst similarity index 83% rename from source/elements/oneMKL/source/domains/vm/cosh.rst rename to source/elements/oneMath/source/domains/vm/cosh.rst index 005e7e9b2a..a32856b7cc 100644 --- a/source/elements/oneMKL/source/domains/vm/cosh.rst +++ b/source/elements/oneMath/source/domains/vm/cosh.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_cosh: +.. _onemath_vm_cosh: cosh ==== @@ -27,17 +27,17 @@ cosh .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cosh( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ cosh .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cosh( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ cosh const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -120,10 +120,10 @@ cosh -   * - X > overflow - +∞ - - ``oneapi::mkl::vm::status::overflow`` + - ``oneapi::math::vm::status::overflow`` * - X < -overflow - +∞ - - ``oneapi::mkl::vm::status::overflow`` + - ``oneapi::math::vm::status::overflow`` * - +∞ - +∞ -   @@ -218,7 +218,7 @@ cosh - The complex cosh(a) function sets the VM status code to - ``oneapi::mkl::vm::status::overflow`` in the case of overflow, that is, when RE(a), + ``oneapi::math::vm::status::overflow`` in the case of overflow, that is, when RE(a), IM(a) are finite non-zero numbers, but the real or imaginary part of the exact result is so large that it does not meet the target precision. @@ -254,14 +254,14 @@ cosh mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -287,14 +287,14 @@ cosh mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -329,7 +329,7 @@ cosh .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -337,6 +337,6 @@ cosh .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/cospi.rst b/source/elements/oneMath/source/domains/vm/cospi.rst similarity index 80% rename from source/elements/oneMKL/source/domains/vm/cospi.rst rename to source/elements/oneMath/source/domains/vm/cospi.rst index e095b4bafe..681799ff80 100644 --- a/source/elements/oneMKL/source/domains/vm/cospi.rst +++ b/source/elements/oneMath/source/domains/vm/cospi.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_cospi: +.. _onemath_vm_cospi: cospi ===== @@ -27,17 +27,17 @@ cospi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cospi( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ cospi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event cospi( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ cospi const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -107,10 +107,10 @@ cospi -   * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -156,14 +156,14 @@ cospi mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -189,14 +189,14 @@ cospi mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -231,7 +231,7 @@ cospi .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -239,6 +239,6 @@ cospi .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/create_error_handler.rst b/source/elements/oneMath/source/domains/vm/create_error_handler.rst similarity index 81% rename from source/elements/oneMKL/source/domains/vm/create_error_handler.rst rename to source/elements/oneMath/source/domains/vm/create_error_handler.rst index 3be49afc14..80c241b4e8 100644 --- a/source/elements/oneMKL/source/domains/vm/create_error_handler.rst +++ b/source/elements/oneMath/source/domains/vm/create_error_handler.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_create_error_handler: +.. _onemath_vm_create_error_handler: create_error_handler ==================== @@ -27,16 +27,16 @@ create_error_handler .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { - oneapi::mkl::vm::error_handler create_error_handler( - sycl::buffer & status_array, + oneapi::math::vm::error_handler create_error_handler( + sycl::buffer & status_array, int64_t length = 1, - oneapi::mkl::vm::status status = oneapi::mkl::vm::status::not_defined, + oneapi::math::vm::status status = oneapi::math::vm::status::not_defined, T fixup = {}, bool copysign = false); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm USM API: @@ -45,16 +45,16 @@ create_error_handler .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { - oneapi::mkl::vm::error_handler create_error_handler( - oneapi::mkl::vm::status* status_array, + oneapi::math::vm::error_handler create_error_handler( + oneapi::math::vm::status* status_array, int64_t length = 1, - oneapi::mkl::vm::status status = oneapi::mkl::vm::status::not_defined, + oneapi::math::vm::status status = oneapi::math::vm::status::not_defined, T fixup = {}, bool copysign = false); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm ``create_error_handler`` supports the following precisions. @@ -129,26 +129,26 @@ create_error_handler - Description * - Successful Execution - - * - ``oneapi::mkl::vm::status::success`` + * - ``oneapi::math::vm::status::success`` - VM function execution completed successfully - * - ``oneapi::mkl::vm::status::not_defined`` + * - ``oneapi::math::vm::status::not_defined`` - VM status not defined * - Warnings - - * - ``oneapi::mkl::vm::status::accuracy_warning`` + * - ``oneapi::math::vm::status::accuracy_warning`` - VM function execution completed successfully in a different accuracy mode * - Computational Errors - - * - ``oneapi::mkl::vm::status::errdom`` + * - ``oneapi::math::vm::status::errdom`` - Values are out of a range of definition producing invalid (QNaN) result - * - ``oneapi::mkl::vm::status::sing`` + * - ``oneapi::math::vm::status::sing`` - Values cause divide-by-zero (singularity) computational errors and produce and invalid (QNaN or Inf) result - * - ``oneapi::mkl::vm::status::overflow`` + * - ``oneapi::math::vm::status::overflow`` - An overflow happened during the calculation process - * - ``oneapi::mkl::vm::status::underflow`` + * - ``oneapi::math::vm::status::underflow`` - An underflow happened during the calculation process @@ -185,7 +185,7 @@ create_error_handler status_code Status code to match and fix the results. This is an optional argument, - default value is ``oneapi::mkl::vm::status::not_defined``. + default value is ``oneapi::math::vm::status::not_defined``. fixup @@ -215,4 +215,4 @@ create_error_handler .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_service_functions` + **Parent topic:** :ref:`onemath_vm_service_functions` diff --git a/source/elements/oneMKL/source/domains/vm/div.rst b/source/elements/oneMath/source/domains/vm/div.rst similarity index 78% rename from source/elements/oneMKL/source/domains/vm/div.rst rename to source/elements/oneMath/source/domains/vm/div.rst index 137b75742e..9ca75a13b6 100644 --- a/source/elements/oneMKL/source/domains/vm/div.rst +++ b/source/elements/oneMath/source/domains/vm/div.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_div: +.. _onemath_vm_div: div === @@ -27,7 +27,7 @@ div .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event div( sycl::queue& exec_queue, @@ -35,10 +35,10 @@ div sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ div .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event div( sycl::queue& exec_queue, @@ -57,10 +57,10 @@ div const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -103,27 +103,27 @@ div * - X > +0 - +0 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - X > +0 - -0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - X < +0 - +0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - X < +0 - -0 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - +0 - +0 - QNAN - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -0 - -0 - QNAN - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - X > +0 - +∞ - +0 @@ -163,7 +163,7 @@ div x1, x2, y1, y2 are finite numbers, but the real or imaginary part of the exact result is so large that it does not fit the target precision. In that case, the function returns ∞ in that part of the - result, and sets the VM status code to ``oneapi::mkl::vm::status::overflow``. + result, and sets the VM status code to ``oneapi::math::vm::status::overflow``. .. container:: section @@ -194,14 +194,14 @@ div mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -231,14 +231,14 @@ div mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -273,7 +273,7 @@ div .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -281,6 +281,6 @@ div .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/erf.rst b/source/elements/oneMath/source/domains/vm/erf.rst similarity index 86% rename from source/elements/oneMKL/source/domains/vm/erf.rst rename to source/elements/oneMath/source/domains/vm/erf.rst index 6f039e430c..5a969d7a72 100644 --- a/source/elements/oneMKL/source/domains/vm/erf.rst +++ b/source/elements/oneMath/source/domains/vm/erf.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_erf: +.. _onemath_vm_erf: erf === @@ -27,16 +27,16 @@ erf .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event erf( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -46,7 +46,7 @@ erf .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event erf( sycl::queue& exec_queue, @@ -54,9 +54,9 @@ erf const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -206,9 +206,9 @@ erf mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -232,9 +232,9 @@ erf mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -267,7 +267,7 @@ erf .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -275,7 +275,7 @@ erf .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/erfc.rst b/source/elements/oneMath/source/domains/vm/erfc.rst similarity index 83% rename from source/elements/oneMKL/source/domains/vm/erfc.rst rename to source/elements/oneMath/source/domains/vm/erfc.rst index 1cd4f55eaf..8607c65ccc 100644 --- a/source/elements/oneMKL/source/domains/vm/erfc.rst +++ b/source/elements/oneMath/source/domains/vm/erfc.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_erfc: +.. _onemath_vm_erfc: erfc ==== @@ -27,17 +27,17 @@ erfc .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event erfc( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ erfc .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event erfc( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ erfc const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -173,7 +173,7 @@ erfc - Status code * - a > underflow - +0 - - ``oneapi::mkl::vm::status::underflow`` + - ``oneapi::math::vm::status::underflow`` * - +∞ - +0 -   @@ -214,14 +214,14 @@ erfc mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -247,14 +247,14 @@ erfc mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -289,7 +289,7 @@ erfc .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -297,7 +297,7 @@ erfc .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/erfcinv.rst b/source/elements/oneMath/source/domains/vm/erfcinv.rst similarity index 79% rename from source/elements/oneMKL/source/domains/vm/erfcinv.rst rename to source/elements/oneMath/source/domains/vm/erfcinv.rst index 0f238a5e7b..c60b321516 100644 --- a/source/elements/oneMKL/source/domains/vm/erfcinv.rst +++ b/source/elements/oneMath/source/domains/vm/erfcinv.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_erfcinv: +.. _onemath_vm_erfcinv: erfcinv ======= @@ -28,17 +28,17 @@ erfcinv .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event erfcinv( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ erfcinv .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event erfcinv( sycl::queue& exec_queue, @@ -56,10 +56,10 @@ erfcinv const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -146,25 +146,25 @@ erfcinv -   * - +2 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -0 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - +0 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - a < -0 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - a > +2 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -199,14 +199,14 @@ erfcinv mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -232,14 +232,14 @@ erfcinv mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -274,7 +274,7 @@ erfcinv .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -282,7 +282,7 @@ erfcinv .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/erfinv.rst b/source/elements/oneMath/source/domains/vm/erfinv.rst similarity index 81% rename from source/elements/oneMKL/source/domains/vm/erfinv.rst rename to source/elements/oneMath/source/domains/vm/erfinv.rst index 80051126df..d081605824 100644 --- a/source/elements/oneMKL/source/domains/vm/erfinv.rst +++ b/source/elements/oneMath/source/domains/vm/erfinv.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_erfinv: +.. _onemath_vm_erfinv: erfinv ====== @@ -27,17 +27,17 @@ erfinv .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event erfinv( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ erfinv .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event erfinv( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ erfinv const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -167,19 +167,19 @@ erfinv -   * - +1 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -1 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - \|a\| > 1 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -214,14 +214,14 @@ erfinv mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -247,14 +247,14 @@ erfinv mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -289,7 +289,7 @@ erfinv .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -297,7 +297,7 @@ erfinv .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/exp.rst b/source/elements/oneMath/source/domains/vm/exp.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/exp.rst rename to source/elements/oneMath/source/domains/vm/exp.rst index 604bc987f2..cf82176e98 100644 --- a/source/elements/oneMKL/source/domains/vm/exp.rst +++ b/source/elements/oneMath/source/domains/vm/exp.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_exp: +.. _onemath_vm_exp: exp === @@ -27,17 +27,17 @@ exp .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event exp( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ exp .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event exp( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ exp const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -120,10 +120,10 @@ exp -   * - a > overflow - +∞ - - ``oneapi::mkl::vm::status::overflow`` + - ``oneapi::math::vm::status::overflow`` * - a < underflow - +0 - - ``oneapi::mkl::vm::status::overflow`` + - ``oneapi::math::vm::status::overflow`` * - +∞ - +∞ -   @@ -218,7 +218,7 @@ exp - The complex exp(z) function sets the VM status code to - ``oneapi::mkl::vm::status::overflow`` in the case of overflow, + ``oneapi::math::vm::status::overflow`` in the case of overflow, that is, when both ``RE(z)`` and ``IM(z)`` are finite non-zero numbers, but the real or imaginary part of the exact result is so large that it does not meet the target precision. @@ -249,14 +249,14 @@ exp mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -282,14 +282,14 @@ exp mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -324,7 +324,7 @@ exp .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -332,6 +332,6 @@ exp .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/exp10.rst b/source/elements/oneMath/source/domains/vm/exp10.rst similarity index 79% rename from source/elements/oneMKL/source/domains/vm/exp10.rst rename to source/elements/oneMath/source/domains/vm/exp10.rst index 059e76349c..fb85530fff 100644 --- a/source/elements/oneMKL/source/domains/vm/exp10.rst +++ b/source/elements/oneMath/source/domains/vm/exp10.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_exp10: +.. _onemath_vm_exp10: exp10 ===== @@ -27,17 +27,17 @@ exp10 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event exp10( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ exp10 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event exp10( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ exp10 const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -119,10 +119,10 @@ exp10 -   * - ``a`` > overflow - +∞ - - ``oneapi::mkl::vm::status::overflow`` + - ``oneapi::math::vm::status::overflow`` * - ``a`` < underflow - +0 - - ``oneapi::mkl::vm::status::underflow`` + - ``oneapi::math::vm::status::underflow`` * - +∞ - +∞ -   @@ -163,14 +163,14 @@ exp10 mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -196,14 +196,14 @@ exp10 mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -238,7 +238,7 @@ exp10 .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -246,6 +246,6 @@ exp10 .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/exp2.rst b/source/elements/oneMath/source/domains/vm/exp2.rst similarity index 79% rename from source/elements/oneMKL/source/domains/vm/exp2.rst rename to source/elements/oneMath/source/domains/vm/exp2.rst index 69ebce5401..4f37237e34 100644 --- a/source/elements/oneMKL/source/domains/vm/exp2.rst +++ b/source/elements/oneMath/source/domains/vm/exp2.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_exp2: +.. _onemath_vm_exp2: exp2 ==== @@ -27,17 +27,17 @@ exp2 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event exp2( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ exp2 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event exp2( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ exp2 const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -118,10 +118,10 @@ exp2 -   * - ``a`` > overflow - +∞ - - ``oneapi::mkl::vm::status::overflow`` + - ``oneapi::math::vm::status::overflow`` * - ``a`` < underflow - +0 - - ``oneapi::mkl::vm::status::underflow`` + - ``oneapi::math::vm::status::underflow`` * - +∞ - +∞ -   @@ -162,14 +162,14 @@ exp2 mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -195,14 +195,14 @@ exp2 mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -237,7 +237,7 @@ exp2 .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -245,6 +245,6 @@ exp2 .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/expint1.rst b/source/elements/oneMath/source/domains/vm/expint1.rst similarity index 77% rename from source/elements/oneMKL/source/domains/vm/expint1.rst rename to source/elements/oneMath/source/domains/vm/expint1.rst index 67eb7a6f1a..33061ce484 100644 --- a/source/elements/oneMKL/source/domains/vm/expint1.rst +++ b/source/elements/oneMath/source/domains/vm/expint1.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_expint1: +.. _onemath_vm_expint1: expint1 ======= @@ -27,17 +27,17 @@ expint1 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event expint1( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ expint1 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event expint1( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ expint1 const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -109,19 +109,19 @@ expint1 - Status code * - ``x`` < +0 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +0 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -0 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - +∞ - +0 -   * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -156,14 +156,14 @@ expint1 mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -189,14 +189,14 @@ expint1 mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -231,7 +231,7 @@ expint1 .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -239,4 +239,4 @@ expint1 .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/expm1.rst b/source/elements/oneMath/source/domains/vm/expm1.rst similarity index 79% rename from source/elements/oneMKL/source/domains/vm/expm1.rst rename to source/elements/oneMath/source/domains/vm/expm1.rst index 8ab133b6e5..4355fe1815 100644 --- a/source/elements/oneMKL/source/domains/vm/expm1.rst +++ b/source/elements/oneMath/source/domains/vm/expm1.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_expm1: +.. _onemath_vm_expm1: expm1 ===== @@ -28,17 +28,17 @@ expm1 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event expm1( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ expm1 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event expm1( sycl::queue& exec_queue, @@ -56,10 +56,10 @@ expm1 const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -104,7 +104,7 @@ expm1 -   * - a > overflow - +∞ - - ``oneapi::mkl::vm::status::overflow`` + - ``oneapi::math::vm::status::overflow`` * - +∞ - +∞ -   @@ -161,14 +161,14 @@ expm1 mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -194,14 +194,14 @@ expm1 mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -236,7 +236,7 @@ expm1 .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -244,5 +244,5 @@ expm1 .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/fdim.rst b/source/elements/oneMath/source/domains/vm/fdim.rst similarity index 83% rename from source/elements/oneMKL/source/domains/vm/fdim.rst rename to source/elements/oneMath/source/domains/vm/fdim.rst index ad4fb2f6bd..9377e3bdc3 100644 --- a/source/elements/oneMKL/source/domains/vm/fdim.rst +++ b/source/elements/oneMath/source/domains/vm/fdim.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_fdim: +.. _onemath_vm_fdim: fdim ==== @@ -29,7 +29,7 @@ fdim .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event fdim( sycl::queue& exec_queue, @@ -37,9 +37,9 @@ fdim sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -49,7 +49,7 @@ fdim .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event fdim( sycl::queue& exec_queue, @@ -58,9 +58,9 @@ fdim const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -150,9 +150,9 @@ fdim mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -180,9 +180,9 @@ fdim mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -215,7 +215,7 @@ fdim .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -223,6 +223,6 @@ fdim .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/floor.rst b/source/elements/oneMath/source/domains/vm/floor.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/floor.rst rename to source/elements/oneMath/source/domains/vm/floor.rst index 438dd5e672..a20982fc8d 100644 --- a/source/elements/oneMKL/source/domains/vm/floor.rst +++ b/source/elements/oneMath/source/domains/vm/floor.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_floor: +.. _onemath_vm_floor: floor ===== @@ -28,16 +28,16 @@ floor .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event floor( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ floor .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event floor( sycl::queue& exec_queue, @@ -55,9 +55,9 @@ floor const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -147,9 +147,9 @@ floor mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -173,9 +173,9 @@ floor mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -208,7 +208,7 @@ floor .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -216,4 +216,4 @@ floor .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/fmax.rst b/source/elements/oneMath/source/domains/vm/fmax.rst similarity index 83% rename from source/elements/oneMKL/source/domains/vm/fmax.rst rename to source/elements/oneMath/source/domains/vm/fmax.rst index ad27e7828e..2aced6de10 100644 --- a/source/elements/oneMKL/source/domains/vm/fmax.rst +++ b/source/elements/oneMath/source/domains/vm/fmax.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_fmax: +.. _onemath_vm_fmax: fmax ==== @@ -28,7 +28,7 @@ fmax .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event fmax( sycl::queue& exec_queue, @@ -36,9 +36,9 @@ fmax sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ fmax .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event fmax( sycl::queue& exec_queue, @@ -57,9 +57,9 @@ fmax const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -146,9 +146,9 @@ fmax mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -176,9 +176,9 @@ fmax mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -211,7 +211,7 @@ fmax .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -219,6 +219,6 @@ fmax .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/fmin.rst b/source/elements/oneMath/source/domains/vm/fmin.rst similarity index 83% rename from source/elements/oneMKL/source/domains/vm/fmin.rst rename to source/elements/oneMath/source/domains/vm/fmin.rst index e31e197ca8..f3c9e28907 100644 --- a/source/elements/oneMKL/source/domains/vm/fmin.rst +++ b/source/elements/oneMath/source/domains/vm/fmin.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_fmin: +.. _onemath_vm_fmin: fmin ==== @@ -28,7 +28,7 @@ fmin .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event fmin( sycl::queue& exec_queue, @@ -36,9 +36,9 @@ fmin sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ fmin .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event fmin( sycl::queue& exec_queue, @@ -57,9 +57,9 @@ fmin const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -146,9 +146,9 @@ fmin mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -176,9 +176,9 @@ fmin mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -211,7 +211,7 @@ fmin .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -219,6 +219,6 @@ fmin .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/fmod.rst b/source/elements/oneMath/source/domains/vm/fmod.rst similarity index 80% rename from source/elements/oneMKL/source/domains/vm/fmod.rst rename to source/elements/oneMath/source/domains/vm/fmod.rst index 238f068ce3..31a2906976 100644 --- a/source/elements/oneMKL/source/domains/vm/fmod.rst +++ b/source/elements/oneMath/source/domains/vm/fmod.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_fmod: +.. _onemath_vm_fmod: fmod ==== @@ -28,7 +28,7 @@ fmod .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event fmod( sycl::queue& exec_queue, @@ -36,10 +36,10 @@ fmod sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -49,7 +49,7 @@ fmod .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event fmod( sycl::queue& exec_queue, @@ -58,10 +58,10 @@ fmod const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -112,11 +112,11 @@ fmod * - ``a`` not NAN - ±0 - NAN - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - ±∞ - ``b`` not NAN - NAN - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - ±0 - ``b``\ ≠ 0, not NAN - ±0 @@ -165,14 +165,14 @@ fmod mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -202,14 +202,14 @@ fmod mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -244,7 +244,7 @@ fmod .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -252,6 +252,6 @@ fmod .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/frac.rst b/source/elements/oneMath/source/domains/vm/frac.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/frac.rst rename to source/elements/oneMath/source/domains/vm/frac.rst index 118a0b7d95..bf735dcb40 100644 --- a/source/elements/oneMKL/source/domains/vm/frac.rst +++ b/source/elements/oneMath/source/domains/vm/frac.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_frac: +.. _onemath_vm_frac: frac ==== @@ -27,16 +27,16 @@ frac .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event frac( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -46,7 +46,7 @@ frac .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event frac( sycl::queue& exec_queue, @@ -54,9 +54,9 @@ frac const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -149,9 +149,9 @@ frac mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -175,9 +175,9 @@ frac mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -210,7 +210,7 @@ frac .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -218,4 +218,4 @@ frac .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/get_mode.rst b/source/elements/oneMath/source/domains/vm/get_mode.rst similarity index 74% rename from source/elements/oneMKL/source/domains/vm/get_mode.rst rename to source/elements/oneMath/source/domains/vm/get_mode.rst index 497e434410..be8fdc64a4 100644 --- a/source/elements/oneMKL/source/domains/vm/get_mode.rst +++ b/source/elements/oneMath/source/domains/vm/get_mode.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_get_mode: +.. _onemath_vm_get_mode: get_mode ======== @@ -23,12 +23,12 @@ get_mode .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { - oneapi::mkl::vm::mode get_mode( + oneapi::math::vm::mode get_mode( sycl::queue& exec_queue); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,16 +47,16 @@ get_mode - Description * - Accuracy Control - - * - ``oneapi::mkl::vm::mode::ha`` + * - ``oneapi::math::vm::mode::ha`` - High accuracy versions of VM functions. - * - ``oneapi::mkl::vm::mode::la`` + * - ``oneapi::math::vm::mode::la`` - Low accuracy versions of VM functions. - * - ``oneapi::mkl::vm::mode::ep`` + * - ``oneapi::math::vm::mode::ep`` - Enhanced performance accuracy versions of VM functions. - * - ``oneapi::mkl::vm::mode::not_defined`` + * - ``oneapi::math::vm::mode::not_defined`` - VM mode not defined. It means that no special provisions for accuracy have been made for this queue. - See :ref:`onemkl_vm_setmode` for details. + See :ref:`onemath_vm_setmode` for details. .. container:: section @@ -86,4 +86,4 @@ get_mode .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_service_functions` + **Parent topic:** :ref:`onemath_vm_service_functions` diff --git a/source/elements/oneMKL/source/domains/vm/get_status.rst b/source/elements/oneMath/source/domains/vm/get_status.rst similarity index 75% rename from source/elements/oneMKL/source/domains/vm/get_status.rst rename to source/elements/oneMath/source/domains/vm/get_status.rst index b95c928e33..c4670cde18 100644 --- a/source/elements/oneMKL/source/domains/vm/get_status.rst +++ b/source/elements/oneMath/source/domains/vm/get_status.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_get_status: +.. _onemath_vm_get_status: get_status ========== @@ -24,12 +24,12 @@ get_status .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { - oneapi::mkl::vm::status get_status( + oneapi::math::vm::status get_status( sycl::queue& exec_queue); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -53,23 +53,23 @@ get_status - Description * - Successful Execution - - * - ``oneapi::mkl::vm::status::success`` + * - ``oneapi::math::vm::status::success`` - VM function execution completed successfully - * - ``oneapi::mkl::vm::status::not_defined`` + * - ``oneapi::math::vm::status::not_defined`` - VM status not defined * - Warnings - - * - ``oneapi::mkl::vm::status::accuracy_warning`` + * - ``oneapi::math::vm::status::accuracy_warning`` - VM function execution completed successfully in a different accuracy mode * - Computational status codes - - * - ``oneapi::mkl::vm::status::errdom`` + * - ``oneapi::math::vm::status::errdom`` - Values are out of a range of definition producing invalid (QNaN) result - * - ``oneapi::mkl::vm::status::sing`` + * - ``oneapi::math::vm::status::sing`` - Values cause divide-by-zero (singularity) computational errors and produce and invalid (QNaN or Inf) result - * - ``oneapi::mkl::vm::status::overflow`` + * - ``oneapi::math::vm::status::overflow`` - An overflow happened during the calculation process - * - ``oneapi::mkl::vm::status::underflow`` + * - ``oneapi::math::vm::status::underflow`` - An underflow happened during the calculation process @@ -102,6 +102,6 @@ get_status .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_service_functions` + **Parent topic:** :ref:`onemath_vm_service_functions` diff --git a/source/elements/oneMKL/source/domains/vm/hypot.rst b/source/elements/oneMath/source/domains/vm/hypot.rst similarity index 85% rename from source/elements/oneMKL/source/domains/vm/hypot.rst rename to source/elements/oneMath/source/domains/vm/hypot.rst index 6b204b006f..9f7532bf0f 100644 --- a/source/elements/oneMKL/source/domains/vm/hypot.rst +++ b/source/elements/oneMath/source/domains/vm/hypot.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_hypot: +.. _onemath_vm_hypot: hypot ===== @@ -27,7 +27,7 @@ hypot .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event hypot( sycl::queue& exec_queue, @@ -35,9 +35,9 @@ hypot sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ hypot .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event hypot( sycl::queue& exec_queue, @@ -56,9 +56,9 @@ hypot const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -179,9 +179,9 @@ hypot mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -209,9 +209,9 @@ hypot mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -244,7 +244,7 @@ hypot .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -252,6 +252,6 @@ hypot .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/inv.rst b/source/elements/oneMath/source/domains/vm/inv.rst similarity index 77% rename from source/elements/oneMKL/source/domains/vm/inv.rst rename to source/elements/oneMath/source/domains/vm/inv.rst index 26f98c9ad6..101bcca197 100644 --- a/source/elements/oneMKL/source/domains/vm/inv.rst +++ b/source/elements/oneMath/source/domains/vm/inv.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_inv: +.. _onemath_vm_inv: inv === @@ -27,17 +27,17 @@ inv .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event inv( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ inv .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event inv( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ inv const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -97,10 +97,10 @@ inv - VM status code * - +0 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - +∞ - +0 -   @@ -141,14 +141,14 @@ inv mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -174,14 +174,14 @@ inv mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -216,7 +216,7 @@ inv .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -224,6 +224,6 @@ inv .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/invcbrt.rst b/source/elements/oneMath/source/domains/vm/invcbrt.rst similarity index 77% rename from source/elements/oneMKL/source/domains/vm/invcbrt.rst rename to source/elements/oneMath/source/domains/vm/invcbrt.rst index c3e90b4a2e..d5b33f5a22 100644 --- a/source/elements/oneMKL/source/domains/vm/invcbrt.rst +++ b/source/elements/oneMath/source/domains/vm/invcbrt.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_invcbrt: +.. _onemath_vm_invcbrt: invcbrt ======= @@ -27,17 +27,17 @@ invcbrt .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event invcbrt( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ invcbrt .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event invcbrt( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ invcbrt const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -97,10 +97,10 @@ invcbrt - Status code * - +0 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - +∞ - +0 -   @@ -141,14 +141,14 @@ invcbrt mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -174,14 +174,14 @@ invcbrt mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -216,7 +216,7 @@ invcbrt .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -224,6 +224,6 @@ invcbrt .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/invsqrt.rst b/source/elements/oneMath/source/domains/vm/invsqrt.rst similarity index 75% rename from source/elements/oneMKL/source/domains/vm/invsqrt.rst rename to source/elements/oneMath/source/domains/vm/invsqrt.rst index 8a98352007..80910c1bfb 100644 --- a/source/elements/oneMKL/source/domains/vm/invsqrt.rst +++ b/source/elements/oneMath/source/domains/vm/invsqrt.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_invsqrt: +.. _onemath_vm_invsqrt: invsqrt ======= @@ -27,17 +27,17 @@ invsqrt .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event invsqrt( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ invsqrt .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event invsqrt( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ invsqrt const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -97,16 +97,16 @@ invsqrt - VM status code * - a < +0 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +0 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - +0 -   @@ -144,14 +144,14 @@ invsqrt mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -177,14 +177,14 @@ invsqrt mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -219,7 +219,7 @@ invsqrt .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -227,6 +227,6 @@ invsqrt .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/lgamma.rst b/source/elements/oneMath/source/domains/vm/lgamma.rst similarity index 77% rename from source/elements/oneMKL/source/domains/vm/lgamma.rst rename to source/elements/oneMath/source/domains/vm/lgamma.rst index 6bbaae482c..092f017b04 100644 --- a/source/elements/oneMKL/source/domains/vm/lgamma.rst +++ b/source/elements/oneMath/source/domains/vm/lgamma.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_lgamma: +.. _onemath_vm_lgamma: lgamma ====== @@ -28,17 +28,17 @@ lgamma .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event lgamma( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ lgamma .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event lgamma( sycl::queue& exec_queue, @@ -56,10 +56,10 @@ lgamma const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -88,7 +88,7 @@ lgamma writes them to the output vector ``y``. Precision overflow thresholds for the lgamma function are beyond the scope of this document. If the result does not meet the target precision, the function sets the VM - status code to ``oneapi::mkl::vm::status::overflow``. + status code to ``oneapi::math::vm::status::overflow``. .. container:: tablenoborder @@ -108,13 +108,13 @@ lgamma -   * - +0 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -0 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - negative integer - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -∞ - +∞ -   @@ -123,7 +123,7 @@ lgamma -   * - a > overflow - +∞ - - ``oneapi::mkl::vm::status::overflow`` + - ``oneapi::math::vm::status::overflow`` * - QNAN - QNAN -   @@ -158,14 +158,14 @@ lgamma mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -191,14 +191,14 @@ lgamma mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -233,7 +233,7 @@ lgamma .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -241,6 +241,6 @@ lgamma .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/linearfrac.rst b/source/elements/oneMath/source/domains/vm/linearfrac.rst similarity index 84% rename from source/elements/oneMKL/source/domains/vm/linearfrac.rst rename to source/elements/oneMath/source/domains/vm/linearfrac.rst index cc2f32aa5e..2458c6efcb 100644 --- a/source/elements/oneMKL/source/domains/vm/linearfrac.rst +++ b/source/elements/oneMath/source/domains/vm/linearfrac.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_linearfrac: +.. _onemath_vm_linearfrac: linearfrac ========== @@ -28,7 +28,7 @@ linearfrac .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event linearfrac( sycl::queue& exec_queue, @@ -40,10 +40,10 @@ linearfrac T scaleb, T shiftb, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -53,7 +53,7 @@ linearfrac .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event linearfrac( sycl::queue& exec_queue, @@ -66,10 +66,10 @@ linearfrac T shiftb, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -105,7 +105,7 @@ linearfrac The linearfrac function is implemented in the EP accuracy mode only, therefore no special values are defined for this function. If used in HA or LA mode, linearfrac sets the VM status code to - ``oneapi::mkl::vm::status::accuracy_warning``. Correctness is guaranteed within the + ``oneapi::math::vm::status::accuracy_warning``. Correctness is guaranteed within the threshold limitations defined for each input parameter (see the table below); otherwise, the behavior is unspecified. @@ -136,7 +136,7 @@ linearfrac ``EMIN``\ and ``EMAX`` are the minimum and maximum exponents and ``p`` is the number of significant bits (precision) for the corresponding data type according to the ANSI/IEEE Standard 754-2008 - ([:ref:`onemkl_vm_bibliography`]): + ([:ref:`onemath_vm_bibliography`]): - for single precision\ ``EMIN`` = -126, ``EMAX`` = 127, ``p`` = 24 @@ -202,14 +202,14 @@ linearfrac mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -255,14 +255,14 @@ linearfrac mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -297,7 +297,7 @@ linearfrac .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -305,6 +305,6 @@ linearfrac .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/ln.rst b/source/elements/oneMath/source/domains/vm/ln.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/ln.rst rename to source/elements/oneMath/source/domains/vm/ln.rst index f8ebb88153..185be638ef 100644 --- a/source/elements/oneMKL/source/domains/vm/ln.rst +++ b/source/elements/oneMath/source/domains/vm/ln.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_ln: +.. _onemath_vm_ln: ln == @@ -27,17 +27,17 @@ ln .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event ln( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ ln .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event ln( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ ln const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -101,16 +101,16 @@ ln -   * - a <+0 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - +∞ -   @@ -222,14 +222,14 @@ ln mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -255,14 +255,14 @@ ln mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -297,7 +297,7 @@ ln .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -305,4 +305,4 @@ ln .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/log10.rst b/source/elements/oneMath/source/domains/vm/log10.rst similarity index 83% rename from source/elements/oneMKL/source/domains/vm/log10.rst rename to source/elements/oneMath/source/domains/vm/log10.rst index 79e8588c72..4e5a40fd7a 100644 --- a/source/elements/oneMKL/source/domains/vm/log10.rst +++ b/source/elements/oneMath/source/domains/vm/log10.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_log10: +.. _onemath_vm_log10: log10 ===== @@ -27,17 +27,17 @@ log10 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event log10( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ log10 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event log10( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ log10 const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -102,16 +102,16 @@ log10 -   * - a <+0 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - +∞ -   @@ -223,14 +223,14 @@ log10 mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -256,14 +256,14 @@ log10 mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -298,7 +298,7 @@ log10 .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -306,7 +306,7 @@ log10 .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/log1p.rst b/source/elements/oneMath/source/domains/vm/log1p.rst similarity index 77% rename from source/elements/oneMKL/source/domains/vm/log1p.rst rename to source/elements/oneMath/source/domains/vm/log1p.rst index 67c9208ab2..ea6cdbbc94 100644 --- a/source/elements/oneMKL/source/domains/vm/log1p.rst +++ b/source/elements/oneMath/source/domains/vm/log1p.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_log1p: +.. _onemath_vm_log1p: log1p ===== @@ -28,17 +28,17 @@ log1p .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event log1p( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ log1p .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event log1p( sycl::queue& exec_queue, @@ -56,10 +56,10 @@ log1p const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -98,10 +98,10 @@ log1p - VM status code * - -1 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - a <-1 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +0 - +0 -   @@ -110,7 +110,7 @@ log1p -   * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - +∞ -   @@ -148,14 +148,14 @@ log1p mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -181,14 +181,14 @@ log1p mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -223,7 +223,7 @@ log1p .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -231,6 +231,6 @@ log1p .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/log2.rst b/source/elements/oneMath/source/domains/vm/log2.rst similarity index 75% rename from source/elements/oneMKL/source/domains/vm/log2.rst rename to source/elements/oneMath/source/domains/vm/log2.rst index 21d365675c..45581ff967 100644 --- a/source/elements/oneMKL/source/domains/vm/log2.rst +++ b/source/elements/oneMath/source/domains/vm/log2.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_log2: +.. _onemath_vm_log2: log2 ==== @@ -27,17 +27,17 @@ log2 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event log2( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ log2 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event log2( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ log2 const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -100,16 +100,16 @@ log2 -   * - ``a`` < +0 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - +∞ -   @@ -147,14 +147,14 @@ log2 mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -180,14 +180,14 @@ log2 mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -222,7 +222,7 @@ log2 .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -230,6 +230,6 @@ log2 .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/logb.rst b/source/elements/oneMath/source/domains/vm/logb.rst similarity index 78% rename from source/elements/oneMKL/source/domains/vm/logb.rst rename to source/elements/oneMath/source/domains/vm/logb.rst index be2c6e7171..2c4139d505 100644 --- a/source/elements/oneMKL/source/domains/vm/logb.rst +++ b/source/elements/oneMath/source/domains/vm/logb.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_logb: +.. _onemath_vm_logb: logb ==== @@ -27,17 +27,17 @@ logb .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event logb( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ logb .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event logb( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ logb const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -100,10 +100,10 @@ logb - VM status code * - +0 - +∞ - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -0 - -∞ - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - +∞ -   @@ -144,14 +144,14 @@ logb mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -177,14 +177,14 @@ logb mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -219,7 +219,7 @@ logb .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -227,6 +227,6 @@ logb .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/maxmag.rst b/source/elements/oneMath/source/domains/vm/maxmag.rst similarity index 84% rename from source/elements/oneMKL/source/domains/vm/maxmag.rst rename to source/elements/oneMath/source/domains/vm/maxmag.rst index 71ff771b67..d1008ba674 100644 --- a/source/elements/oneMKL/source/domains/vm/maxmag.rst +++ b/source/elements/oneMath/source/domains/vm/maxmag.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_maxmag: +.. _onemath_vm_maxmag: maxmag ====== @@ -28,7 +28,7 @@ maxmag .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event maxmag( sycl::queue& exec_queue, @@ -36,9 +36,9 @@ maxmag sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ maxmag .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event maxmag( sycl::queue& exec_queue, @@ -57,9 +57,9 @@ maxmag const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -156,9 +156,9 @@ maxmag mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -186,9 +186,9 @@ maxmag mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -221,7 +221,7 @@ maxmag .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -229,6 +229,6 @@ maxmag .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/minmag.rst b/source/elements/oneMath/source/domains/vm/minmag.rst similarity index 84% rename from source/elements/oneMKL/source/domains/vm/minmag.rst rename to source/elements/oneMath/source/domains/vm/minmag.rst index 9e7325bbd6..50ce8258f2 100644 --- a/source/elements/oneMKL/source/domains/vm/minmag.rst +++ b/source/elements/oneMath/source/domains/vm/minmag.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_minmag: +.. _onemath_vm_minmag: minmag ====== @@ -28,7 +28,7 @@ minmag .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event minmag( sycl::queue& exec_queue, @@ -36,9 +36,9 @@ minmag sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ minmag .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event minmag( sycl::queue& exec_queue, @@ -57,9 +57,9 @@ minmag const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -156,9 +156,9 @@ minmag mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -186,9 +186,9 @@ minmag mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -221,7 +221,7 @@ minmag .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -229,6 +229,6 @@ minmag .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/modf.rst b/source/elements/oneMath/source/domains/vm/modf.rst similarity index 84% rename from source/elements/oneMKL/source/domains/vm/modf.rst rename to source/elements/oneMath/source/domains/vm/modf.rst index 6990acb559..80bc5eec79 100644 --- a/source/elements/oneMKL/source/domains/vm/modf.rst +++ b/source/elements/oneMath/source/domains/vm/modf.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_modf: +.. _onemath_vm_modf: modf ==== @@ -28,7 +28,7 @@ modf .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event modf( sycl::queue& exec_queue, @@ -36,9 +36,9 @@ modf sycl::buffer& a, sycl::buffer& y, sycl::buffer& z, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ modf .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event modf( sycl::queue& exec_queue, @@ -57,9 +57,9 @@ modf T* y, T* z, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -166,9 +166,9 @@ modf mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -192,9 +192,9 @@ modf mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -239,7 +239,7 @@ modf .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -247,4 +247,4 @@ modf .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/mul.rst b/source/elements/oneMath/source/domains/vm/mul.rst similarity index 83% rename from source/elements/oneMKL/source/domains/vm/mul.rst rename to source/elements/oneMath/source/domains/vm/mul.rst index 40e8859900..fcd7cce4a3 100644 --- a/source/elements/oneMKL/source/domains/vm/mul.rst +++ b/source/elements/oneMath/source/domains/vm/mul.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_mul: +.. _onemath_vm_mul: mul === @@ -28,7 +28,7 @@ mul .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event mul( sycl::queue& exec_queue, @@ -36,10 +36,10 @@ mul sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -49,7 +49,7 @@ mul .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event mul( sycl::queue& exec_queue, @@ -58,10 +58,10 @@ mul const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -197,8 +197,8 @@ mul are finite numbers, but the real or imaginary part of the computed result is so large that it does not fit the target precision. In this case, the function returns ∞ in that part of the result, and sets the - VM status code to ``oneapi::mkl::vm::status::overflow`` (overriding any possible - ``oneapi::mkl::vm::status::accuracy_warning`` status). + VM status code to ``oneapi::math::vm::status::overflow`` (overriding any possible + ``oneapi::math::vm::status::accuracy_warning`` status). .. container:: section @@ -229,14 +229,14 @@ mul mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -266,14 +266,14 @@ mul mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -308,7 +308,7 @@ mul .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -316,6 +316,6 @@ mul .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/mulbyconj.rst b/source/elements/oneMath/source/domains/vm/mulbyconj.rst similarity index 77% rename from source/elements/oneMKL/source/domains/vm/mulbyconj.rst rename to source/elements/oneMath/source/domains/vm/mulbyconj.rst index 3cc0609a8d..a58ce2a0c1 100644 --- a/source/elements/oneMKL/source/domains/vm/mulbyconj.rst +++ b/source/elements/oneMath/source/domains/vm/mulbyconj.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_mulbyconj: +.. _onemath_vm_mulbyconj: mulbyconj ========= @@ -28,7 +28,7 @@ mulbyconj .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event mulbyconj( sycl::queue& exec_queue, @@ -36,10 +36,10 @@ mulbyconj sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -49,7 +49,7 @@ mulbyconj .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event mulbyconj( sycl::queue& exec_queue, @@ -58,10 +58,10 @@ mulbyconj const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -106,14 +106,14 @@ mulbyconj mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -143,14 +143,14 @@ mulbyconj mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -185,7 +185,7 @@ mulbyconj .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -193,6 +193,6 @@ mulbyconj .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/nearbyint.rst b/source/elements/oneMath/source/domains/vm/nearbyint.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/nearbyint.rst rename to source/elements/oneMath/source/domains/vm/nearbyint.rst index 08b6e63b8c..e2a97592bf 100644 --- a/source/elements/oneMKL/source/domains/vm/nearbyint.rst +++ b/source/elements/oneMath/source/domains/vm/nearbyint.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_nearbyint: +.. _onemath_vm_nearbyint: nearbyint ========= @@ -28,16 +28,16 @@ nearbyint .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event nearbyint( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ nearbyint .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event nearbyint( sycl::queue& exec_queue, @@ -55,9 +55,9 @@ nearbyint const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -143,9 +143,9 @@ nearbyint mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -169,9 +169,9 @@ nearbyint mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -204,7 +204,7 @@ nearbyint .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -212,6 +212,6 @@ nearbyint .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/nextafter.rst b/source/elements/oneMath/source/domains/vm/nextafter.rst similarity index 79% rename from source/elements/oneMKL/source/domains/vm/nextafter.rst rename to source/elements/oneMath/source/domains/vm/nextafter.rst index 4c666ed6dd..b568b6b727 100644 --- a/source/elements/oneMKL/source/domains/vm/nextafter.rst +++ b/source/elements/oneMath/source/domains/vm/nextafter.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_nextafter: +.. _onemath_vm_nextafter: nextafter ========= @@ -30,7 +30,7 @@ nextafter .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event nextafter( sycl::queue& exec_queue, @@ -38,10 +38,10 @@ nextafter sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -51,7 +51,7 @@ nextafter .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event nextafter( sycl::queue& exec_queue, @@ -60,10 +60,10 @@ nextafter const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -102,9 +102,9 @@ nextafter * - Arguments/Results - Status code * - Input vector argument element is finite and the corresponding result vector element value is infinite - - ``oneapi::mkl::vm::status::overflow`` + - ``oneapi::math::vm::status::overflow`` * - Result vector element value is subnormal or zero, and different from the corresponding input vector argument element - - ``oneapi::mkl::vm::status::underflow`` + - ``oneapi::math::vm::status::underflow`` @@ -141,14 +141,14 @@ nextafter mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -178,14 +178,14 @@ nextafter mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -220,7 +220,7 @@ nextafter .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -229,6 +229,6 @@ nextafter .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/pow.rst b/source/elements/oneMath/source/domains/vm/pow.rst similarity index 83% rename from source/elements/oneMKL/source/domains/vm/pow.rst rename to source/elements/oneMath/source/domains/vm/pow.rst index bfede9029c..d98462f870 100644 --- a/source/elements/oneMKL/source/domains/vm/pow.rst +++ b/source/elements/oneMath/source/domains/vm/pow.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_pow: +.. _onemath_vm_pow: pow === @@ -27,7 +27,7 @@ pow .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event pow( sycl::queue& exec_queue, @@ -35,10 +35,10 @@ pow sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ pow .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event pow( sycl::queue& exec_queue, @@ -57,10 +57,10 @@ pow const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -112,27 +112,27 @@ pow * - +0 - neg. odd integer - +∞ - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -0 - neg. odd integer - -∞ - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +0 - neg. even integer - +∞ - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -0 - neg. even integer - +∞ - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +0 - neg. non-integer - +∞ - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -0 - neg. non-integer - +∞ - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -0 - pos. odd integer - +0 @@ -240,7 +240,7 @@ pow * - a < +0 - non-integer - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - \|a\| < 1 - -∞ - +∞ @@ -248,11 +248,11 @@ pow * - +0 - -∞ - +∞ - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -0 - -∞ - +∞ - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - \|a\| > 1 - -∞ - +0 @@ -324,7 +324,7 @@ pow * - Big finite value\* - Big finite value\* - +/-∞ - - ``oneapi::mkl::vm::status::overflow`` + - ``oneapi::math::vm::status::overflow`` * - QNAN - QNAN - QNAN @@ -354,7 +354,7 @@ pow #. Returns ∞ in the result. - #. Sets the VM status code to ``oneapi::mkl::vm::status::overflow``. + #. Sets the VM status code to ``oneapi::math::vm::status::overflow``. Overflow in a complex function occurs (supported in the HA/LA @@ -362,14 +362,14 @@ pow are finite numbers, but the real or imaginary part of the computed result is so large that it does not fit the target precision. In this case, the function returns ∞ in that part of the result, and sets the - VM status code to ``oneapi::mkl::vm::status::overflow`` (overriding any possible - ``oneapi::mkl::vm::status::accuracy_warning`` status). + VM status code to ``oneapi::math::vm::status::overflow`` (overriding any possible + ``oneapi::math::vm::status::accuracy_warning`` status). The complex double precision versions of this function are implemented in the EP accuracy mode only. If used in HA or LA mode, the functions set the VM status code to - ``oneapi::mkl::vm::status::accuracy_warning``. + ``oneapi::math::vm::status::accuracy_warning``. .. container:: section @@ -400,14 +400,14 @@ pow mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -437,14 +437,14 @@ pow mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -479,7 +479,7 @@ pow .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -487,6 +487,6 @@ pow .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/pow2o3.rst b/source/elements/oneMath/source/domains/vm/pow2o3.rst similarity index 81% rename from source/elements/oneMKL/source/domains/vm/pow2o3.rst rename to source/elements/oneMath/source/domains/vm/pow2o3.rst index 363f752448..bb335ff04e 100644 --- a/source/elements/oneMKL/source/domains/vm/pow2o3.rst +++ b/source/elements/oneMath/source/domains/vm/pow2o3.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_pow2o3: +.. _onemath_vm_pow2o3: pow2o3 ====== @@ -27,16 +27,16 @@ pow2o3 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event pow2o3( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -46,7 +46,7 @@ pow2o3 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event pow2o3( sycl::queue& exec_queue, @@ -54,9 +54,9 @@ pow2o3 const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -139,14 +139,14 @@ pow2o3 mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -172,14 +172,14 @@ pow2o3 mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -214,7 +214,7 @@ pow2o3 .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -222,6 +222,6 @@ pow2o3 .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/pow3o2.rst b/source/elements/oneMath/source/domains/vm/pow3o2.rst similarity index 79% rename from source/elements/oneMKL/source/domains/vm/pow3o2.rst rename to source/elements/oneMath/source/domains/vm/pow3o2.rst index 51f2413334..2f02f2b455 100644 --- a/source/elements/oneMKL/source/domains/vm/pow3o2.rst +++ b/source/elements/oneMath/source/domains/vm/pow3o2.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_pow3o2: +.. _onemath_vm_pow3o2: pow3o2 ====== @@ -27,17 +27,17 @@ pow3o2 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event pow3o2( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ pow3o2 .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event pow3o2( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ pow3o2 const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -113,7 +113,7 @@ pow3o2 - VM status code * - a < +0 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +0 - +0 -   @@ -122,7 +122,7 @@ pow3o2 -   * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - +∞ -   @@ -160,14 +160,14 @@ pow3o2 mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -193,14 +193,14 @@ pow3o2 mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -235,7 +235,7 @@ pow3o2 .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -243,6 +243,6 @@ pow3o2 .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/powr.rst b/source/elements/oneMath/source/domains/vm/powr.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/powr.rst rename to source/elements/oneMath/source/domains/vm/powr.rst index 0f483c1d1e..ecee06cd2b 100644 --- a/source/elements/oneMKL/source/domains/vm/powr.rst +++ b/source/elements/oneMath/source/domains/vm/powr.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_powr: +.. _onemath_vm_powr: powr ==== @@ -28,7 +28,7 @@ powr .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event powr( sycl::queue& exec_queue, @@ -36,10 +36,10 @@ powr sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -49,7 +49,7 @@ powr .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event powr( sycl::queue& exec_queue, @@ -58,10 +58,10 @@ powr const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -123,7 +123,7 @@ powr * - ``a`` < 0 - any value ``b`` - NAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - 0 < ``a`` < ∞ - ±0 - 1 @@ -191,19 +191,19 @@ powr * - QNAN - QNAN - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - SNAN - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - SNAN - QNAN - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - SNAN - SNAN - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` @@ -236,14 +236,14 @@ powr mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -273,14 +273,14 @@ powr mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -315,7 +315,7 @@ powr .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -324,6 +324,6 @@ powr .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/powx.rst b/source/elements/oneMath/source/domains/vm/powx.rst similarity index 79% rename from source/elements/oneMKL/source/domains/vm/powx.rst rename to source/elements/oneMath/source/domains/vm/powx.rst index c10486e15d..f3a7d35d89 100644 --- a/source/elements/oneMKL/source/domains/vm/powx.rst +++ b/source/elements/oneMath/source/domains/vm/powx.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_powx: +.. _onemath_vm_powx: powx ==== @@ -27,7 +27,7 @@ powx .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event powx( sycl::queue& exec_queue, @@ -35,10 +35,10 @@ powx sycl::buffer& a, T b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ powx .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event powx( sycl::queue& exec_queue, @@ -57,10 +57,10 @@ powx T b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -131,14 +131,14 @@ powx mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -168,14 +168,14 @@ powx mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -210,7 +210,7 @@ powx .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -219,4 +219,4 @@ powx .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/remainder.rst b/source/elements/oneMath/source/domains/vm/remainder.rst similarity index 81% rename from source/elements/oneMKL/source/domains/vm/remainder.rst rename to source/elements/oneMath/source/domains/vm/remainder.rst index cc0d459cbb..8fdfa93c72 100644 --- a/source/elements/oneMKL/source/domains/vm/remainder.rst +++ b/source/elements/oneMath/source/domains/vm/remainder.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_remainder: +.. _onemath_vm_remainder: remainder ========= @@ -29,7 +29,7 @@ remainder .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event remainder( sycl::queue& exec_queue, @@ -37,10 +37,10 @@ remainder sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -50,7 +50,7 @@ remainder .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event remainder( sycl::queue& exec_queue, @@ -59,10 +59,10 @@ remainder const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -113,7 +113,7 @@ remainder * - ``a`` not NAN - ±0 - NAN - - oneapi::mkl::vm::status::errdom + - oneapi::math::vm::status::errdom * - ±∞ - ``b`` not NAN - NAN @@ -166,14 +166,14 @@ remainder mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -203,14 +203,14 @@ remainder mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -245,7 +245,7 @@ remainder .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -253,6 +253,6 @@ remainder .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/rint.rst b/source/elements/oneMath/source/domains/vm/rint.rst similarity index 83% rename from source/elements/oneMKL/source/domains/vm/rint.rst rename to source/elements/oneMath/source/domains/vm/rint.rst index e9718dd5f6..b6c3b300a6 100644 --- a/source/elements/oneMKL/source/domains/vm/rint.rst +++ b/source/elements/oneMath/source/domains/vm/rint.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_rint: +.. _onemath_vm_rint: rint ==== @@ -27,16 +27,16 @@ rint .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event rint( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -46,7 +46,7 @@ rint .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event rint( sycl::queue& exec_queue, @@ -54,9 +54,9 @@ rint const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -161,9 +161,9 @@ rint mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -187,9 +187,9 @@ rint mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -222,7 +222,7 @@ rint .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -230,6 +230,6 @@ rint .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/round.rst b/source/elements/oneMath/source/domains/vm/round.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/round.rst rename to source/elements/oneMath/source/domains/vm/round.rst index 38df3fda39..6d4e7f862e 100644 --- a/source/elements/oneMKL/source/domains/vm/round.rst +++ b/source/elements/oneMath/source/domains/vm/round.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_round: +.. _onemath_vm_round: round ===== @@ -28,16 +28,16 @@ round .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event round( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ round .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event round( sycl::queue& exec_queue, @@ -55,9 +55,9 @@ round const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -145,9 +145,9 @@ round mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -171,9 +171,9 @@ round mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -206,7 +206,7 @@ round .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -214,6 +214,6 @@ round .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/set_status.rst b/source/elements/oneMath/source/domains/vm/set_status.rst similarity index 75% rename from source/elements/oneMKL/source/domains/vm/set_status.rst rename to source/elements/oneMath/source/domains/vm/set_status.rst index 98061201a5..069a91950b 100644 --- a/source/elements/oneMKL/source/domains/vm/set_status.rst +++ b/source/elements/oneMath/source/domains/vm/set_status.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_set_status: +.. _onemath_vm_set_status: set_status ========== @@ -24,13 +24,13 @@ set_status .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { - oneapi::mkl::vm::status set_status( + oneapi::math::vm::status set_status( sycl::queue& exec_queue, - oneapi::mkl::vm::status new_status); + oneapi::math::vm::status new_status); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm .. rubric:: Description @@ -54,23 +54,23 @@ set_status - Description * - Successful Execution - - * - ``oneapi::mkl::vm::status::success`` + * - ``oneapi::math::vm::status::success`` - VM function execution completed successfully - * - ``oneapi::mkl::vm::status::not_defined`` + * - ``oneapi::math::vm::status::not_defined`` - VM status not defined * - Warnings - - * - ``oneapi::mkl::vm::status::accuracy_warning`` + * - ``oneapi::math::vm::status::accuracy_warning`` - VM function execution completed successfully in a different accuracy mode * - Computational status codes - - * - ``oneapi::mkl::vm::status::errdom`` + * - ``oneapi::math::vm::status::errdom`` - Values are out of a range of definition producing invalid (QNaN) result - * - ``oneapi::mkl::vm::status::sing`` + * - ``oneapi::math::vm::status::sing`` - Values cause divide-by-zero (singularity) computational errors and produce and invalid (QNaN or Inf) result - * - ``oneapi::mkl::vm::status::overflow`` + * - ``oneapi::math::vm::status::overflow`` - An overflow happened during the calculation process - * - ``oneapi::mkl::vm::status::underflow`` + * - ``oneapi::math::vm::status::underflow`` - An underflow happened during the calculation process @@ -107,6 +107,6 @@ set_status .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_service_functions` + **Parent topic:** :ref:`onemath_vm_service_functions` diff --git a/source/elements/oneMKL/source/domains/vm/setmode.rst b/source/elements/oneMath/source/domains/vm/setmode.rst similarity index 76% rename from source/elements/oneMKL/source/domains/vm/setmode.rst rename to source/elements/oneMath/source/domains/vm/setmode.rst index 1f768db86f..00b873508c 100644 --- a/source/elements/oneMKL/source/domains/vm/setmode.rst +++ b/source/elements/oneMath/source/domains/vm/setmode.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_setmode: +.. _onemath_vm_setmode: set_mode ======== @@ -24,13 +24,13 @@ set_mode .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { - oneapi::mkl::vm::mode set_mode( + oneapi::math::vm::mode set_mode( sycl::queue& exec_queue, - oneapi::mkl::vm::mode new_mode); + oneapi::math::vm::mode new_mode); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm .. rubric:: Description @@ -51,17 +51,17 @@ set_mode - Description * - Accuracy Control - - * - ``oneapi::mkl::vm::mode::ha`` + * - ``oneapi::math::vm::mode::ha`` - High accuracy versions of VM functions. - * - ``oneapi::mkl::vm::mode::la`` + * - ``oneapi::math::vm::mode::la`` - Low accuracy versions of VM functions. - * - ``oneapi::mkl::vm::mode::ep`` + * - ``oneapi::math::vm::mode::ep`` - Enhanced performance accuracy versions of VM functions. - * - ``oneapi::mkl::vm::mode::not_defined`` + * - ``oneapi::math::vm::mode::not_defined`` - VM mode not defined. This has no effect. The assumed value of the ``mode`` parameter for a new queue, if ``set_mode`` - is not called is ``oneapi::mkl::vm::mode::ha``. + is not called is ``oneapi::math::vm::mode::ha``. @@ -96,6 +96,6 @@ set_mode .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_service_functions` + **Parent topic:** :ref:`onemath_vm_service_functions` diff --git a/source/elements/oneMKL/source/domains/vm/sin.rst b/source/elements/oneMath/source/domains/vm/sin.rst similarity index 80% rename from source/elements/oneMKL/source/domains/vm/sin.rst rename to source/elements/oneMath/source/domains/vm/sin.rst index b9c5ed213c..c214984510 100644 --- a/source/elements/oneMKL/source/domains/vm/sin.rst +++ b/source/elements/oneMath/source/domains/vm/sin.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_sin: +.. _onemath_vm_sin: sin === @@ -27,17 +27,17 @@ sin .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sin( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ sin .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sin( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ sin const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -114,10 +114,10 @@ sin -   * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -159,14 +159,14 @@ sin mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -192,14 +192,14 @@ sin mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -234,7 +234,7 @@ sin .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -242,6 +242,6 @@ sin .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/sincos.rst b/source/elements/oneMath/source/domains/vm/sincos.rst similarity index 80% rename from source/elements/oneMKL/source/domains/vm/sincos.rst rename to source/elements/oneMath/source/domains/vm/sincos.rst index a679c6008f..24f9cb883c 100644 --- a/source/elements/oneMKL/source/domains/vm/sincos.rst +++ b/source/elements/oneMath/source/domains/vm/sincos.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_sincos: +.. _onemath_vm_sincos: sincos ====== @@ -27,7 +27,7 @@ sincos .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sincos( sycl::queue& exec_queue, @@ -35,10 +35,10 @@ sincos sycl::buffer& a, sycl::buffer& y, sycl::buffer& z, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -48,7 +48,7 @@ sincos .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sincos( sycl::queue& exec_queue, @@ -57,10 +57,10 @@ sincos T* y, T* z, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -118,11 +118,11 @@ sincos * - +∞ - QNAN - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN - QNAN @@ -159,14 +159,14 @@ sincos mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -192,14 +192,14 @@ sincos mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -244,7 +244,7 @@ sincos .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -252,6 +252,6 @@ sincos .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/sind.rst b/source/elements/oneMath/source/domains/vm/sind.rst similarity index 80% rename from source/elements/oneMKL/source/domains/vm/sind.rst rename to source/elements/oneMath/source/domains/vm/sind.rst index 6490dff8ab..eb8e1fcc64 100644 --- a/source/elements/oneMKL/source/domains/vm/sind.rst +++ b/source/elements/oneMath/source/domains/vm/sind.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_sind: +.. _onemath_vm_sind: sind ==== @@ -27,17 +27,17 @@ sind .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sind( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ sind .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sind( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ sind const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -116,10 +116,10 @@ sind -   * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -154,14 +154,14 @@ sind mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -187,14 +187,14 @@ sind mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -229,7 +229,7 @@ sind .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -238,6 +238,6 @@ sind .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/sinh.rst b/source/elements/oneMath/source/domains/vm/sinh.rst similarity index 83% rename from source/elements/oneMKL/source/domains/vm/sinh.rst rename to source/elements/oneMath/source/domains/vm/sinh.rst index 59c4385144..16051f303e 100644 --- a/source/elements/oneMKL/source/domains/vm/sinh.rst +++ b/source/elements/oneMath/source/domains/vm/sinh.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_sinh: +.. _onemath_vm_sinh: sinh ==== @@ -27,17 +27,17 @@ sinh .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sinh( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ sinh .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sinh( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ sinh const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -120,10 +120,10 @@ sinh -   * - a > overflow - +∞ - - ``oneapi::mkl::vm::status::overflow`` + - ``oneapi::math::vm::status::overflow`` * - a < -overflow - -∞ - - ``oneapi::mkl::vm::status::overflow`` + - ``oneapi::math::vm::status::overflow`` * - +∞ - +∞ -   @@ -218,7 +218,7 @@ sinh - The complex sinh(a) function sets the VM status code to - oneapi::mkl::vm::status::overflow in the case of overflow, that is, when RE(a), + oneapi::math::vm::status::overflow in the case of overflow, that is, when RE(a), IM(a) are finite non-zero numbers, but the real or imaginary part of the exact result is so large that it does not meet the target precision. @@ -254,14 +254,14 @@ sinh mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -287,14 +287,14 @@ sinh mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -329,7 +329,7 @@ sinh .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -337,6 +337,6 @@ sinh .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/sinpi.rst b/source/elements/oneMath/source/domains/vm/sinpi.rst similarity index 80% rename from source/elements/oneMKL/source/domains/vm/sinpi.rst rename to source/elements/oneMath/source/domains/vm/sinpi.rst index e7512b3c65..5deb148ac5 100644 --- a/source/elements/oneMKL/source/domains/vm/sinpi.rst +++ b/source/elements/oneMath/source/domains/vm/sinpi.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_sinpi: +.. _onemath_vm_sinpi: sinpi ===== @@ -27,17 +27,17 @@ sinpi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sinpi( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ sinpi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sinpi( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ sinpi const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -110,10 +110,10 @@ sinpi -   * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -159,14 +159,14 @@ sinpi mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -192,14 +192,14 @@ sinpi mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -234,7 +234,7 @@ sinpi .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -243,6 +243,6 @@ sinpi .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/special-value-notations.rst b/source/elements/oneMath/source/domains/vm/special-value-notations.rst similarity index 95% rename from source/elements/oneMKL/source/domains/vm/special-value-notations.rst rename to source/elements/oneMath/source/domains/vm/special-value-notations.rst index 29154cea66..fcd196c74b 100644 --- a/source/elements/oneMKL/source/domains/vm/special-value-notations.rst +++ b/source/elements/oneMath/source/domains/vm/special-value-notations.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_special_value_notations: +.. _onemath_vm_special_value_notations: Special Value Notations ======================= @@ -60,5 +60,5 @@ Special Value Notations well-defined computationally. -**Parent topic:** :ref:`onemkl_vm` +**Parent topic:** :ref:`onemath_vm` diff --git a/source/elements/oneMKL/source/domains/vm/sqr.rst b/source/elements/oneMath/source/domains/vm/sqr.rst similarity index 81% rename from source/elements/oneMKL/source/domains/vm/sqr.rst rename to source/elements/oneMath/source/domains/vm/sqr.rst index 7b25164db3..8b0aedb40c 100644 --- a/source/elements/oneMKL/source/domains/vm/sqr.rst +++ b/source/elements/oneMath/source/domains/vm/sqr.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_sqr: +.. _onemath_vm_sqr: sqr === @@ -27,16 +27,16 @@ sqr .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sqr( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -46,7 +46,7 @@ sqr .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sqr( sycl::queue& exec_queue, @@ -54,9 +54,9 @@ sqr const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -141,9 +141,9 @@ sqr mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -167,9 +167,9 @@ sqr mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -202,7 +202,7 @@ sqr .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -210,6 +210,6 @@ sqr .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/sqrt.rst b/source/elements/oneMath/source/domains/vm/sqrt.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/sqrt.rst rename to source/elements/oneMath/source/domains/vm/sqrt.rst index 96e3f48b8d..2b4a6c5b21 100644 --- a/source/elements/oneMKL/source/domains/vm/sqrt.rst +++ b/source/elements/oneMath/source/domains/vm/sqrt.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_sqrt: +.. _onemath_vm_sqrt: sqrt ==== @@ -27,17 +27,17 @@ sqrt .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sqrt( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ sqrt .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sqrt( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ sqrt const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -98,7 +98,7 @@ sqrt - VM status code * - a< +0 - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +0 - +0 -   @@ -107,7 +107,7 @@ sqrt -   * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - +∞ -   @@ -225,14 +225,14 @@ sqrt mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -258,14 +258,14 @@ sqrt mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -300,7 +300,7 @@ sqrt .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -308,6 +308,6 @@ sqrt .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/sub.rst b/source/elements/oneMath/source/domains/vm/sub.rst similarity index 81% rename from source/elements/oneMKL/source/domains/vm/sub.rst rename to source/elements/oneMath/source/domains/vm/sub.rst index 7365699e36..afe8c3c9df 100644 --- a/source/elements/oneMKL/source/domains/vm/sub.rst +++ b/source/elements/oneMath/source/domains/vm/sub.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_sub: +.. _onemath_vm_sub: sub === @@ -28,7 +28,7 @@ sub .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sub( sycl::queue& exec_queue, @@ -36,10 +36,10 @@ sub sycl::buffer& a, sycl::buffer& b, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -51,7 +51,7 @@ sub .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event sub( sycl::queue& exec_queue, @@ -60,10 +60,10 @@ sub const T *b, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler - {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler - {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -159,8 +159,8 @@ sub are finite numbers, but the real or imaginary part of the computed result is so large that it does not fit the target precision. In this case, the function returns ∞ in that part of the result, and sets the - VM status code to ``oneapi::mkl::vm::status::overflow`` (overriding any possible - ``oneapi::mkl::vm::status::accuracy_warning`` status). + VM status code to ``oneapi::math::vm::status::overflow`` (overriding any possible + ``oneapi::math::vm::status::accuracy_warning`` status). .. container:: section @@ -191,14 +191,14 @@ sub mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -228,14 +228,14 @@ sub mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -270,7 +270,7 @@ sub .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -279,6 +279,6 @@ sub .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/tan.rst b/source/elements/oneMath/source/domains/vm/tan.rst similarity index 80% rename from source/elements/oneMKL/source/domains/vm/tan.rst rename to source/elements/oneMath/source/domains/vm/tan.rst index 40c53e71fb..2bc0ee72a2 100644 --- a/source/elements/oneMKL/source/domains/vm/tan.rst +++ b/source/elements/oneMath/source/domains/vm/tan.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_tan: +.. _onemath_vm_tan: tan === @@ -27,17 +27,17 @@ tan .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event tan( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ tan .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event tan( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ tan const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -114,10 +114,10 @@ tan -   * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -159,14 +159,14 @@ tan mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -192,14 +192,14 @@ tan mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -234,7 +234,7 @@ tan .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -243,6 +243,6 @@ tan .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/tand.rst b/source/elements/oneMath/source/domains/vm/tand.rst similarity index 80% rename from source/elements/oneMKL/source/domains/vm/tand.rst rename to source/elements/oneMath/source/domains/vm/tand.rst index c827653ef2..c2d8daaba0 100644 --- a/source/elements/oneMKL/source/domains/vm/tand.rst +++ b/source/elements/oneMath/source/domains/vm/tand.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_tand: +.. _onemath_vm_tand: tand ==== @@ -27,17 +27,17 @@ tand .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event tand( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ tand .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event tand( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ tand const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -116,10 +116,10 @@ tand -   * - ±∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - ±∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -154,14 +154,14 @@ tand mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -187,14 +187,14 @@ tand mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -229,7 +229,7 @@ tand .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -237,6 +237,6 @@ tand .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/tanh.rst b/source/elements/oneMath/source/domains/vm/tanh.rst similarity index 87% rename from source/elements/oneMKL/source/domains/vm/tanh.rst rename to source/elements/oneMath/source/domains/vm/tanh.rst index 8a6522e5b9..1d9b39f8c4 100644 --- a/source/elements/oneMKL/source/domains/vm/tanh.rst +++ b/source/elements/oneMath/source/domains/vm/tanh.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_tanh: +.. _onemath_vm_tanh: tanh ==== @@ -27,16 +27,16 @@ tanh .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event tanh( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -46,7 +46,7 @@ tanh .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event tanh( sycl::queue& exec_queue, @@ -54,9 +54,9 @@ tanh const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -226,9 +226,9 @@ tanh mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -252,9 +252,9 @@ tanh mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -287,7 +287,7 @@ tanh .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -296,6 +296,6 @@ tanh .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/tanpi.rst b/source/elements/oneMath/source/domains/vm/tanpi.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/tanpi.rst rename to source/elements/oneMath/source/domains/vm/tanpi.rst index cc18eb51db..9f93f17520 100644 --- a/source/elements/oneMKL/source/domains/vm/tanpi.rst +++ b/source/elements/oneMath/source/domains/vm/tanpi.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_tanpi: +.. _onemath_vm_tanpi: tanpi ===== @@ -27,17 +27,17 @@ tanpi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event tanpi( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ tanpi .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event tanpi( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ tanpi const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -116,10 +116,10 @@ tanpi -   * - +∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - QNAN - QNAN -   @@ -170,14 +170,14 @@ tanpi mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -203,14 +203,14 @@ tanpi mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -245,7 +245,7 @@ tanpi .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -253,6 +253,6 @@ tanpi .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/tgamma.rst b/source/elements/oneMath/source/domains/vm/tgamma.rst similarity index 75% rename from source/elements/oneMKL/source/domains/vm/tgamma.rst rename to source/elements/oneMath/source/domains/vm/tgamma.rst index cabec01cf7..9e9ec8701d 100644 --- a/source/elements/oneMKL/source/domains/vm/tgamma.rst +++ b/source/elements/oneMath/source/domains/vm/tgamma.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_tgamma: +.. _onemath_vm_tgamma: tgamma ====== @@ -27,17 +27,17 @@ tgamma .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event tgamma( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ tgamma .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event tgamma( sycl::queue& exec_queue, @@ -55,10 +55,10 @@ tgamma const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined, - oneapi::mkl::vm::error_handler errhandler = {}); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined, + oneapi::math::vm::error_handler errhandler = {}); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -87,7 +87,7 @@ tgamma Precision overflow thresholds for the tgamma function are beyond the scope of this document. If the result does not meet the target precision, the function raises sets the VM status code to - oneapi::mkl::vm::status::sing. + oneapi::math::vm::status::sing. .. container:: tablenoborder @@ -101,22 +101,22 @@ tgamma - Status code * - +0 - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - -0 - -∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - negative integer - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - -∞ - QNAN - - ``oneapi::mkl::vm::status::errdom`` + - ``oneapi::math::vm::status::errdom`` * - +∞ - +∞ -   * - a > overflow - +∞ - - ``oneapi::mkl::vm::status::sing`` + - ``oneapi::math::vm::status::sing`` * - QNAN - QNAN -   @@ -151,14 +151,14 @@ tgamma mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -184,14 +184,14 @@ tgamma mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. errhandler Sets local error handling mode for this function call. See the - :ref:`onemkl_vm_create_error_handler` + :ref:`onemath_vm_create_error_handler` function for arguments and their descriptions. This is an optional parameter. The local error handler is disabled by default. @@ -226,7 +226,7 @@ tgamma .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -234,6 +234,6 @@ tgamma .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/trunc.rst b/source/elements/oneMath/source/domains/vm/trunc.rst similarity index 82% rename from source/elements/oneMKL/source/domains/vm/trunc.rst rename to source/elements/oneMath/source/domains/vm/trunc.rst index ee18568bc8..f086e8d6cd 100644 --- a/source/elements/oneMKL/source/domains/vm/trunc.rst +++ b/source/elements/oneMath/source/domains/vm/trunc.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_trunc: +.. _onemath_vm_trunc: trunc ===== @@ -28,16 +28,16 @@ trunc .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event trunc( sycl::queue& exec_queue, std::int64_t n, sycl::buffer& a, sycl::buffer& y, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -47,7 +47,7 @@ trunc .. code-block:: cpp - namespace oneapi::mkl::vm { + namespace oneapi::math::vm { sycl::event trunc( sycl::queue& exec_queue, @@ -55,9 +55,9 @@ trunc const T *a, T* y, std::vector const & depends = {}, - oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined); + oneapi::math::vm::mode mode = oneapi::math::vm::mode::not_defined); - } // namespace oneapi::mkl::vm + } // namespace oneapi::math::vm @@ -150,9 +150,9 @@ trunc mode Overrides the global VM mode setting for this function call. See - :ref:`onemkl_vm_setmode` + :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. USM API: @@ -176,9 +176,9 @@ trunc mode Overrides the global VM mode setting for this function call. See - the :ref:`onemkl_vm_setmode` + the :ref:`onemath_vm_setmode` function for possible values and their description. This is an - optional parameter. The default value is ``oneapi::mkl::vm::mode::not_defined``. + optional parameter. The default value is ``oneapi::math::vm::mode::not_defined``. .. container:: section @@ -211,7 +211,7 @@ trunc .. rubric:: Exceptions :class: sectiontitle - For list of generated exceptions please refer to  :ref:`onemkl_vm_exceptions` + For list of generated exceptions please refer to  :ref:`onemath_vm_exceptions` .. container:: familylinks @@ -219,4 +219,4 @@ trunc .. container:: parentlink - **Parent topic:** :ref:`onemkl_vm_mathematical_functions` + **Parent topic:** :ref:`onemath_vm_mathematical_functions` diff --git a/source/elements/oneMKL/source/domains/vm/vm-exceptions.rst b/source/elements/oneMath/source/domains/vm/vm-exceptions.rst similarity index 91% rename from source/elements/oneMKL/source/domains/vm/vm-exceptions.rst rename to source/elements/oneMath/source/domains/vm/vm-exceptions.rst index 1e1e8300d9..b9702d47aa 100644 --- a/source/elements/oneMKL/source/domains/vm/vm-exceptions.rst +++ b/source/elements/oneMath/source/domains/vm/vm-exceptions.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_exceptions: +.. _onemath_vm_exceptions: Exceptions ========== @@ -16,7 +16,7 @@ Exceptions +----------------------------------+------------------------------------+ | exception | when thrown | +----------------------------------+------------------------------------+ - | oneapi::mkl::invalid_argument | buffer API: | + | oneapi::math::invalid_argument | buffer API: | | | n < 0; | | | | | | y.get_count() < n; | @@ -29,13 +29,13 @@ Exceptions | | | | | any pointer argument is nullptr | +----------------------------------+------------------------------------+ - | oneapi::mkl::host_bad_alloc | USM API: | + | oneapi::math::host_bad_alloc | USM API: | | | when internal copying to and | | | from host memory is used | | | and corresponding allocation | | | fails | +----------------------------------+------------------------------------+ - | oneapi::mkl::device_bad_alloc | USM API: | + | oneapi::math::device_bad_alloc | USM API: | | | when internal copying to and | | | from device memory is used | | | and corresponding allocation | diff --git a/source/elements/oneMKL/source/domains/vm/vm-mathematical-functions.rst b/source/elements/oneMath/source/domains/vm/vm-mathematical-functions.rst similarity index 76% rename from source/elements/oneMKL/source/domains/vm/vm-mathematical-functions.rst rename to source/elements/oneMath/source/domains/vm/vm-mathematical-functions.rst index 466af75e4d..cbdfebfdab 100644 --- a/source/elements/oneMKL/source/domains/vm/vm-mathematical-functions.rst +++ b/source/elements/oneMath/source/domains/vm/vm-mathematical-functions.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_mathematical_functions: +.. _onemath_vm_mathematical_functions: VM Mathematical Functions ========================= @@ -48,29 +48,29 @@ VM Mathematical Functions * - Arithmetic Routines - Description - * - :ref:`onemkl_vm_add` + * - :ref:`onemath_vm_add` - Adds vector elements - * - :ref:`onemkl_vm_sub` + * - :ref:`onemath_vm_sub` - Subtracts vector elements - * - :ref:`onemkl_vm_sqr` + * - :ref:`onemath_vm_sqr` - Squares vector elements - * - :ref:`onemkl_vm_mul` + * - :ref:`onemath_vm_mul` - Multiplies vector elements - * - :ref:`onemkl_vm_mulbyconj` + * - :ref:`onemath_vm_mulbyconj` - Multiplies elements of one vector by conjugated elements of the second vector - * - :ref:`onemkl_vm_conj` + * - :ref:`onemath_vm_conj` - Conjugates vector elements - * - :ref:`onemkl_vm_abs` + * - :ref:`onemath_vm_abs` - Computes the absolute value of vector elements - * - :ref:`onemkl_vm_arg` + * - :ref:`onemath_vm_arg` - Computes the argument of vector elements - * - :ref:`onemkl_vm_linearfrac` + * - :ref:`onemath_vm_linearfrac` - Performs linear fraction transformation of vectors - * - :ref:`onemkl_vm_fmod` + * - :ref:`onemath_vm_fmod` - Performs element by element computation of the modulus function of vector ``a`` with respect to vector ``b`` - * - :ref:`onemkl_vm_remainder` + * - :ref:`onemath_vm_remainder` - Performs element by element computation of the remainder function on the elements of vector ``a`` and the corresponding elements of vector ``b`` @@ -83,30 +83,30 @@ VM Mathematical Functions * - Power and Root Routines - Description - * - :ref:`onemkl_vm_inv` + * - :ref:`onemath_vm_inv` - Inverts vector elements - * - :ref:`onemkl_vm_div` + * - :ref:`onemath_vm_div` - Divides elements of one vector by elements of the second vector - * - :ref:`onemkl_vm_sqrt` + * - :ref:`onemath_vm_sqrt` - Computes the square root of vector elements - * - :ref:`onemkl_vm_invsqrt` + * - :ref:`onemath_vm_invsqrt` - Computes the inverse square root of vector elements - * - :ref:`onemkl_vm_cbrt` + * - :ref:`onemath_vm_cbrt` - Computes the cube root of vector elements - * - :ref:`onemkl_vm_invcbrt` + * - :ref:`onemath_vm_invcbrt` - Computes the inverse cube root of vector elements - * - :ref:`onemkl_vm_pow2o3` + * - :ref:`onemath_vm_pow2o3` - Computes the cube root of the square of each vector element - * - :ref:`onemkl_vm_pow3o2` + * - :ref:`onemath_vm_pow3o2` - Computes the square root of the cube of each vector element - * - :ref:`onemkl_vm_pow` + * - :ref:`onemath_vm_pow` - Raises each vector element to the specified power - * - :ref:`onemkl_vm_powx` + * - :ref:`onemath_vm_powx` - Raises each vector element to the constant power - * - :ref:`onemkl_vm_powr` + * - :ref:`onemath_vm_powr` - Computes ``a`` to the power ``b`` for elements of two vectors, where the elements of vector argument ``a`` are all non-negative - * - :ref:`onemkl_vm_hypot` + * - :ref:`onemath_vm_hypot` - Computes the square root of sum of squares .. tabularcolumns:: |p{0.4\textwidth}|p{0.6\textwidth}| @@ -117,25 +117,25 @@ VM Mathematical Functions * - Exponential and Logarithmic Routines - Description - * - :ref:`onemkl_vm_exp` + * - :ref:`onemath_vm_exp` - Computes the base ``e`` exponential of vector elements - * - :ref:`onemkl_vm_exp2` + * - :ref:`onemath_vm_exp2` - Computes the base 2 exponential of vector elements - * - :ref:`onemkl_vm_exp10` + * - :ref:`onemath_vm_exp10` - Computes the base 10 exponential of vector elements - * - :ref:`onemkl_vm_expm1` + * - :ref:`onemath_vm_expm1` - Computes the base ``e`` exponential of vector elements decreased by 1 - * - :ref:`onemkl_vm_ln` + * - :ref:`onemath_vm_ln` - Computes the natural logarithm of vector elements - * - :ref:`onemkl_vm_log2` + * - :ref:`onemath_vm_log2` - Computes the base 2 logarithm of vector elements - * - :ref:`onemkl_vm_log10` + * - :ref:`onemath_vm_log10` - Computes the base 10 logarithm of vector elements - * - :ref:`onemkl_vm_log1p` + * - :ref:`onemath_vm_log1p` - Computes the natural logarithm of vector elements that are increased by 1 - * - :ref:`onemkl_vm_logb` + * - :ref:`onemath_vm_logb` - Computes the exponents of the elements of input vector ``a`` .. tabularcolumns:: |p{0.4\textwidth}|p{0.6\textwidth}| @@ -146,46 +146,46 @@ VM Mathematical Functions * - Trigonometric Routines - Description - * - :ref:`onemkl_vm_cos` + * - :ref:`onemath_vm_cos` - Computes the cosine of vector elements - * - :ref:`onemkl_vm_sin` + * - :ref:`onemath_vm_sin` - Computes the sine of vector elements - * - :ref:`onemkl_vm_sincos` + * - :ref:`onemath_vm_sincos` - Computes the sine and cosine of vector elements - * - :ref:`onemkl_vm_cis` + * - :ref:`onemath_vm_cis` - Computes the complex exponent of vector elements (cosine and sine combined to complex value) - * - :ref:`onemkl_vm_tan` + * - :ref:`onemath_vm_tan` - Computes the tangent of vector elements - * - :ref:`onemkl_vm_acos` + * - :ref:`onemath_vm_acos` - Computes the inverse cosine of vector elements - * - :ref:`onemkl_vm_asin` + * - :ref:`onemath_vm_asin` - Computes the inverse sine of vector elements - * - :ref:`onemkl_vm_atan` + * - :ref:`onemath_vm_atan` - Computes the inverse tangent of vector elements - * - :ref:`onemkl_vm_atan2` + * - :ref:`onemath_vm_atan2` - Computes the four-quadrant inverse tangent of ratios of the elements of two vectors - * - :ref:`onemkl_vm_cospi` + * - :ref:`onemath_vm_cospi` - Computes the cosine of vector elements multiplied by ``π`` - * - :ref:`onemkl_vm_sinpi` + * - :ref:`onemath_vm_sinpi` - Computes the sine of vector elements multiplied by ``π`` - * - :ref:`onemkl_vm_tanpi` + * - :ref:`onemath_vm_tanpi` - Computes the tangent of vector elements multiplied by ``π`` - * - :ref:`onemkl_vm_acospi` + * - :ref:`onemath_vm_acospi` - Computes the inverse cosine of vector elements divided by ``π`` - * - :ref:`onemkl_vm_asinpi` + * - :ref:`onemath_vm_asinpi` - Computes the inverse sine of vector elements divided by ``π`` - * - :ref:`onemkl_vm_atanpi` + * - :ref:`onemath_vm_atanpi` - Computes the inverse tangent of vector elements divided by ``π`` - * - :ref:`onemkl_vm_atan2pi` + * - :ref:`onemath_vm_atan2pi` - Computes the four-quadrant inverse tangent of the ratios of the corresponding elements of two vectors divided by ``π`` - * - :ref:`onemkl_vm_cosd` + * - :ref:`onemath_vm_cosd` - Computes the cosine of vector elements multiplied by ``π``/180 - * - :ref:`onemkl_vm_sind` + * - :ref:`onemath_vm_sind` - Computes the sine of vector elements multiplied by ``π``/180 - * - :ref:`onemkl_vm_tand` + * - :ref:`onemath_vm_tand` - Computes the tangent of vector elements multiplied by ``π``/180 .. tabularcolumns:: |p{0.4\textwidth}|p{0.6\textwidth}| @@ -196,17 +196,17 @@ VM Mathematical Functions * - Hyperbolic Routines - Description - * - :ref:`onemkl_vm_cosh` + * - :ref:`onemath_vm_cosh` - Computes the hyperbolic cosine of vector elements - * - :ref:`onemkl_vm_sinh` + * - :ref:`onemath_vm_sinh` - Computes the hyperbolic sine of vector elements - * - :ref:`onemkl_vm_tanh` + * - :ref:`onemath_vm_tanh` - Computes the hyperbolic tangent of vector elements - * - :ref:`onemkl_vm_acosh` + * - :ref:`onemath_vm_acosh` - Computes the inverse hyperbolic cosine of vector elements - * - :ref:`onemkl_vm_asinh` + * - :ref:`onemath_vm_asinh` - Computes the inverse hyperbolic sine of vector elements - * - :ref:`onemkl_vm_atanh` + * - :ref:`onemath_vm_atanh` - Computes the inverse hyperbolic tangent of vector elements. .. tabularcolumns:: |p{0.4\textwidth}|p{0.6\textwidth}| @@ -217,27 +217,27 @@ VM Mathematical Functions * - Special Routines - Description - * - :ref:`onemkl_vm_erf` + * - :ref:`onemath_vm_erf` - Computes the error function value of vector elements - * - :ref:`onemkl_vm_erfc` + * - :ref:`onemath_vm_erfc` - Computes the complementary error function value of vector elements - * - :ref:`onemkl_vm_cdfnorm` + * - :ref:`onemath_vm_cdfnorm` - Computes the cumulative normal distribution function value of vector elements - * - :ref:`onemkl_vm_erfinv` + * - :ref:`onemath_vm_erfinv` - Computes the inverse error function value of vector elements - * - :ref:`onemkl_vm_erfcinv` + * - :ref:`onemath_vm_erfcinv` - Computes the inverse complementary error function value of vector elements - * - :ref:`onemkl_vm_cdfnorminv` + * - :ref:`onemath_vm_cdfnorminv` - Computes the inverse cumulative normal distribution function value of vector elements - * - :ref:`onemkl_vm_lgamma` + * - :ref:`onemath_vm_lgamma` - Computes the natural logarithm for the absolute value of the gamma function of vector elements - * - :ref:`onemkl_vm_tgamma` + * - :ref:`onemath_vm_tgamma` - Computes the gamma function of vector elements - * - :ref:`onemkl_vm_expint1` + * - :ref:`onemath_vm_expint1` - Computes the exponential integral of vector elements .. tabularcolumns:: |p{0.4\textwidth}|p{0.6\textwidth}| @@ -248,22 +248,22 @@ VM Mathematical Functions * - Rounding Routines - Description - * - :ref:`onemkl_vm_floor` + * - :ref:`onemath_vm_floor` - Rounds towards minus infinity - * - :ref:`onemkl_vm_ceil` + * - :ref:`onemath_vm_ceil` - Rounds towards plus infinity - * - :ref:`onemkl_vm_trunc` + * - :ref:`onemath_vm_trunc` - Rounds towards zero infinity - * - :ref:`onemkl_vm_round` + * - :ref:`onemath_vm_round` - Rounds to nearest integer - * - :ref:`onemkl_vm_nearbyint` + * - :ref:`onemath_vm_nearbyint` - Rounds according to current mode - * - :ref:`onemkl_vm_rint` + * - :ref:`onemath_vm_rint` - Rounds according to current mode and reports inexact result status - * - :ref:`onemkl_vm_modf` + * - :ref:`onemath_vm_modf` - Computes the integer and fractional parts - * - :ref:`onemkl_vm_frac` + * - :ref:`onemath_vm_frac` - Computes the fractional part .. tabularcolumns:: |p{0.4\textwidth}|p{0.6\textwidth}| @@ -274,33 +274,33 @@ VM Mathematical Functions * - Miscellaneous Routines - Description - * - :ref:`onemkl_vm_copysign` + * - :ref:`onemath_vm_copysign` - Returns vector of elements of one argument with signs changed to match other argument elements - * - :ref:`onemkl_vm_nextafter` + * - :ref:`onemath_vm_nextafter` - Returns vector of elements containing the next representable floating-point values following the values from the elements of one vector in the direction of the corresponding elements of another vector - * - :ref:`onemkl_vm_fdim` + * - :ref:`onemath_vm_fdim` - Returns vector containing the differences of the corresponding elements of the vector arguments if the first is larger and +0 otherwise - * - :ref:`onemkl_vm_fmax` + * - :ref:`onemath_vm_fmax` - Returns the larger of each pair of elements of the two vector arguments - * - :ref:`onemkl_vm_fmin` + * - :ref:`onemath_vm_fmin` - Returns the smaller of each pair of elements of the two vector arguments - * - :ref:`onemkl_vm_maxmag` + * - :ref:`onemath_vm_maxmag` - Returns the element with the larger magnitude between each pair of elements of the two vector arguments - * - :ref:`onemkl_vm_minmag` + * - :ref:`onemath_vm_minmag` - Returns the element with the smaller magnitude between each pair of elements of the two vector arguments -**Parent topic:** :ref:`onemkl_vm` +**Parent topic:** :ref:`onemath_vm` .. toctree:: :hidden: diff --git a/source/elements/oneMKL/source/domains/vm/vm-service-functions.rst b/source/elements/oneMath/source/domains/vm/vm-service-functions.rst similarity index 75% rename from source/elements/oneMKL/source/domains/vm/vm-service-functions.rst rename to source/elements/oneMath/source/domains/vm/vm-service-functions.rst index 518784d186..fd183d0c2b 100644 --- a/source/elements/oneMKL/source/domains/vm/vm-service-functions.rst +++ b/source/elements/oneMath/source/domains/vm/vm-service-functions.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm_service_functions: +.. _onemath_vm_service_functions: VM Service Functions ==================== @@ -25,21 +25,21 @@ VM Service Functions * - Function Short Name - Description - * - :ref:`onemkl_vm_setmode` + * - :ref:`onemath_vm_setmode` - Sets the VM mode for given queue - * - :ref:`onemkl_vm_get_mode` + * - :ref:`onemath_vm_get_mode` - Gets the VM mode for given queue - * - :ref:`onemkl_vm_set_status` + * - :ref:`onemath_vm_set_status` - Sets the VM status code for given queue - * - :ref:`onemkl_vm_get_status` + * - :ref:`onemath_vm_get_status` - Gets the VM status code for given queue - * - :ref:`onemkl_vm_clear_status` + * - :ref:`onemath_vm_clear_status` - Clears the VM status code for given queue - * - :ref:`onemkl_vm_create_error_handler` + * - :ref:`onemath_vm_create_error_handler` - Creates the local VM error handler for a function -**Parent topic:** :ref:`onemkl_vm` +**Parent topic:** :ref:`onemath_vm` .. toctree:: :hidden: diff --git a/source/elements/oneMKL/source/domains/vm/vm.rst b/source/elements/oneMath/source/domains/vm/vm.rst similarity index 81% rename from source/elements/oneMKL/source/domains/vm/vm.rst rename to source/elements/oneMath/source/domains/vm/vm.rst index fe984e90ca..b971c4f005 100644 --- a/source/elements/oneMKL/source/domains/vm/vm.rst +++ b/source/elements/oneMath/source/domains/vm/vm.rst @@ -2,7 +2,7 @@ .. .. SPDX-License-Identifier: CC-BY-4.0 -.. _onemkl_vm: +.. _onemath_vm: Vector Math ------------ @@ -18,12 +18,12 @@ Vector Math operations they perform: - - :ref:`onemkl_vm_mathematical_functions` compute values of mathematical + - :ref:`onemath_vm_mathematical_functions` compute values of mathematical functions, such as sine, cosine, exponential, or logarithm, on vectors stored contiguously in memory. - - :ref:`onemkl_vm_service_functions` set/get the accuracy modes and the + - :ref:`onemath_vm_service_functions` set/get the accuracy modes and the error codes, and create error handlers for mathematical functions. @@ -33,7 +33,7 @@ Vector Math can perform in-place operations, where the input and output arrays are at the same memory locations. - - :ref:`onemkl_vm_special_value_notations` + - :ref:`onemath_vm_special_value_notations` .. toctree:: :hidden: @@ -44,4 +44,4 @@ Vector Math vm-exceptions.rst bibliography.rst -**Parent topic:** :ref:`onemkl_vm_inc` \ No newline at end of file +**Parent topic:** :ref:`onemath_vm_inc` \ No newline at end of file diff --git a/source/elements/oneMath/source/index.rst b/source/elements/oneMath/source/index.rst new file mode 100644 index 0000000000..62517ce145 --- /dev/null +++ b/source/elements/oneMath/source/index.rst @@ -0,0 +1,24 @@ +.. SPDX-FileCopyrightText: 2019-2020 Intel Corporation +.. +.. SPDX-License-Identifier: CC-BY-4.0 + +.. _oneMath-section: + +======= +oneMath +======= + +The |onemath_full_name| (oneMath) defines a set of fundamental mathematical routines for use in high-performance computing and other applications. As part of oneAPI, oneMath is designed to allow execution on a wide variety of computational devices: CPUs, GPUs, FPGAs, and other accelerators. The functionality is subdivided into several domains: dense linear algebra, sparse linear algebra, discrete Fourier transforms, random number generators and vector math. + + +The general assumptions, design features and requirements for the oneMath library and host-to-device computational routines will be described in :ref:`onemath_architecture`. +The individual domains and their APIs are described in :ref:`onemath_domains`. +Other design considerations that are not necessarily part of the oneMath specification but that are worth mentioning will be discussed in :ref:`onemath_appendix`. + + +.. toctree:: + :maxdepth: 2 + + architecture/architecture.rst + domains/domains.rst + appendix/appendix.rst diff --git a/source/index.rst b/source/index.rst index b6f7398d9d..457ba57b77 100644 --- a/source/index.rst +++ b/source/index.rst @@ -25,6 +25,6 @@ for creating parallel applications: elements/oneCCL/source/index elements/oneDAL/source/index elements/oneTBB/source/nested-index - elements/oneMKL/source/index + elements/oneMath/source/index Releases notices diff --git a/source/spelling_wordlist.txt b/source/spelling_wordlist.txt index f37d64b6c0..b27e011bbe 100644 --- a/source/spelling_wordlist.txt +++ b/source/spelling_wordlist.txt @@ -80,7 +80,6 @@ LSTM Levitan Lognormal MByte -MKL Matsumoto Mersenne Multinomial @@ -496,7 +495,6 @@ microarchitecture middleware minibatch minmag -mkl modf moveassignable mrg @@ -547,11 +545,11 @@ oneCCL oneDAL oneDNN oneDPL -oneMKL +oneMath oneTBB oneVPL oneapi -onemkl +onemath opencl oqueueing orgbr