{%- endif %}
scikit-cuda-0.5.1/docs/source/authors.rst 0000664 0000000 0000000 00000004500 12614655073 0020374 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
Authors & Acknowledgments
=========================
This software was written and packaged by `Lev Givon
`_. Although it
depends upon the excellent `PyCUDA `_
package by `Andreas Klöckner `_, scikit-cuda
is developed independently of PyCUDA.
Special thanks are due to the following parties for their contributions:
- `Frédéric Bastien `_ - CUBLAS version detection enhancements.
- `David Wei Chiang `_ - Improvements to vectorized functions, bug fixes.
- `Sander Dieleman `_ - CUBLAS 5 bindings.
- `Chris Capdevila `_ - MacOS X library search fix.
- `Ben Erichson `_ - QR decomposition, eigenvalue/eigenvector computation, Dynamic
Mode Decomposition, randomized linear algebra routines.
- `Ying Wei (Daniel) Fan
`_ - Kindly
permitted reuse of CUBLAS wrapper code in his PARRET Python package.
- `Michael M. Forbes `_ - Improved MacOSX compatibility, bug fixes.
- `Jacob Frelinger `_ - Various enhancements.
- Tim Klein - Additional MAGMA wrappers.
- `Eric Larson `_ - Various enhancements.
- `Gregory R. Lee `_ - Enhanced FFT plan creation.
- `Teodor Mihai Moldovan `_ - CUBLAS 5
bindings.
- `Lars Pastewka `_ - FFT tests and FFTW compatibility mode configuration.
- `Luke Pfister `_ - Bug fixes.
- `Alex Rubinsteyn `_ - Support for CULA Dense Free R17.
- `Xing Shi `_ - Bug fixes.
- `Steve Taylor `_ - Cholesky factorization/solve functions.
- Rob Turetsky - Useful feedback.
- `Thomas Unterthiner `_ - Additional high-level and wrapper functions.
- `Stefan van der Walt `_ - Bug fixes.
- `Feng Wang `_ - Bug reports.
- `Yiyin Zhou `_ - Patches, bug reports, and function wrappers
scikit-cuda-0.5.1/docs/source/changes.rst 0000664 0000000 0000000 00000014703 12614655073 0020325 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
Change Log
==========
Release 0.5.1 - (October 30, 2015)
----------------------------------
* More CUSOLVER wrappers.
* Eigenvalue/eigenvector computation (eng. by N. Ben Erichson).
* QR decomposition (enh. by N. Ben Erichson).
* Improved Windows 10 compatibility (enh. by N. Ben Erichson).
* Function for constructing Vandermonde matrix in GPU memory (enh. by N. Ben
Erichson).
* Unrandomized and randomized Dynamic Mode Decomposition (enh. by N. Ben
Erichson).
* Randomized linear algebra routines (enh. by N. Ben Erichson).
* Add triu function (enh. by N. Ben Erichson).
* Support Bessel correction in computation of variance and standard
deviation (#143).
* Fix pip installation issues.
Release 0.5.0 - (July 14, 2015)
-------------------------------
* Rename package to scikit-cuda.
* Reductions sum, mean, var, std, max, min, argmax, argmin accept keepdims option.
* The same reductions now return a GPUArray instead of ndarray if axis=None.
* Switch to PEP 440 version numbering.
* Replace distribute_setup.py with ez_setup.py.
* Improve support for latest NVIDIA GPUs.
* Direct links to online NVIDIA documentation in CUBLAS, CUFFT wrapper
docstrings.
* Add wrappers for CUSOLVER in CUDA 7.0.
* Add skcuda namespace package that contains all modules in scikits.cuda namespace.
* Add more wrappers for CUBLAS 5 functions (enh. by Teodor Moldovan, Sander
Dieleman).
* Add support for CULA Dense Free R17 (enh. by Alex Rubinsteyn).
* Memoize elementwise kernel used by ifft scaling (#37).
* Speed up misc.maxabs using reduction and kernel memoization.
* Speed up misc.cumsum using scan and kernel memoization.
* Speed up linalg.conj and misc.diff using elementwise kernel and memoization.
* Speed up special.{sici,exp1,expi} using elementwise kernel and memoization.
* Add wrappers for experimental multi-GPU CULA routines in CULA Dense R14+.
* Use ldconfig to find library paths rather than libdl (#39).
* Fix win32 platform detection.
* Add Cholesky factorization/solve routines (enh. by Steve Taylor).
* Fix Cholesky factorization/solve routines (fix by Thomas Unterthiner).
* Enable dot() function to operate inplace (enh. by Thomas Unterthiner).
* Python 3 compatibility improvements (enh. by Thomas Unterthiner).
* Support for Fortran-order arrays in dot() and cho_solve() (enh. by Thomas Unterthiner)
* CULA-based matrix inversion (enh. by Thomas Unterthiner).
* Add add_diag() function (enh. by Thomas Unterthiner).
* Use cublas*copy in diag() function (enh. by Thomas Unterthiner).
* Improved MacOSX compatibility (enh. by Michael M. Forbes).
* Find CUBLAS version even when it is only accessible via LD_LIBRARY_PATH (enh. by Frédéric Bastien).
* Get both major and minor version numbers from CUBLAS library when determining
version.
* Handle unset LD_LIBRARY_PATH variable (fix by Jan Schlüter).
* Fix library search on MacOS X (fix by capdevc).
* Fix library search on Windows.
* Add Windows support to CULA wrappers.
* Enable specification of memory pool allocator to linalg functions (enh. by
Thomas Unterthiner).
* Improve misc.select_block_grid_sizes() logic to handle different GPU hardware.
* Compute transpose using CUDA 5.0 CUBLAS functions rather than with inefficient naive kernel.
* Use ReadTheDocs theme when building HTML docs locally.
* Support additional cufftPlanMany() parameters when creating FFT plans (enh. by
Gregory R. Lee).
* Improved Python 3.4 compatibility (enh. by Eric Larson).
* Avoid unnecessary import of cublas when importing fft module (enh. by Eric
Larson).
* Matrix trace function (enh. by Thomas Unterthiner).
* Functions for computing simple axis-wise stats over matrices (enh. by Thomas
Unterthiner).
* Matrix add_dot, add_matvec, div_matvec, mult_matvec functions (enh. by Thomas
Unterthiner).
* Faster dot_diag implementation using CUBLAS matrix-matrix multiplication (enh.
by Thomas Unterthiner).
* Memoize SourceModule calls to speed up various high-level functions (enh. by
Thomas Unterthiner).
* Function for computing matrix determinant (enh. by Thomas Unterthiner).
* Function for computing min/max and argmin/argmax along a matrix axis
(enh. by Thomas Unterthiner).
* Set default value of the parameter 'overwrite' to False in all linalg
functions.
* Elementwise arithmetic operations with broadcasting up to 2 dimensions
(enh. David Wei Chiang)
Release 0.042 - (March 10, 2013)
--------------------------------
* Add complex exponential integral.
* Fix typo in cublasCgbmv.
* Use CUBLAS v2 API, add preliminary support for CUBLAS 5 functions.
* Detect CUBLAS version without initializing the GPU.
* Work around numpy bug #1898.
* Fix issues with pycuda installations done via easy_install/pip.
* Add support for specifying streams when creating FFT plans.
* Successfully find CULA R13a libraries.
* Raise exceptions when functions in the full release of CULA Dense are invoked
without the library installed.
* Perform post-fft scaling in-place.
* Fix broken Python 2.6 compatibility (#19).
* Download distribute for package installation if it isn't available.
* Prevent absence of CULA from causing import errors (enh. by Jacob Frelinger)
* FFT batch tests and FFTW mode configuration (enh. by Lars Pastewka)
Release 0.041 - (May 22, 2011)
------------------------------
* Fix bug preventing installation with pip.
Release 0.04 - (May 11, 2011)
-----------------------------
* Fix bug in cutoff_invert kernel.
* Add get_compute_capability function and other goodies to misc module.
* Use pycuda-complex.hpp to improve kernel readability.
* Add integrate module.
* Add unit tests for high-level functions.
* Automatically determine device used by current context.
* Support batched and multidimensional FFT operations.
* Extended dot() function to support implicit transpose/Hermitian.
* Support for in-place computation of singular vectors in svd() function.
* Simplify kernel launch setup.
* More CULA routine wrappers.
* Wrappers for CULA R11 auxiliary routines.
Release 0.03 - (November 22, 2010)
----------------------------------
* Add support for some functions in the premium version of CULA toolkit.
* Add wrappers for all lapack functions in basic CULA toolkit.
* Fix pinv() to properly invert complex matrices.
* Add Hermitian transpose.
* Add tril function.
* Fix missing library detection.
* Include missing CUDA headers in package.
Release 0.02 - (September 21, 2010)
-----------------------------------
* Add documentation.
* Update copyright information.
Release 0.01 - (September 17, 2010)
-----------------------------------
* First public release.
scikit-cuda-0.5.1/docs/source/conf.py 0000664 0000000 0000000 00000023743 12614655073 0017466 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#
# scikit-cuda documentation build configuration file, created by
# sphinx-quickstart on Fri Jul 19 10:11:54 2013.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import re, sys, os
# Prevent project dependencies from interfering with autodoc:
class Mock(object):
__all__ = []
def __init__(self, *args, **kwargs):
pass
def __call__(self, *args, **kwargs):
return Mock()
@classmethod
def __getattr__(cls, name):
if name in ('__file__', '__path__'):
return '/dev/null'
elif name == 'typecodes':
return {'AllInteger': [], 'AllFloat': []}
elif name[0] == name[0].upper():
mockType = type(name, (), {})
mockType.__module__ = __name__
return mockType
else:
return Mock()
def __getitem__(self, v):
return Mock()
MOCK_MODULES = ['numpy', 'pycuda', 'pycuda.compiler', 'pycuda.curandom', 'pycuda.driver',
'pycuda.elementwise', 'pycuda.gpuarray',
'pycuda.reduction', 'pycuda.scan', 'pycuda.tools', 'pytools']
for mod_name in MOCK_MODULES:
sys.modules[mod_name] = Mock()
# Prevent attempts at finding certain shared libraries from causing module
# import exceptions:
import ctypes
ctypes.cdll.LoadLibrary = Mock()
# Prevent pkg_resources requirements checking from raising exceptions due to
# missing dependencies:
import pkg_resources
pkg_resources.require = Mock()
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.append(os.path.abspath('../sphinxext'))
sys.path.append(os.path.abspath('../skcuda'))
sys.path.append(os.path.abspath('../../'))
# Prevent cublas library load from interfering with doc build:
import skcuda.utils
def __temp(filename):
return 'libcublas.so.6.5'
__temp.__doc__ = skcuda.utils.get_soname.__doc__
skcuda.utils.get_soname = __temp
# -- General configuration -----------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc',
'sphinx.ext.autosummary',
'sphinx.ext.intersphinx',
'sphinx.ext.pngmath',
'sphinx.ext.viewcode',
'numpydoc']
# Generate autosummary stubs:
autosummary_generate = True
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'scikit-cuda'
copyright = u'2009-2015, Lev Givon'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
# The short X.Y version.
version = '0.5'
# The full version, including alpha/beta/rc tags.
release = '0.5.0'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
language = 'en'
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of documents that shouldn't be included in the build.
#unused_docs = []
# List of directories, relative to source directory, that shouldn't be searched
# for source files.
exclude_trees = ['build']
# The reST default role (used for this markup: `text`) to use for all documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
#keep_warnings = False
# -- Options for HTML output ---------------------------------------------------
on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
if on_rtd:
html_theme = 'default'
else:
import sphinx_rtd_theme
# The theme to use for HTML and HTML Help pages. Major themes that come with
# Sphinx are currently 'default' and 'sphinxdoc'.
html_theme = 'sphinx_rtd_theme'
# Add any paths that contain custom themes here, relative to this directory.
html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
# The name for this set of Sphinx documents. If None, it defaults to
# " v documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
#html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = 'scikit-cuda-doc'
# -- Options for LaTeX output --------------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
'preamble': """
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\usepackage{ucs}
\\renewcommand{\\familydefault}{\\sfdefault}
"""
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
('index', 'scikit-cuda-doc.tex', u'scikit-cuda Documentation',
u'Lev Givon', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
latex_use_parts = True
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output --------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
('index', 'scikit-cuda', u'scikit-cuda Documentation',
[u'Lev Givon'], 1)
]
# If true, show URL addresses after external links.
#man_show_urls = False
# -- Options for Texinfo output ------------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
('index', 'scikit-cuda', u'scikit-cuda Documentation',
u'Lev Givon', 'scikit-cuda', 'scikit-cuda',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
#texinfo_no_detailmenu = False
# Generate links to other projects' online references:
intersphinx_mapping = {
'http://docs.python.org/2/': None,
'http://docs.scipy.org/doc/numpy/': None,
'http://documen.tician.de/pycuda/': None,
}
scikit-cuda-0.5.1/docs/source/index.rst 0000664 0000000 0000000 00000001303 12614655073 0020014 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
scikit-cuda
===========
scikit-cuda provides Python interfaces to many of the functions in the CUDA
device/runtime, CUBLAS, CUFFT, and CUSOLVER libraries distributed as
part of NVIDIA's `CUDA Programming Toolkit `_, as
well as interfaces to select functions in the free and standard versions of the
`CULA Dense Toolkit `_. Both low-level wrapper
functions similar to their C counterparts and high-level functions comparable to
those in `NumPy and Scipy `_ are provided.
Contents
--------
.. toctree::
:maxdepth: 2
install
reference
authors
license
changes
Index
-----
* :ref:`genindex`
scikit-cuda-0.5.1/docs/source/install.rst 0000664 0000000 0000000 00000007232 12614655073 0020362 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
Installation
============
Quick Installation
------------------
If you have `pip `_ installed, you should be
able to install the latest stable release of ``scikit-cuda`` by running the
following::
pip install scikit-cuda
All dependencies should be automatically downloaded and installed if they are
not already on your system.
Obtaining the Latest Software
-----------------------------
The latest stable and development versions of ``scikit-cuda`` can be downloaded
from `GitHub `_
Online documentation is available at ``_
Installation Dependencies
-------------------------
``scikit-cuda`` requires that the following software packages be
installed:
* `Python `_ 2.7 or 3.4.
* `Setuptools `_ 0.6c10 or later.
* `Mako `_ 1.0.1 or later.
* `NumPy `_ 1.2.0 or later.
* `PyCUDA `_ 2014.1 or later (some
parts of ``scikit-cuda`` might not work properly with earlier versions).
* `NVIDIA CUDA Toolkit `_ 5.0
or later.
To run the unit tests, the following packages are also required:
* `nose `_ 0.11 or later.
* `SciPy `_ 0.14.0 or later.
Some of the linear algebra functionality relies on the CULA Dense toolkit; the
single precision release of the toolkit is free of charge, but requires
registration. Depending on the version of CULA installed, some functions may
not be available:
* `CULA `_ R16a or later.
To build the documentation, the following packages are also required:
* `Docutils `_ 0.5 or later.
* `Jinja2 `_ 2.2 or later.
* `Pygments `_ 0.8 or later.
* `Sphinx `_ 1.0.1 or later.
* `Sphinx ReadTheDocs Theme
`_ 0.1.6 or later.
Platform Support
----------------
The software has been developed and tested on Linux; it should also work on
other Unix-like platforms supported by the above packages. Parts of the package
may work on Windows as well, but remain untested.
Building and Installation
-------------------------
``scikit-cuda`` searches for CUDA libraries in the system library
search path when imported. You may have to modify this path (e.g., by adding the
path to the CUDA libraries to ``/etc/ld.so.conf`` and running ``ldconfig`` as
root or to the
``LD_LIBRARY_PATH`` environmental variable on Linux, or by adding the CUDA
library path to the ``DYLD_LIBRARY_PATH`` on MacOSX) if the libraries are
not being found.
To build and install the toolbox, download and unpack the source
release and run::
python setup.py install
from within the main directory in the release. To rebuild the
documentation, run::
python setup.py build_sphinx
Running the Unit Tests
----------------------
To run all of the package unit tests, download and unpack the package source
tarball and run::
python setup.py test
from within the main directory in the archive. Tests for individual
modules (found in the ``tests/`` subdirectory) can also be run
directly.
Getting Started
---------------
The functions provided by ``scikit-cuda`` are grouped into several submodules in
the ``skcuda`` namespace package. Sample code demonstrating how to use
different parts of the toolbox is located in the ``demos/`` subdirectory of the
source release. Many of the high-level functions also contain doctests that
describe their usage.
scikit-cuda-0.5.1/docs/source/license.rst 0000664 0000000 0000000 00000002751 12614655073 0020337 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
License
=======
Copyright (c) 2009-2015, Lev Givon.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Lev Givon nor the names of any
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
scikit-cuda-0.5.1/docs/source/reference.rst 0000664 0000000 0000000 00000000726 12614655073 0020653 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
Reference
=========
Library Wrapper Routines
------------------------
.. toctree::
:maxdepth: 2
reference_cublas
reference_cufft
reference_cusolver
reference_cula
reference_pcula
High-Level Routines
-------------------
.. toctree::
:maxdepth: 2
reference_fft
reference_integrate
reference_linalg
reference_rlinalg
reference_special
Other Routines
--------------
.. toctree::
:maxdepth: 2
reference_misc
scikit-cuda-0.5.1/docs/source/reference_cublas.rst 0000664 0000000 0000000 00000007577 12614655073 0022217 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
.. currentmodule:: skcuda.cublas
CUBLAS Routines
===============
Helper Routines
---------------
.. autosummary::
:toctree: generated/
:nosignatures:
cublasCheckStatus
cublasCreate
cublasDestroy
cublasGetCurrentCtx
cublasGetStream
cublasGetVersion
cublasSetStream
Wrapper Routines
----------------
Single Precision BLAS1 Routines
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
cublasIsamax
cublasIsamin
cublasSasum
cublasSaxpy
cublasScopy
cublasSdot
cublasSnrm2
cublasSrot
cublasSrotg
cublasSrotm
cublasSrotmg
cublasSscal
cublasSswap
cublasCaxpy
cublasCcopy
cublasCdotc
cublasCdotu
cublasCrot
cublasCrotg
cublasCscal
cublasCsrot
cublasCsscal
cublasCswap
cublasIcamax
cublasIcamin
cublasScasum
cublasScnrm2
Double Precision BLAS1 Routines
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
cublasIdamax
cublasIdamin
cublasDasum
cublasDaxpy
cublasDcopy
cublasDdot
cublasDnrm2
cublasDrot
cublasDrotg
cublasDrotm
cublasDrotmg
cublasDscal
cublasDswap
cublasDzasum
cublasDznrm2
cublasIzamax
cublasIzamin
cublasZaxpy
cublasZcopy
cublasZdotc
cublasZdotu
cublasZdrot
cublasZdscal
cublasZrot
cublasZrotg
cublasZscal
cublasZswap
Single Precision BLAS2 Routines
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
cublasSgbmv
cublasSgemv
cublasSger
cublasSsbmv
cublasSspmv
cublasSspr
cublasSspr2
cublasSsymv
cublasSsyr
cublasSsyr2
cublasStbmv
cublasStbsv
cublasStpmv
cublasStpsv
cublasStrmv
cublasStrsv
cublasCgbmv
cublasCgemv
cublasCgerc
cublasCgeru
cublasChbmv
cublasChemv
cublasCher
cublasCher2
cublasChpmv
cublasChpr
cublasChpr2
cublasCtbmv
cublasCtbsv
cublasCtpmv
cublasCtpsv
cublasCtrmv
cublasCtrsv
Double Precision BLAS2 Routines
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
cublasDgbmv
cublasDgemv
cublasDger
cublasDsbmv
cublasDspmv
cublasDspr
cublasDspr2
cublasDsymv
cublasDsyr
cublasDsyr2
cublasDtbmv
cublasDtbsv
cublasDtpmv
cublasDtpsv
cublasDtrmv
cublasDtrsv
cublasZgbmv
cublasZgemv
cublasZgerc
cublasZgeru
cublasZhbmv
cublasZhemv
cublasZher
cublasZher2
cublasZhpmv
cublasZhpr
cublasZhpr2
cublasZtbmv
cublasZtbsv
cublasZtpmv
cublasZtpsv
cublasZtrmv
cublasZtrsv
Single Precision BLAS3 Routines
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
cublasSgemm
cublasSsymm
cublasSsyrk
cublasSsyr2k
cublasStrmm
cublasStrsm
cublasCgemm
cublasChemm
cublasCherk
cublasCher2k
cublasCsymm
cublasCsyrk
cublasCsyr2k
cublasCtrmm
cublasCtrsm
Double Precision BLAS3 Routines
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
cublasDgemm
cublasDsymm
cublasDsyrk
cublasDsyr2k
cublasDtrmm
cublasDtrsm
cublasZgemm
cublasZhemm
cublasZherk
cublasZher2k
cublasZsymm
cublasZsyrk
cublasZsyr2k
cublasZtrmm
cublasZtrsm
Single-Precision BLAS-like Extension Routines
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
cublasSdgmm
cublasSgeam
cublasSgemmBatched
cublasCgemmBatched
cublasStrsmBatched
cublasSgetrfBatched
cublasCdgmm
cublasCgeam
Double-Precision BLAS-like Extension Routines
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
cublasDdgmm
cublasDgeam
cublasDgemmBatched
cublasZgemmBatched
cublasDtrsmBatched
cublasDgetrfBatched
cublasZdgmm
cublasZgeam
scikit-cuda-0.5.1/docs/source/reference_cufft.rst 0000664 0000000 0000000 00000001022 12614655073 0022030 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
.. currentmodule:: skcuda.cufft
CUFFT Routines
==============
Helper Routines
---------------
.. autosummary::
:toctree: generated/
:nosignatures:
cufftCheckStatus
Wrapper Routines
----------------
.. autosummary::
:toctree: generated/
:nosignatures:
cufftPlan1d
cufftPlan2d
cufftPlan3d
cufftPlanMany
cufftDestroy
cufftExecC2C
cufftExecR2C
cufftExecC2R
cufftExecZ2Z
cufftExecD2Z
cufftExecZ2D
cufftSetCompatibilityMode
cufftSetStream
scikit-cuda-0.5.1/docs/source/reference_cula.rst 0000664 0000000 0000000 00000006341 12614655073 0021656 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
.. currentmodule:: skcuda.cula
CULA Routines
=============
Framework Routines
------------------
.. autosummary::
:toctree: generated/
:nosignatures:
culaCheckStatus
culaFreeBuffers
culaGetCublasMinimumVersion
culaGetCublasRuntimeVersion
culaGetCudaDriverVersion
culaGetCudaMinimumVersion
culaGetCudaRuntimeVersion
culaGetDeviceCount
culaGetErrorInfo
culaGetErrorInfoString
culaGetExecutingDevice
culaGetLastStatus
culaGetStatusString
culaGetVersion
culaInitialize
culaSelectDevice
culaShutdown
Auxiliary Routines
------------------
Single Precision Real
^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
culaDeviceSgeNancheck
culaDeviceSgeTranspose
culaDeviceSgeTransposeInplace
Single Precision Complex
^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
culaDeviceCgeConjugate
culaDeviceCgeNancheck
culaDeviceCgeTranspose
culaDeviceCgeTransposeConjugate
culaDeviceCgeTransposeInplace
culaDeviceCgeTransposeConjugateInplace
Double Precision Real
^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
culaDeviceDgeNancheck
culaDeviceDgeTranspose
culaDeviceDgeTransposeInplace
Double Precision Complex
^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
culaDeviceZgeConjugate
culaDeviceZgeNancheck
culaDeviceZgeTranspose
culaDeviceZgeTransposeConjugate
culaDeviceZgeTransposeInplace
culaDeviceZgeTransposeConjugateInplace
BLAS Routines
-------------
Single Precision Real
^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
culaDeviceSgemm
culaDeviceSgemv
Single Precision Complex
^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
culaDeviceCgemm
culaDeviceCgemv
Double Precision Real
^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
culaDeviceDgemm
culaDeviceDgemv
Double Precision Complex
^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
culaDeviceZgemm
culaDeviceZgemv
LAPACK Routines
---------------
Single Precision Real
^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
culaDeviceSgels
culaDeviceSgeqrf
culaDeviceSgesv
culaDeviceSgesvd
culaDeviceSgetrf
culaDeviceSgglse
culaDeviceSposv
culaDeviceSpotrf
Single Precision Complex
^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
culaDeviceCgels
culaDeviceCgeqrf
culaDeviceCgesv
culaDeviceCgesvd
culaDeviceCgetrf
culaDeviceCgglse
culaDeviceCposv
culaDeviceCpotrf
Double Precision Real
^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
culaDeviceDgels
culaDeviceDgeqrf
culaDeviceDgesv
culaDeviceDgesvd
culaDeviceDgetrf
culaDeviceDgglse
culaDeviceDposv
culaDeviceDpotrf
Double Precision Complex
^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
culaDeviceZgels
culaDeviceZgeqrf
culaDeviceZgesv
culaDeviceZgesvd
culaDeviceZgetrf
culaDeviceZgglse
culaDeviceZposv
culaDeviceZpotrf
scikit-cuda-0.5.1/docs/source/reference_cusolver.rst 0000664 0000000 0000000 00000002400 12614655073 0022564 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
.. currentmodule:: skcuda.cusolver
CUSOLVER Routines
=================
These routines are only available in CUDA 7.0 and later.
Helper Routines
---------------
.. autosummary::
:toctree: generated/
:nosignatures:
cusolverDnCreate
cusolverDnGetStream
cusolverDnDestroy
cusolverDnSetStream
Wrapper Routines
----------------
Single Precision Routines
^^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
cusolverDnSgeqrf_bufferSize
cusolverDnSgeqrf
cusolverDnSgesvd_bufferSize
cusolverDnSgesvd
cusolverDnSgetrf_bufferSize
cusolverDnSgetrf
cusolverDnSgetrs
cusolverDnCgeqrf_bufferSize
cusolverDnCgeqrf
cusolverDnCgesvd_bufferSize
cusolverDnCgesvd
cusolverDnCgetrf_bufferSize
cusolverDnCgetrf
cusolverDnCgetrs
Double Precision Routines
^^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
cusolverDnDgeqrf_bufferSize
cusolverDnDgeqrf
cusolverDnDgesvd_bufferSize
cusolverDnDgesvd
cusolverDnDgetrf_bufferSize
cusolverDnDgetrf
cusolverDnDgetrs
cusolverDnZgeqrf_bufferSize
cusolverDnZgeqrf
cusolverDnZgesvd_bufferSize
cusolverDnZgesvd
cusolverDnZgetrf_bufferSize
cusolverDnZgetrf
cusolverDnZgetrs
scikit-cuda-0.5.1/docs/source/reference_fft.rst 0000664 0000000 0000000 00000000264 12614655073 0021507 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
.. currentmodule:: skcuda.fft
Fast Fourier Transform
======================
.. autosummary::
:toctree: generated/
:nosignatures:
fft
ifft
Plan
scikit-cuda-0.5.1/docs/source/reference_integrate.rst 0000664 0000000 0000000 00000000260 12614655073 0022706 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
.. currentmodule:: skcuda.integrate
Integration Routines
====================
.. autosummary::
:toctree: generated/
:nosignatures:
trapz
trapz2d
scikit-cuda-0.5.1/docs/source/reference_linalg.rst 0000664 0000000 0000000 00000000671 12614655073 0022200 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
.. currentmodule:: skcuda.linalg
Linear Algebra Routines
=======================
.. autosummary::
:toctree: generated/
:nosignatures:
add_diag
add_dot
add_matvec
cho_factor
cho_solve
conj
det
diag
div_matvec
dmd
dot_diag
dot
eig
eye
hermitian
inv
mdot
mult_matvec
multiply
norm
pinv
qr
scale
svd
trace
transpose
tril
triu
vander
scikit-cuda-0.5.1/docs/source/reference_misc.rst 0000664 0000000 0000000 00000001116 12614655073 0021660 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
.. currentmodule:: skcuda.misc
Miscellaneous Routines
======================
.. autosummary::
:toctree: generated/
:nosignatures:
add
add_matvec
argmax
argmin
cumsum
diff
divide
done_context
get_by_index
get_compute_capability
get_current_device
get_dev_attrs
inf
init
init_context
init_device
iscomplextype
isdoubletype
max
maxabs
mean
min
multiply
ones
ones_like
select_block_grid_sizes
set_by_index
set_realloc
shutdown
std
subtract
sum
var
zeros
zeros_like
scikit-cuda-0.5.1/docs/source/reference_pcula.rst 0000664 0000000 0000000 00000003105 12614655073 0022031 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
.. currentmodule:: skcuda.pcula
Multi-GPU CULA Routines
=======================
Framework Routines
------------------
.. autosummary::
:toctree: generated/
:nosignatures:
pculaConfigInit
BLAS Routines
-------------
Single Precision Real
^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
pculaSgemm
pculaStrsm
Single Precision Complex
^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
pculaCgemm
pculaCtrsm
Double Precision Real
^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
pculaDgemm
pculaDtrsm
Double Precision Complex
^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
pculaZgemm
pculaZtrsm
LAPACK Routines
---------------
Single Precision Real
^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
pculaSgesv
pculaSgetrf
pculaSgetrs
pculaSposv
pculaSpotrf
pculaSpotrs
Single Precision Complex
^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
pculaCgesv
pculaCgetrf
pculaCgetrs
pculaCposv
pculaCpotrf
pculaCpotrs
Double Precision Real
^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
pculaDgesv
pculaDgetrf
pculaDgetrs
pculaDposv
pculaDpotrf
pculaDpotrs
Double Precision Complex
^^^^^^^^^^^^^^^^^^^^^^^^
.. autosummary::
:toctree: generated/
:nosignatures:
pculaZgesv
pculaZgetrf
pculaZgetrs
pculaZposv
pculaZpotrf
pculaZpotrs
scikit-cuda-0.5.1/docs/source/reference_rlinalg.rst 0000664 0000000 0000000 00000000306 12614655073 0022355 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
.. currentmodule:: skcuda.rlinalg
Randomized Linear Algebra Routines
==================================
.. autosummary::
:toctree: generated/
:nosignatures:
rdmd
rsvd
scikit-cuda-0.5.1/docs/source/reference_special.rst 0000664 0000000 0000000 00000000265 12614655073 0022351 0 ustar 00root root 0000000 0000000 .. -*- rst -*-
.. currentmodule:: skcuda.special
Special Math Functions
======================
.. autosummary::
:toctree: generated/
:nosignatures:
exp1
expi
sici
scikit-cuda-0.5.1/docs/sphinxext/ 0000775 0000000 0000000 00000000000 12614655073 0016710 5 ustar 00root root 0000000 0000000 scikit-cuda-0.5.1/docs/sphinxext/LICENSE.txt 0000664 0000000 0000000 00000013507 12614655073 0020541 0 ustar 00root root 0000000 0000000 -------------------------------------------------------------------------------
The files
- numpydoc.py
- docscrape.py
- docscrape_sphinx.py
- phantom_import.py
have the following license:
Copyright (C) 2008 Stefan van der Walt , Pauli Virtanen
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-------------------------------------------------------------------------------
The files
- compiler_unparse.py
- comment_eater.py
- traitsdoc.py
have the following license:
This software is OSI Certified Open Source Software.
OSI Certified is a certification mark of the Open Source Initiative.
Copyright (c) 2006, Enthought, Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of Enthought, Inc. nor the names of its contributors may
be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-------------------------------------------------------------------------------
The file
- plot_directive.py
originates from Matplotlib (http://matplotlib.sf.net/) which has
the following license:
Copyright (c) 2002-2008 John D. Hunter; All Rights Reserved.
1. This LICENSE AGREEMENT is between John D. Hunter (“JDH”), and the Individual or Organization (“Licensee”) accessing and otherwise using matplotlib software in source or binary form and its associated documentation.
2. Subject to the terms and conditions of this License Agreement, JDH hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use matplotlib 0.98.3 alone or in any derivative version, provided, however, that JDH’s License Agreement and JDH’s notice of copyright, i.e., “Copyright (c) 2002-2008 John D. Hunter; All Rights Reserved” are retained in matplotlib 0.98.3 alone or in any derivative version prepared by Licensee.
3. In the event Licensee prepares a derivative work that is based on or incorporates matplotlib 0.98.3 or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to matplotlib 0.98.3.
4. JDH is making matplotlib 0.98.3 available to Licensee on an “AS IS” basis. JDH MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, JDH MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB 0.98.3 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
5. JDH SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB 0.98.3 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING MATPLOTLIB 0.98.3, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between JDH and Licensee. This License Agreement does not grant permission to use JDH trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
8. By copying, installing or otherwise using matplotlib 0.98.3, Licensee agrees to be bound by the terms and conditions of this License Agreement.
scikit-cuda-0.5.1/docs/sphinxext/comment_eater.py 0000664 0000000 0000000 00000012451 12614655073 0022107 0 ustar 00root root 0000000 0000000 from __future__ import division, absolute_import, print_function
import sys
if sys.version_info[0] >= 3:
from io import StringIO
else:
from io import StringIO
import compiler
import inspect
import textwrap
import tokenize
from .compiler_unparse import unparse
class Comment(object):
""" A comment block.
"""
is_comment = True
def __init__(self, start_lineno, end_lineno, text):
# int : The first line number in the block. 1-indexed.
self.start_lineno = start_lineno
# int : The last line number. Inclusive!
self.end_lineno = end_lineno
# str : The text block including '#' character but not any leading spaces.
self.text = text
def add(self, string, start, end, line):
""" Add a new comment line.
"""
self.start_lineno = min(self.start_lineno, start[0])
self.end_lineno = max(self.end_lineno, end[0])
self.text += string
def __repr__(self):
return '%s(%r, %r, %r)' % (self.__class__.__name__, self.start_lineno,
self.end_lineno, self.text)
class NonComment(object):
""" A non-comment block of code.
"""
is_comment = False
def __init__(self, start_lineno, end_lineno):
self.start_lineno = start_lineno
self.end_lineno = end_lineno
def add(self, string, start, end, line):
""" Add lines to the block.
"""
if string.strip():
# Only add if not entirely whitespace.
self.start_lineno = min(self.start_lineno, start[0])
self.end_lineno = max(self.end_lineno, end[0])
def __repr__(self):
return '%s(%r, %r)' % (self.__class__.__name__, self.start_lineno,
self.end_lineno)
class CommentBlocker(object):
""" Pull out contiguous comment blocks.
"""
def __init__(self):
# Start with a dummy.
self.current_block = NonComment(0, 0)
# All of the blocks seen so far.
self.blocks = []
# The index mapping lines of code to their associated comment blocks.
self.index = {}
def process_file(self, file):
""" Process a file object.
"""
if sys.version_info[0] >= 3:
nxt = file.__next__
else:
nxt = file.next
for token in tokenize.generate_tokens(nxt):
self.process_token(*token)
self.make_index()
def process_token(self, kind, string, start, end, line):
""" Process a single token.
"""
if self.current_block.is_comment:
if kind == tokenize.COMMENT:
self.current_block.add(string, start, end, line)
else:
self.new_noncomment(start[0], end[0])
else:
if kind == tokenize.COMMENT:
self.new_comment(string, start, end, line)
else:
self.current_block.add(string, start, end, line)
def new_noncomment(self, start_lineno, end_lineno):
""" We are transitioning from a noncomment to a comment.
"""
block = NonComment(start_lineno, end_lineno)
self.blocks.append(block)
self.current_block = block
def new_comment(self, string, start, end, line):
""" Possibly add a new comment.
Only adds a new comment if this comment is the only thing on the line.
Otherwise, it extends the noncomment block.
"""
prefix = line[:start[1]]
if prefix.strip():
# Oops! Trailing comment, not a comment block.
self.current_block.add(string, start, end, line)
else:
# A comment block.
block = Comment(start[0], end[0], string)
self.blocks.append(block)
self.current_block = block
def make_index(self):
""" Make the index mapping lines of actual code to their associated
prefix comments.
"""
for prev, block in zip(self.blocks[:-1], self.blocks[1:]):
if not block.is_comment:
self.index[block.start_lineno] = prev
def search_for_comment(self, lineno, default=None):
""" Find the comment block just before the given line number.
Returns None (or the specified default) if there is no such block.
"""
if not self.index:
self.make_index()
block = self.index.get(lineno, None)
text = getattr(block, 'text', default)
return text
def strip_comment_marker(text):
""" Strip # markers at the front of a block of comment text.
"""
lines = []
for line in text.splitlines():
lines.append(line.lstrip('#'))
text = textwrap.dedent('\n'.join(lines))
return text
def get_class_traits(klass):
""" Yield all of the documentation for trait definitions on a class object.
"""
# FIXME: gracefully handle errors here or in the caller?
source = inspect.getsource(klass)
cb = CommentBlocker()
cb.process_file(StringIO(source))
mod_ast = compiler.parse(source)
class_ast = mod_ast.node.nodes[0]
for node in class_ast.code.nodes:
# FIXME: handle other kinds of assignments?
if isinstance(node, compiler.ast.Assign):
name = node.nodes[0].name
rhs = unparse(node.expr).strip()
doc = strip_comment_marker(cb.search_for_comment(node.lineno, default=''))
yield name, rhs, doc
scikit-cuda-0.5.1/docs/sphinxext/compiler_unparse.py 0000664 0000000 0000000 00000060244 12614655073 0022637 0 ustar 00root root 0000000 0000000 """ Turn compiler.ast structures back into executable python code.
The unparse method takes a compiler.ast tree and transforms it back into
valid python code. It is incomplete and currently only works for
import statements, function calls, function definitions, assignments, and
basic expressions.
Inspired by python-2.5-svn/Demo/parser/unparse.py
fixme: We may want to move to using _ast trees because the compiler for
them is about 6 times faster than compiler.compile.
"""
from __future__ import division, absolute_import, print_function
import sys
from compiler.ast import Const, Name, Tuple, Div, Mul, Sub, Add
if sys.version_info[0] >= 3:
from io import StringIO
else:
from StringIO import StringIO
def unparse(ast, single_line_functions=False):
s = StringIO()
UnparseCompilerAst(ast, s, single_line_functions)
return s.getvalue().lstrip()
op_precedence = { 'compiler.ast.Power':3, 'compiler.ast.Mul':2, 'compiler.ast.Div':2,
'compiler.ast.Add':1, 'compiler.ast.Sub':1 }
class UnparseCompilerAst:
""" Methods in this class recursively traverse an AST and
output source code for the abstract syntax; original formatting
is disregarged.
"""
#########################################################################
# object interface.
#########################################################################
def __init__(self, tree, file = sys.stdout, single_line_functions=False):
""" Unparser(tree, file=sys.stdout) -> None.
Print the source for tree to file.
"""
self.f = file
self._single_func = single_line_functions
self._do_indent = True
self._indent = 0
self._dispatch(tree)
self._write("\n")
self.f.flush()
#########################################################################
# Unparser private interface.
#########################################################################
### format, output, and dispatch methods ################################
def _fill(self, text = ""):
"Indent a piece of text, according to the current indentation level"
if self._do_indent:
self._write("\n"+" "*self._indent + text)
else:
self._write(text)
def _write(self, text):
"Append a piece of text to the current line."
self.f.write(text)
def _enter(self):
"Print ':', and increase the indentation."
self._write(": ")
self._indent += 1
def _leave(self):
"Decrease the indentation level."
self._indent -= 1
def _dispatch(self, tree):
"_dispatcher function, _dispatching tree type T to method _T."
if isinstance(tree, list):
for t in tree:
self._dispatch(t)
return
meth = getattr(self, "_"+tree.__class__.__name__)
if tree.__class__.__name__ == 'NoneType' and not self._do_indent:
return
meth(tree)
#########################################################################
# compiler.ast unparsing methods.
#
# There should be one method per concrete grammar type. They are
# organized in alphabetical order.
#########################################################################
def _Add(self, t):
self.__binary_op(t, '+')
def _And(self, t):
self._write(" (")
for i, node in enumerate(t.nodes):
self._dispatch(node)
if i != len(t.nodes)-1:
self._write(") and (")
self._write(")")
def _AssAttr(self, t):
""" Handle assigning an attribute of an object
"""
self._dispatch(t.expr)
self._write('.'+t.attrname)
def _Assign(self, t):
""" Expression Assignment such as "a = 1".
This only handles assignment in expressions. Keyword assignment
is handled separately.
"""
self._fill()
for target in t.nodes:
self._dispatch(target)
self._write(" = ")
self._dispatch(t.expr)
if not self._do_indent:
self._write('; ')
def _AssName(self, t):
""" Name on left hand side of expression.
Treat just like a name on the right side of an expression.
"""
self._Name(t)
def _AssTuple(self, t):
""" Tuple on left hand side of an expression.
"""
# _write each elements, separated by a comma.
for element in t.nodes[:-1]:
self._dispatch(element)
self._write(", ")
# Handle the last one without writing comma
last_element = t.nodes[-1]
self._dispatch(last_element)
def _AugAssign(self, t):
""" +=,-=,*=,/=,**=, etc. operations
"""
self._fill()
self._dispatch(t.node)
self._write(' '+t.op+' ')
self._dispatch(t.expr)
if not self._do_indent:
self._write(';')
def _Bitand(self, t):
""" Bit and operation.
"""
for i, node in enumerate(t.nodes):
self._write("(")
self._dispatch(node)
self._write(")")
if i != len(t.nodes)-1:
self._write(" & ")
def _Bitor(self, t):
""" Bit or operation
"""
for i, node in enumerate(t.nodes):
self._write("(")
self._dispatch(node)
self._write(")")
if i != len(t.nodes)-1:
self._write(" | ")
def _CallFunc(self, t):
""" Function call.
"""
self._dispatch(t.node)
self._write("(")
comma = False
for e in t.args:
if comma: self._write(", ")
else: comma = True
self._dispatch(e)
if t.star_args:
if comma: self._write(", ")
else: comma = True
self._write("*")
self._dispatch(t.star_args)
if t.dstar_args:
if comma: self._write(", ")
else: comma = True
self._write("**")
self._dispatch(t.dstar_args)
self._write(")")
def _Compare(self, t):
self._dispatch(t.expr)
for op, expr in t.ops:
self._write(" " + op + " ")
self._dispatch(expr)
def _Const(self, t):
""" A constant value such as an integer value, 3, or a string, "hello".
"""
self._dispatch(t.value)
def _Decorators(self, t):
""" Handle function decorators (eg. @has_units)
"""
for node in t.nodes:
self._dispatch(node)
def _Dict(self, t):
self._write("{")
for i, (k, v) in enumerate(t.items):
self._dispatch(k)
self._write(": ")
self._dispatch(v)
if i < len(t.items)-1:
self._write(", ")
self._write("}")
def _Discard(self, t):
""" Node for when return value is ignored such as in "foo(a)".
"""
self._fill()
self._dispatch(t.expr)
def _Div(self, t):
self.__binary_op(t, '/')
def _Ellipsis(self, t):
self._write("...")
def _From(self, t):
""" Handle "from xyz import foo, bar as baz".
"""
# fixme: Are From and ImportFrom handled differently?
self._fill("from ")
self._write(t.modname)
self._write(" import ")
for i, (name,asname) in enumerate(t.names):
if i != 0:
self._write(", ")
self._write(name)
if asname is not None:
self._write(" as "+asname)
def _Function(self, t):
""" Handle function definitions
"""
if t.decorators is not None:
self._fill("@")
self._dispatch(t.decorators)
self._fill("def "+t.name + "(")
defaults = [None] * (len(t.argnames) - len(t.defaults)) + list(t.defaults)
for i, arg in enumerate(zip(t.argnames, defaults)):
self._write(arg[0])
if arg[1] is not None:
self._write('=')
self._dispatch(arg[1])
if i < len(t.argnames)-1:
self._write(', ')
self._write(")")
if self._single_func:
self._do_indent = False
self._enter()
self._dispatch(t.code)
self._leave()
self._do_indent = True
def _Getattr(self, t):
""" Handle getting an attribute of an object
"""
if isinstance(t.expr, (Div, Mul, Sub, Add)):
self._write('(')
self._dispatch(t.expr)
self._write(')')
else:
self._dispatch(t.expr)
self._write('.'+t.attrname)
def _If(self, t):
self._fill()
for i, (compare,code) in enumerate(t.tests):
if i == 0:
self._write("if ")
else:
self._write("elif ")
self._dispatch(compare)
self._enter()
self._fill()
self._dispatch(code)
self._leave()
self._write("\n")
if t.else_ is not None:
self._write("else")
self._enter()
self._fill()
self._dispatch(t.else_)
self._leave()
self._write("\n")
def _IfExp(self, t):
self._dispatch(t.then)
self._write(" if ")
self._dispatch(t.test)
if t.else_ is not None:
self._write(" else (")
self._dispatch(t.else_)
self._write(")")
def _Import(self, t):
""" Handle "import xyz.foo".
"""
self._fill("import ")
for i, (name,asname) in enumerate(t.names):
if i != 0:
self._write(", ")
self._write(name)
if asname is not None:
self._write(" as "+asname)
def _Keyword(self, t):
""" Keyword value assignment within function calls and definitions.
"""
self._write(t.name)
self._write("=")
self._dispatch(t.expr)
def _List(self, t):
self._write("[")
for i,node in enumerate(t.nodes):
self._dispatch(node)
if i < len(t.nodes)-1:
self._write(", ")
self._write("]")
def _Module(self, t):
if t.doc is not None:
self._dispatch(t.doc)
self._dispatch(t.node)
def _Mul(self, t):
self.__binary_op(t, '*')
def _Name(self, t):
self._write(t.name)
def _NoneType(self, t):
self._write("None")
def _Not(self, t):
self._write('not (')
self._dispatch(t.expr)
self._write(')')
def _Or(self, t):
self._write(" (")
for i, node in enumerate(t.nodes):
self._dispatch(node)
if i != len(t.nodes)-1:
self._write(") or (")
self._write(")")
def _Pass(self, t):
self._write("pass\n")
def _Printnl(self, t):
self._fill("print ")
if t.dest:
self._write(">> ")
self._dispatch(t.dest)
self._write(", ")
comma = False
for node in t.nodes:
if comma: self._write(', ')
else: comma = True
self._dispatch(node)
def _Power(self, t):
self.__binary_op(t, '**')
def _Return(self, t):
self._fill("return ")
if t.value:
if isinstance(t.value, Tuple):
text = ', '.join([ name.name for name in t.value.asList() ])
self._write(text)
else:
self._dispatch(t.value)
if not self._do_indent:
self._write('; ')
def _Slice(self, t):
self._dispatch(t.expr)
self._write("[")
if t.lower:
self._dispatch(t.lower)
self._write(":")
if t.upper:
self._dispatch(t.upper)
#if t.step:
# self._write(":")
# self._dispatch(t.step)
self._write("]")
def _Sliceobj(self, t):
for i, node in enumerate(t.nodes):
if i != 0:
self._write(":")
if not (isinstance(node, Const) and node.value is None):
self._dispatch(node)
def _Stmt(self, tree):
for node in tree.nodes:
self._dispatch(node)
def _Sub(self, t):
self.__binary_op(t, '-')
def _Subscript(self, t):
self._dispatch(t.expr)
self._write("[")
for i, value in enumerate(t.subs):
if i != 0:
self._write(",")
self._dispatch(value)
self._write("]")
def _TryExcept(self, t):
self._fill("try")
self._enter()
self._dispatch(t.body)
self._leave()
for handler in t.handlers:
self._fill('except ')
self._dispatch(handler[0])
if handler[1] is not None:
self._write(', ')
self._dispatch(handler[1])
self._enter()
self._dispatch(handler[2])
self._leave()
if t.else_:
self._fill("else")
self._enter()
self._dispatch(t.else_)
self._leave()
def _Tuple(self, t):
if not t.nodes:
# Empty tuple.
self._write("()")
else:
self._write("(")
# _write each elements, separated by a comma.
for element in t.nodes[:-1]:
self._dispatch(element)
self._write(", ")
# Handle the last one without writing comma
last_element = t.nodes[-1]
self._dispatch(last_element)
self._write(")")
def _UnaryAdd(self, t):
self._write("+")
self._dispatch(t.expr)
def _UnarySub(self, t):
self._write("-")
self._dispatch(t.expr)
def _With(self, t):
self._fill('with ')
self._dispatch(t.expr)
if t.vars:
self._write(' as ')
self._dispatch(t.vars.name)
self._enter()
self._dispatch(t.body)
self._leave()
self._write('\n')
def _int(self, t):
self._write(repr(t))
def __binary_op(self, t, symbol):
# Check if parenthesis are needed on left side and then dispatch
has_paren = False
left_class = str(t.left.__class__)
if (left_class in op_precedence.keys() and
op_precedence[left_class] < op_precedence[str(t.__class__)]):
has_paren = True
if has_paren:
self._write('(')
self._dispatch(t.left)
if has_paren:
self._write(')')
# Write the appropriate symbol for operator
self._write(symbol)
# Check if parenthesis are needed on the right side and then dispatch
has_paren = False
right_class = str(t.right.__class__)
if (right_class in op_precedence.keys() and
op_precedence[right_class] < op_precedence[str(t.__class__)]):
has_paren = True
if has_paren:
self._write('(')
self._dispatch(t.right)
if has_paren:
self._write(')')
def _float(self, t):
# if t is 0.1, str(t)->'0.1' while repr(t)->'0.1000000000001'
# We prefer str here.
self._write(str(t))
def _str(self, t):
self._write(repr(t))
def _tuple(self, t):
self._write(str(t))
#########################################################################
# These are the methods from the _ast modules unparse.
#
# As our needs to handle more advanced code increase, we may want to
# modify some of the methods below so that they work for compiler.ast.
#########################################################################
# # stmt
# def _Expr(self, tree):
# self._fill()
# self._dispatch(tree.value)
#
# def _Import(self, t):
# self._fill("import ")
# first = True
# for a in t.names:
# if first:
# first = False
# else:
# self._write(", ")
# self._write(a.name)
# if a.asname:
# self._write(" as "+a.asname)
#
## def _ImportFrom(self, t):
## self._fill("from ")
## self._write(t.module)
## self._write(" import ")
## for i, a in enumerate(t.names):
## if i == 0:
## self._write(", ")
## self._write(a.name)
## if a.asname:
## self._write(" as "+a.asname)
## # XXX(jpe) what is level for?
##
#
# def _Break(self, t):
# self._fill("break")
#
# def _Continue(self, t):
# self._fill("continue")
#
# def _Delete(self, t):
# self._fill("del ")
# self._dispatch(t.targets)
#
# def _Assert(self, t):
# self._fill("assert ")
# self._dispatch(t.test)
# if t.msg:
# self._write(", ")
# self._dispatch(t.msg)
#
# def _Exec(self, t):
# self._fill("exec ")
# self._dispatch(t.body)
# if t.globals:
# self._write(" in ")
# self._dispatch(t.globals)
# if t.locals:
# self._write(", ")
# self._dispatch(t.locals)
#
# def _Print(self, t):
# self._fill("print ")
# do_comma = False
# if t.dest:
# self._write(">>")
# self._dispatch(t.dest)
# do_comma = True
# for e in t.values:
# if do_comma:self._write(", ")
# else:do_comma=True
# self._dispatch(e)
# if not t.nl:
# self._write(",")
#
# def _Global(self, t):
# self._fill("global")
# for i, n in enumerate(t.names):
# if i != 0:
# self._write(",")
# self._write(" " + n)
#
# def _Yield(self, t):
# self._fill("yield")
# if t.value:
# self._write(" (")
# self._dispatch(t.value)
# self._write(")")
#
# def _Raise(self, t):
# self._fill('raise ')
# if t.type:
# self._dispatch(t.type)
# if t.inst:
# self._write(", ")
# self._dispatch(t.inst)
# if t.tback:
# self._write(", ")
# self._dispatch(t.tback)
#
#
# def _TryFinally(self, t):
# self._fill("try")
# self._enter()
# self._dispatch(t.body)
# self._leave()
#
# self._fill("finally")
# self._enter()
# self._dispatch(t.finalbody)
# self._leave()
#
# def _excepthandler(self, t):
# self._fill("except ")
# if t.type:
# self._dispatch(t.type)
# if t.name:
# self._write(", ")
# self._dispatch(t.name)
# self._enter()
# self._dispatch(t.body)
# self._leave()
#
# def _ClassDef(self, t):
# self._write("\n")
# self._fill("class "+t.name)
# if t.bases:
# self._write("(")
# for a in t.bases:
# self._dispatch(a)
# self._write(", ")
# self._write(")")
# self._enter()
# self._dispatch(t.body)
# self._leave()
#
# def _FunctionDef(self, t):
# self._write("\n")
# for deco in t.decorators:
# self._fill("@")
# self._dispatch(deco)
# self._fill("def "+t.name + "(")
# self._dispatch(t.args)
# self._write(")")
# self._enter()
# self._dispatch(t.body)
# self._leave()
#
# def _For(self, t):
# self._fill("for ")
# self._dispatch(t.target)
# self._write(" in ")
# self._dispatch(t.iter)
# self._enter()
# self._dispatch(t.body)
# self._leave()
# if t.orelse:
# self._fill("else")
# self._enter()
# self._dispatch(t.orelse)
# self._leave
#
# def _While(self, t):
# self._fill("while ")
# self._dispatch(t.test)
# self._enter()
# self._dispatch(t.body)
# self._leave()
# if t.orelse:
# self._fill("else")
# self._enter()
# self._dispatch(t.orelse)
# self._leave
#
# # expr
# def _Str(self, tree):
# self._write(repr(tree.s))
##
# def _Repr(self, t):
# self._write("`")
# self._dispatch(t.value)
# self._write("`")
#
# def _Num(self, t):
# self._write(repr(t.n))
#
# def _ListComp(self, t):
# self._write("[")
# self._dispatch(t.elt)
# for gen in t.generators:
# self._dispatch(gen)
# self._write("]")
#
# def _GeneratorExp(self, t):
# self._write("(")
# self._dispatch(t.elt)
# for gen in t.generators:
# self._dispatch(gen)
# self._write(")")
#
# def _comprehension(self, t):
# self._write(" for ")
# self._dispatch(t.target)
# self._write(" in ")
# self._dispatch(t.iter)
# for if_clause in t.ifs:
# self._write(" if ")
# self._dispatch(if_clause)
#
# def _IfExp(self, t):
# self._dispatch(t.body)
# self._write(" if ")
# self._dispatch(t.test)
# if t.orelse:
# self._write(" else ")
# self._dispatch(t.orelse)
#
# unop = {"Invert":"~", "Not": "not", "UAdd":"+", "USub":"-"}
# def _UnaryOp(self, t):
# self._write(self.unop[t.op.__class__.__name__])
# self._write("(")
# self._dispatch(t.operand)
# self._write(")")
#
# binop = { "Add":"+", "Sub":"-", "Mult":"*", "Div":"/", "Mod":"%",
# "LShift":">>", "RShift":"<<", "BitOr":"|", "BitXor":"^", "BitAnd":"&",
# "FloorDiv":"//", "Pow": "**"}
# def _BinOp(self, t):
# self._write("(")
# self._dispatch(t.left)
# self._write(")" + self.binop[t.op.__class__.__name__] + "(")
# self._dispatch(t.right)
# self._write(")")
#
# boolops = {_ast.And: 'and', _ast.Or: 'or'}
# def _BoolOp(self, t):
# self._write("(")
# self._dispatch(t.values[0])
# for v in t.values[1:]:
# self._write(" %s " % self.boolops[t.op.__class__])
# self._dispatch(v)
# self._write(")")
#
# def _Attribute(self,t):
# self._dispatch(t.value)
# self._write(".")
# self._write(t.attr)
#
## def _Call(self, t):
## self._dispatch(t.func)
## self._write("(")
## comma = False
## for e in t.args:
## if comma: self._write(", ")
## else: comma = True
## self._dispatch(e)
## for e in t.keywords:
## if comma: self._write(", ")
## else: comma = True
## self._dispatch(e)
## if t.starargs:
## if comma: self._write(", ")
## else: comma = True
## self._write("*")
## self._dispatch(t.starargs)
## if t.kwargs:
## if comma: self._write(", ")
## else: comma = True
## self._write("**")
## self._dispatch(t.kwargs)
## self._write(")")
#
# # slice
# def _Index(self, t):
# self._dispatch(t.value)
#
# def _ExtSlice(self, t):
# for i, d in enumerate(t.dims):
# if i != 0:
# self._write(': ')
# self._dispatch(d)
#
# # others
# def _arguments(self, t):
# first = True
# nonDef = len(t.args)-len(t.defaults)
# for a in t.args[0:nonDef]:
# if first:first = False
# else: self._write(", ")
# self._dispatch(a)
# for a,d in zip(t.args[nonDef:], t.defaults):
# if first:first = False
# else: self._write(", ")
# self._dispatch(a),
# self._write("=")
# self._dispatch(d)
# if t.vararg:
# if first:first = False
# else: self._write(", ")
# self._write("*"+t.vararg)
# if t.kwarg:
# if first:first = False
# else: self._write(", ")
# self._write("**"+t.kwarg)
#
## def _keyword(self, t):
## self._write(t.arg)
## self._write("=")
## self._dispatch(t.value)
#
# def _Lambda(self, t):
# self._write("lambda ")
# self._dispatch(t.args)
# self._write(": ")
# self._dispatch(t.body)
scikit-cuda-0.5.1/docs/sphinxext/docscrape.py 0000664 0000000 0000000 00000040715 12614655073 0021234 0 ustar 00root root 0000000 0000000 """Extract reference documentation from the NumPy source tree.
"""
from __future__ import division, absolute_import, print_function
import inspect
import textwrap
import re
import pydoc
from warnings import warn
import collections
import sys
class Reader(object):
"""A line-based string reader.
"""
def __init__(self, data):
"""
Parameters
----------
data : str
String with lines separated by '\n'.
"""
if isinstance(data,list):
self._str = data
else:
self._str = data.split('\n') # store string as list of lines
self.reset()
def __getitem__(self, n):
return self._str[n]
def reset(self):
self._l = 0 # current line nr
def read(self):
if not self.eof():
out = self[self._l]
self._l += 1
return out
else:
return ''
def seek_next_non_empty_line(self):
for l in self[self._l:]:
if l.strip():
break
else:
self._l += 1
def eof(self):
return self._l >= len(self._str)
def read_to_condition(self, condition_func):
start = self._l
for line in self[start:]:
if condition_func(line):
return self[start:self._l]
self._l += 1
if self.eof():
return self[start:self._l+1]
return []
def read_to_next_empty_line(self):
self.seek_next_non_empty_line()
def is_empty(line):
return not line.strip()
return self.read_to_condition(is_empty)
def read_to_next_unindented_line(self):
def is_unindented(line):
return (line.strip() and (len(line.lstrip()) == len(line)))
return self.read_to_condition(is_unindented)
def peek(self,n=0):
if self._l + n < len(self._str):
return self[self._l + n]
else:
return ''
def is_empty(self):
return not ''.join(self._str).strip()
class NumpyDocString(object):
def __init__(self, docstring, config={}):
docstring = textwrap.dedent(docstring).split('\n')
self._doc = Reader(docstring)
self._parsed_data = {
'Signature': '',
'Summary': [''],
'Extended Summary': [],
'Parameters': [],
'Returns': [],
'Raises': [],
'Warns': [],
'Other Parameters': [],
'Attributes': [],
'Methods': [],
'See Also': [],
'Notes': [],
'Warnings': [],
'References': '',
'Examples': '',
'index': {}
}
self._parse()
def __getitem__(self,key):
return self._parsed_data[key]
def __setitem__(self,key,val):
if key not in self._parsed_data:
warn("Unknown section %s" % key)
else:
self._parsed_data[key] = val
def _is_at_section(self):
self._doc.seek_next_non_empty_line()
if self._doc.eof():
return False
l1 = self._doc.peek().strip() # e.g. Parameters
if l1.startswith('.. index::'):
return True
l2 = self._doc.peek(1).strip() # ---------- or ==========
return l2.startswith('-'*len(l1)) or l2.startswith('='*len(l1))
def _strip(self,doc):
i = 0
j = 0
for i,line in enumerate(doc):
if line.strip(): break
for j,line in enumerate(doc[::-1]):
if line.strip(): break
return doc[i:len(doc)-j]
def _read_to_next_section(self):
section = self._doc.read_to_next_empty_line()
while not self._is_at_section() and not self._doc.eof():
if not self._doc.peek(-1).strip(): # previous line was empty
section += ['']
section += self._doc.read_to_next_empty_line()
return section
def _read_sections(self):
while not self._doc.eof():
data = self._read_to_next_section()
name = data[0].strip()
if name.startswith('..'): # index section
yield name, data[1:]
elif len(data) < 2:
yield StopIteration
else:
yield name, self._strip(data[2:])
def _parse_param_list(self,content):
r = Reader(content)
params = []
while not r.eof():
header = r.read().strip()
if ' : ' in header:
arg_name, arg_type = header.split(' : ')[:2]
else:
arg_name, arg_type = header, ''
desc = r.read_to_next_unindented_line()
desc = dedent_lines(desc)
params.append((arg_name,arg_type,desc))
return params
_name_rgx = re.compile(r"^\s*(:(?P\w+):`(?P[a-zA-Z0-9_.-]+)`|"
r" (?P[a-zA-Z0-9_.-]+))\s*", re.X)
def _parse_see_also(self, content):
"""
func_name : Descriptive text
continued text
another_func_name : Descriptive text
func_name1, func_name2, :meth:`func_name`, func_name3
"""
items = []
def parse_item_name(text):
"""Match ':role:`name`' or 'name'"""
m = self._name_rgx.match(text)
if m:
g = m.groups()
if g[1] is None:
return g[3], None
else:
return g[2], g[1]
raise ValueError("%s is not a item name" % text)
def push_item(name, rest):
if not name:
return
name, role = parse_item_name(name)
items.append((name, list(rest), role))
del rest[:]
current_func = None
rest = []
for line in content:
if not line.strip(): continue
m = self._name_rgx.match(line)
if m and line[m.end():].strip().startswith(':'):
push_item(current_func, rest)
current_func, line = line[:m.end()], line[m.end():]
rest = [line.split(':', 1)[1].strip()]
if not rest[0]:
rest = []
elif not line.startswith(' '):
push_item(current_func, rest)
current_func = None
if ',' in line:
for func in line.split(','):
if func.strip():
push_item(func, [])
elif line.strip():
current_func = line
elif current_func is not None:
rest.append(line.strip())
push_item(current_func, rest)
return items
def _parse_index(self, section, content):
"""
.. index: default
:refguide: something, else, and more
"""
def strip_each_in(lst):
return [s.strip() for s in lst]
out = {}
section = section.split('::')
if len(section) > 1:
out['default'] = strip_each_in(section[1].split(','))[0]
for line in content:
line = line.split(':')
if len(line) > 2:
out[line[1]] = strip_each_in(line[2].split(','))
return out
def _parse_summary(self):
"""Grab signature (if given) and summary"""
if self._is_at_section():
return
# If several signatures present, take the last one
while True:
summary = self._doc.read_to_next_empty_line()
summary_str = " ".join([s.strip() for s in summary]).strip()
if re.compile('^([\w., ]+=)?\s*[\w\.]+\(.*\)$').match(summary_str):
self['Signature'] = summary_str
if not self._is_at_section():
continue
break
if summary is not None:
self['Summary'] = summary
if not self._is_at_section():
self['Extended Summary'] = self._read_to_next_section()
def _parse(self):
self._doc.reset()
self._parse_summary()
for (section,content) in self._read_sections():
if not section.startswith('..'):
section = ' '.join([s.capitalize() for s in section.split(' ')])
if section in ('Parameters', 'Returns', 'Raises', 'Warns',
'Other Parameters', 'Attributes', 'Methods'):
self[section] = self._parse_param_list(content)
elif section.startswith('.. index::'):
self['index'] = self._parse_index(section, content)
elif section == 'See Also':
self['See Also'] = self._parse_see_also(content)
else:
self[section] = content
# string conversion routines
def _str_header(self, name, symbol='-'):
return [name, len(name)*symbol]
def _str_indent(self, doc, indent=4):
out = []
for line in doc:
out += [' '*indent + line]
return out
def _str_signature(self):
if self['Signature']:
return [self['Signature'].replace('*','\*')] + ['']
else:
return ['']
def _str_summary(self):
if self['Summary']:
return self['Summary'] + ['']
else:
return []
def _str_extended_summary(self):
if self['Extended Summary']:
return self['Extended Summary'] + ['']
else:
return []
def _str_param_list(self, name):
out = []
if self[name]:
out += self._str_header(name)
for param,param_type,desc in self[name]:
if param_type:
out += ['%s : %s' % (param, param_type)]
else:
out += [param]
out += self._str_indent(desc)
out += ['']
return out
def _str_section(self, name):
out = []
if self[name]:
out += self._str_header(name)
out += self[name]
out += ['']
return out
def _str_see_also(self, func_role):
if not self['See Also']: return []
out = []
out += self._str_header("See Also")
last_had_desc = True
for func, desc, role in self['See Also']:
if role:
link = ':%s:`%s`' % (role, func)
elif func_role:
link = ':%s:`%s`' % (func_role, func)
else:
link = "`%s`_" % func
if desc or last_had_desc:
out += ['']
out += [link]
else:
out[-1] += ", %s" % link
if desc:
out += self._str_indent([' '.join(desc)])
last_had_desc = True
else:
last_had_desc = False
out += ['']
return out
def _str_index(self):
idx = self['index']
out = []
out += ['.. index:: %s' % idx.get('default','')]
for section, references in idx.items():
if section == 'default':
continue
out += [' :%s: %s' % (section, ', '.join(references))]
return out
def __str__(self, func_role=''):
out = []
out += self._str_signature()
out += self._str_summary()
out += self._str_extended_summary()
for param_list in ('Parameters', 'Returns', 'Other Parameters',
'Raises', 'Warns'):
out += self._str_param_list(param_list)
out += self._str_section('Warnings')
out += self._str_see_also(func_role)
for s in ('Notes','References','Examples'):
out += self._str_section(s)
for param_list in ('Attributes', 'Methods'):
out += self._str_param_list(param_list)
out += self._str_index()
return '\n'.join(out)
def indent(str,indent=4):
indent_str = ' '*indent
if str is None:
return indent_str
lines = str.split('\n')
return '\n'.join(indent_str + l for l in lines)
def dedent_lines(lines):
"""Deindent a list of lines maximally"""
return textwrap.dedent("\n".join(lines)).split("\n")
def header(text, style='-'):
return text + '\n' + style*len(text) + '\n'
class FunctionDoc(NumpyDocString):
def __init__(self, func, role='func', doc=None, config={}):
self._f = func
self._role = role # e.g. "func" or "meth"
if doc is None:
if func is None:
raise ValueError("No function or docstring given")
doc = inspect.getdoc(func) or ''
NumpyDocString.__init__(self, doc)
if not self['Signature'] and func is not None:
func, func_name = self.get_func()
try:
# try to read signature
if sys.version_info[0] >= 3:
argspec = inspect.getfullargspec(func)
else:
argspec = inspect.getargspec(func)
argspec = inspect.formatargspec(*argspec)
argspec = argspec.replace('*','\*')
signature = '%s%s' % (func_name, argspec)
except TypeError as e:
signature = '%s()' % func_name
self['Signature'] = signature
def get_func(self):
func_name = getattr(self._f, '__name__', self.__class__.__name__)
if inspect.isclass(self._f):
func = getattr(self._f, '__call__', self._f.__init__)
else:
func = self._f
return func, func_name
def __str__(self):
out = ''
func, func_name = self.get_func()
signature = self['Signature'].replace('*', '\*')
roles = {'func': 'function',
'meth': 'method'}
if self._role:
if self._role not in roles:
print("Warning: invalid role %s" % self._role)
out += '.. %s:: %s\n \n\n' % (roles.get(self._role,''),
func_name)
out += super(FunctionDoc, self).__str__(func_role=self._role)
return out
class ClassDoc(NumpyDocString):
extra_public_methods = ['__call__']
def __init__(self, cls, doc=None, modulename='', func_doc=FunctionDoc,
config={}):
if not inspect.isclass(cls) and cls is not None:
raise ValueError("Expected a class or None, but got %r" % cls)
self._cls = cls
self.show_inherited_members = config.get('show_inherited_class_members',
True)
if modulename and not modulename.endswith('.'):
modulename += '.'
self._mod = modulename
if doc is None:
if cls is None:
raise ValueError("No class or documentation string given")
doc = pydoc.getdoc(cls)
NumpyDocString.__init__(self, doc)
if config.get('show_class_members', True):
def splitlines_x(s):
if not s:
return []
else:
return s.splitlines()
for field, items in [('Methods', self.methods),
('Attributes', self.properties)]:
if not self[field]:
doc_list = []
for name in sorted(items):
try:
doc_item = pydoc.getdoc(getattr(self._cls, name))
doc_list.append((name, '', splitlines_x(doc_item)))
except AttributeError:
pass # method doesn't exist
self[field] = doc_list
@property
def methods(self):
if self._cls is None:
return []
return [name for name, func in inspect.getmembers(self._cls)
if ((not name.startswith('_')
or name in self.extra_public_methods)
and isinstance(func, collections.Callable)
and self._is_show_member(name))]
@property
def properties(self):
if self._cls is None:
return []
return [name for name, func in inspect.getmembers(self._cls)
if (not name.startswith('_') and
(func is None or isinstance(func, property) or
inspect.isgetsetdescriptor(func))
and self._is_show_member(name))]
def _is_show_member(self, name):
if self.show_inherited_members:
return True # show all class members
if name not in self._cls.__dict__:
return False # class member is inherited, we do not show it
return True
scikit-cuda-0.5.1/docs/sphinxext/docscrape_sphinx.py 0000664 0000000 0000000 00000022334 12614655073 0022622 0 ustar 00root root 0000000 0000000 from __future__ import division, absolute_import, print_function
import sys, re, inspect, textwrap, pydoc
import sphinx
import collections
from docscrape import NumpyDocString, FunctionDoc, ClassDoc
if sys.version_info[0] >= 3:
sixu = lambda s: s
else:
sixu = lambda s: unicode(s, 'unicode_escape')
class SphinxDocString(NumpyDocString):
def __init__(self, docstring, config={}):
NumpyDocString.__init__(self, docstring, config=config)
self.load_config(config)
def load_config(self, config):
self.use_plots = config.get('use_plots', False)
self.class_members_toctree = config.get('class_members_toctree', True)
# string conversion routines
def _str_header(self, name, symbol='`'):
return ['.. rubric:: ' + name, '']
def _str_field_list(self, name):
return [':' + name + ':']
def _str_indent(self, doc, indent=4):
out = []
for line in doc:
out += [' '*indent + line]
return out
def _str_signature(self):
return ['']
if self['Signature']:
return ['``%s``' % self['Signature']] + ['']
else:
return ['']
def _str_summary(self):
return self['Summary'] + ['']
def _str_extended_summary(self):
return self['Extended Summary'] + ['']
def _str_returns(self):
out = []
if self['Returns']:
out += self._str_field_list('Returns')
out += ['']
for param, param_type, desc in self['Returns']:
if param_type:
out += self._str_indent(['**%s** : %s' % (param.strip(),
param_type)])
else:
out += self._str_indent([param.strip()])
if desc:
out += ['']
out += self._str_indent(desc, 8)
out += ['']
return out
def _str_param_list(self, name):
out = []
if self[name]:
out += self._str_field_list(name)
out += ['']
for param, param_type, desc in self[name]:
if param_type:
out += self._str_indent(['**%s** : %s' % (param.strip(),
param_type)])
else:
out += self._str_indent(['**%s**' % param.strip()])
if desc:
out += ['']
out += self._str_indent(desc, 8)
out += ['']
return out
@property
def _obj(self):
if hasattr(self, '_cls'):
return self._cls
elif hasattr(self, '_f'):
return self._f
return None
def _str_member_list(self, name):
"""
Generate a member listing, autosummary:: table where possible,
and a table where not.
"""
out = []
if self[name]:
out += ['.. rubric:: %s' % name, '']
prefix = getattr(self, '_name', '')
if prefix:
prefix = '~%s.' % prefix
autosum = []
others = []
for param, param_type, desc in self[name]:
param = param.strip()
# Check if the referenced member can have a docstring or not
param_obj = getattr(self._obj, param, None)
if not (callable(param_obj)
or isinstance(param_obj, property)
or inspect.isgetsetdescriptor(param_obj)):
param_obj = None
if param_obj and (pydoc.getdoc(param_obj) or not desc):
# Referenced object has a docstring
autosum += [" %s%s" % (prefix, param)]
else:
others.append((param, param_type, desc))
if autosum:
out += ['.. autosummary::']
if self.class_members_toctree:
out += [' :toctree:']
out += [''] + autosum
if others:
maxlen_0 = max(3, max([len(x[0]) for x in others]))
hdr = sixu("=")*maxlen_0 + sixu(" ") + sixu("=")*10
fmt = sixu('%%%ds %%s ') % (maxlen_0,)
out += ['', hdr]
for param, param_type, desc in others:
desc = sixu(" ").join(x.strip() for x in desc).strip()
if param_type:
desc = "(%s) %s" % (param_type, desc)
out += [fmt % (param.strip(), desc)]
out += [hdr]
out += ['']
return out
def _str_section(self, name):
out = []
if self[name]:
out += self._str_header(name)
out += ['']
content = textwrap.dedent("\n".join(self[name])).split("\n")
out += content
out += ['']
return out
def _str_see_also(self, func_role):
out = []
if self['See Also']:
see_also = super(SphinxDocString, self)._str_see_also(func_role)
out = ['.. seealso::', '']
out += self._str_indent(see_also[2:])
return out
def _str_warnings(self):
out = []
if self['Warnings']:
out = ['.. warning::', '']
out += self._str_indent(self['Warnings'])
return out
def _str_index(self):
idx = self['index']
out = []
if len(idx) == 0:
return out
out += ['.. index:: %s' % idx.get('default','')]
for section, references in idx.items():
if section == 'default':
continue
elif section == 'refguide':
out += [' single: %s' % (', '.join(references))]
else:
out += [' %s: %s' % (section, ','.join(references))]
return out
def _str_references(self):
out = []
if self['References']:
out += self._str_header('References')
if isinstance(self['References'], str):
self['References'] = [self['References']]
out.extend(self['References'])
out += ['']
# Latex collects all references to a separate bibliography,
# so we need to insert links to it
if sphinx.__version__ >= "0.6":
out += ['.. only:: latex','']
else:
out += ['.. latexonly::','']
items = []
for line in self['References']:
m = re.match(r'.. \[([a-z0-9._-]+)\]', line, re.I)
if m:
items.append(m.group(1))
out += [' ' + ", ".join(["[%s]_" % item for item in items]), '']
return out
def _str_examples(self):
examples_str = "\n".join(self['Examples'])
if (self.use_plots and 'import matplotlib' in examples_str
and 'plot::' not in examples_str):
out = []
out += self._str_header('Examples')
out += ['.. plot::', '']
out += self._str_indent(self['Examples'])
out += ['']
return out
else:
return self._str_section('Examples')
def __str__(self, indent=0, func_role="obj"):
out = []
out += self._str_signature()
out += self._str_index() + ['']
out += self._str_summary()
out += self._str_extended_summary()
out += self._str_param_list('Parameters')
out += self._str_returns()
for param_list in ('Other Parameters', 'Raises', 'Warns'):
out += self._str_param_list(param_list)
out += self._str_warnings()
out += self._str_see_also(func_role)
out += self._str_section('Notes')
out += self._str_references()
out += self._str_examples()
for param_list in ('Attributes', 'Methods'):
out += self._str_member_list(param_list)
out = self._str_indent(out,indent)
return '\n'.join(out)
class SphinxFunctionDoc(SphinxDocString, FunctionDoc):
def __init__(self, obj, doc=None, config={}):
self.load_config(config)
FunctionDoc.__init__(self, obj, doc=doc, config=config)
class SphinxClassDoc(SphinxDocString, ClassDoc):
def __init__(self, obj, doc=None, func_doc=None, config={}):
self.load_config(config)
ClassDoc.__init__(self, obj, doc=doc, func_doc=None, config=config)
class SphinxObjDoc(SphinxDocString):
def __init__(self, obj, doc=None, config={}):
self._f = obj
self.load_config(config)
SphinxDocString.__init__(self, doc, config=config)
def get_doc_object(obj, what=None, doc=None, config={}):
if what is None:
if inspect.isclass(obj):
what = 'class'
elif inspect.ismodule(obj):
what = 'module'
elif isinstance(obj, collections.Callable):
what = 'function'
else:
what = 'object'
if what == 'class':
return SphinxClassDoc(obj, func_doc=SphinxFunctionDoc, doc=doc,
config=config)
elif what in ('function', 'method'):
return SphinxFunctionDoc(obj, doc=doc, config=config)
else:
if doc is None:
doc = pydoc.getdoc(obj)
return SphinxObjDoc(obj, doc, config=config)
scikit-cuda-0.5.1/docs/sphinxext/linkcode.py 0000664 0000000 0000000 00000004713 12614655073 0021057 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
"""
linkcode
~~~~~~~~
Add external links to module code in Python object descriptions.
:copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS.
:license: BSD, see LICENSE for details.
"""
from __future__ import division, absolute_import, print_function
import warnings
import collections
warnings.warn("This extension has been accepted to Sphinx upstream. "
"Use the version from there (Sphinx >= 1.2) "
"https://bitbucket.org/birkenfeld/sphinx/pull-request/47/sphinxextlinkcode",
FutureWarning, stacklevel=1)
from docutils import nodes
from sphinx import addnodes
from sphinx.locale import _
from sphinx.errors import SphinxError
class LinkcodeError(SphinxError):
category = "linkcode error"
def doctree_read(app, doctree):
env = app.builder.env
resolve_target = getattr(env.config, 'linkcode_resolve', None)
if not isinstance(env.config.linkcode_resolve, collections.Callable):
raise LinkcodeError(
"Function `linkcode_resolve` is not given in conf.py")
domain_keys = dict(
py=['module', 'fullname'],
c=['names'],
cpp=['names'],
js=['object', 'fullname'],
)
for objnode in doctree.traverse(addnodes.desc):
domain = objnode.get('domain')
uris = set()
for signode in objnode:
if not isinstance(signode, addnodes.desc_signature):
continue
# Convert signode to a specified format
info = {}
for key in domain_keys.get(domain, []):
value = signode.get(key)
if not value:
value = ''
info[key] = value
if not info:
continue
# Call user code to resolve the link
uri = resolve_target(domain, info)
if not uri:
# no source
continue
if uri in uris or not uri:
# only one link per name, please
continue
uris.add(uri)
onlynode = addnodes.only(expr='html')
onlynode += nodes.reference('', '', internal=False, refuri=uri)
onlynode[0] += nodes.inline('', _('[source]'),
classes=['viewcode-link'])
signode += onlynode
def setup(app):
app.connect('doctree-read', doctree_read)
app.add_config_value('linkcode_resolve', None, '')
scikit-cuda-0.5.1/docs/sphinxext/numpydoc.py 0000664 0000000 0000000 00000014651 12614655073 0021127 0 ustar 00root root 0000000 0000000 """
========
numpydoc
========
Sphinx extension that handles docstrings in the Numpy standard format. [1]
It will:
- Convert Parameters etc. sections to field lists.
- Convert See Also section to a See also entry.
- Renumber references.
- Extract the signature from the docstring, if it can't be determined otherwise.
.. [1] https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt
"""
from __future__ import division, absolute_import, print_function
import sys
import re
import pydoc
import sphinx
import inspect
import collections
if sphinx.__version__ < '1.0.1':
raise RuntimeError("Sphinx 1.0.1 or newer is required")
from docscrape_sphinx import get_doc_object, SphinxDocString
from sphinx.util.compat import Directive
if sys.version_info[0] >= 3:
sixu = lambda s: s
else:
sixu = lambda s: unicode(s, 'unicode_escape')
def mangle_docstrings(app, what, name, obj, options, lines,
reference_offset=[0]):
cfg = dict(
use_plots=app.config.numpydoc_use_plots,
show_class_members=app.config.numpydoc_show_class_members,
show_inherited_class_members=app.config.numpydoc_show_inherited_class_members,
class_members_toctree=app.config.numpydoc_class_members_toctree,
)
if what == 'module':
# Strip top title
title_re = re.compile(sixu('^\\s*[#*=]{4,}\\n[a-z0-9 -]+\\n[#*=]{4,}\\s*'),
re.I|re.S)
lines[:] = title_re.sub(sixu(''), sixu("\n").join(lines)).split(sixu("\n"))
else:
doc = get_doc_object(obj, what, sixu("\n").join(lines), config=cfg)
if sys.version_info[0] >= 3:
doc = str(doc)
else:
doc = unicode(doc)
lines[:] = doc.split(sixu("\n"))
if app.config.numpydoc_edit_link and hasattr(obj, '__name__') and \
obj.__name__:
if hasattr(obj, '__module__'):
v = dict(full_name=sixu("%s.%s") % (obj.__module__, obj.__name__))
else:
v = dict(full_name=obj.__name__)
lines += [sixu(''), sixu('.. htmlonly::'), sixu('')]
lines += [sixu(' %s') % x for x in
(app.config.numpydoc_edit_link % v).split("\n")]
# replace reference numbers so that there are no duplicates
references = []
for line in lines:
line = line.strip()
m = re.match(sixu('^.. \\[([a-z0-9_.-])\\]'), line, re.I)
if m:
references.append(m.group(1))
# start renaming from the longest string, to avoid overwriting parts
references.sort(key=lambda x: -len(x))
if references:
for i, line in enumerate(lines):
for r in references:
if re.match(sixu('^\\d+$'), r):
new_r = sixu("R%d") % (reference_offset[0] + int(r))
else:
new_r = sixu("%s%d") % (r, reference_offset[0])
lines[i] = lines[i].replace(sixu('[%s]_') % r,
sixu('[%s]_') % new_r)
lines[i] = lines[i].replace(sixu('.. [%s]') % r,
sixu('.. [%s]') % new_r)
reference_offset[0] += len(references)
def mangle_signature(app, what, name, obj, options, sig, retann):
# Do not try to inspect classes that don't define `__init__`
if (inspect.isclass(obj) and
(not hasattr(obj, '__init__') or
'initializes x; see ' in pydoc.getdoc(obj.__init__))):
return '', ''
if not (isinstance(obj, collections.Callable) or hasattr(obj, '__argspec_is_invalid_')): return
if not hasattr(obj, '__doc__'): return
doc = SphinxDocString(pydoc.getdoc(obj))
if doc['Signature']:
sig = re.sub(sixu("^[^(]*"), sixu(""), doc['Signature'])
return sig, sixu('')
def setup(app, get_doc_object_=get_doc_object):
if not hasattr(app, 'add_config_value'):
return # probably called by nose, better bail out
global get_doc_object
get_doc_object = get_doc_object_
app.connect('autodoc-process-docstring', mangle_docstrings)
app.connect('autodoc-process-signature', mangle_signature)
app.add_config_value('numpydoc_edit_link', None, False)
app.add_config_value('numpydoc_use_plots', None, False)
app.add_config_value('numpydoc_show_class_members', True, True)
app.add_config_value('numpydoc_show_inherited_class_members', True, True)
app.add_config_value('numpydoc_class_members_toctree', True, True)
# Extra mangling domains
app.add_domain(NumpyPythonDomain)
app.add_domain(NumpyCDomain)
#------------------------------------------------------------------------------
# Docstring-mangling domains
#------------------------------------------------------------------------------
from docutils.statemachine import ViewList
from sphinx.domains.c import CDomain
from sphinx.domains.python import PythonDomain
class ManglingDomainBase(object):
directive_mangling_map = {}
def __init__(self, *a, **kw):
super(ManglingDomainBase, self).__init__(*a, **kw)
self.wrap_mangling_directives()
def wrap_mangling_directives(self):
for name, objtype in list(self.directive_mangling_map.items()):
self.directives[name] = wrap_mangling_directive(
self.directives[name], objtype)
class NumpyPythonDomain(ManglingDomainBase, PythonDomain):
name = 'np'
directive_mangling_map = {
'function': 'function',
'class': 'class',
'exception': 'class',
'method': 'function',
'classmethod': 'function',
'staticmethod': 'function',
'attribute': 'attribute',
}
indices = []
class NumpyCDomain(ManglingDomainBase, CDomain):
name = 'np-c'
directive_mangling_map = {
'function': 'function',
'member': 'attribute',
'macro': 'function',
'type': 'class',
'var': 'object',
}
def wrap_mangling_directive(base_directive, objtype):
class directive(base_directive):
def run(self):
env = self.state.document.settings.env
name = None
if self.arguments:
m = re.match(r'^(.*\s+)?(.*?)(\(.*)?', self.arguments[0])
name = m.group(2).strip()
if not name:
name = self.arguments[0]
lines = list(self.content)
mangle_docstrings(env.app, objtype, name, None, None, lines)
self.content = ViewList(lines, self.content.parent)
return base_directive.run(self)
return directive
scikit-cuda-0.5.1/docs/sphinxext/phantom_import.py 0000664 0000000 0000000 00000013336 12614655073 0022330 0 ustar 00root root 0000000 0000000 """
==============
phantom_import
==============
Sphinx extension to make directives from ``sphinx.ext.autodoc`` and similar
extensions to use docstrings loaded from an XML file.
This extension loads an XML file in the Pydocweb format [1] and
creates a dummy module that contains the specified docstrings. This
can be used to get the current docstrings from a Pydocweb instance
without needing to rebuild the documented module.
.. [1] http://code.google.com/p/pydocweb
"""
from __future__ import division, absolute_import, print_function
import imp, sys, compiler, types, os, inspect, re
def setup(app):
app.connect('builder-inited', initialize)
app.add_config_value('phantom_import_file', None, True)
def initialize(app):
fn = app.config.phantom_import_file
if (fn and os.path.isfile(fn)):
print("[numpydoc] Phantom importing modules from", fn, "...")
import_phantom_module(fn)
#------------------------------------------------------------------------------
# Creating 'phantom' modules from an XML description
#------------------------------------------------------------------------------
def import_phantom_module(xml_file):
"""
Insert a fake Python module to sys.modules, based on a XML file.
The XML file is expected to conform to Pydocweb DTD. The fake
module will contain dummy objects, which guarantee the following:
- Docstrings are correct.
- Class inheritance relationships are correct (if present in XML).
- Function argspec is *NOT* correct (even if present in XML).
Instead, the function signature is prepended to the function docstring.
- Class attributes are *NOT* correct; instead, they are dummy objects.
Parameters
----------
xml_file : str
Name of an XML file to read
"""
import lxml.etree as etree
object_cache = {}
tree = etree.parse(xml_file)
root = tree.getroot()
# Sort items so that
# - Base classes come before classes inherited from them
# - Modules come before their contents
all_nodes = dict([(n.attrib['id'], n) for n in root])
def _get_bases(node, recurse=False):
bases = [x.attrib['ref'] for x in node.findall('base')]
if recurse:
j = 0
while True:
try:
b = bases[j]
except IndexError: break
if b in all_nodes:
bases.extend(_get_bases(all_nodes[b]))
j += 1
return bases
type_index = ['module', 'class', 'callable', 'object']
def base_cmp(a, b):
x = cmp(type_index.index(a.tag), type_index.index(b.tag))
if x != 0: return x
if a.tag == 'class' and b.tag == 'class':
a_bases = _get_bases(a, recurse=True)
b_bases = _get_bases(b, recurse=True)
x = cmp(len(a_bases), len(b_bases))
if x != 0: return x
if a.attrib['id'] in b_bases: return -1
if b.attrib['id'] in a_bases: return 1
return cmp(a.attrib['id'].count('.'), b.attrib['id'].count('.'))
nodes = root.getchildren()
nodes.sort(base_cmp)
# Create phantom items
for node in nodes:
name = node.attrib['id']
doc = (node.text or '').decode('string-escape') + "\n"
if doc == "\n": doc = ""
# create parent, if missing
parent = name
while True:
parent = '.'.join(parent.split('.')[:-1])
if not parent: break
if parent in object_cache: break
obj = imp.new_module(parent)
object_cache[parent] = obj
sys.modules[parent] = obj
# create object
if node.tag == 'module':
obj = imp.new_module(name)
obj.__doc__ = doc
sys.modules[name] = obj
elif node.tag == 'class':
bases = [object_cache[b] for b in _get_bases(node)
if b in object_cache]
bases.append(object)
init = lambda self: None
init.__doc__ = doc
obj = type(name, tuple(bases), {'__doc__': doc, '__init__': init})
obj.__name__ = name.split('.')[-1]
elif node.tag == 'callable':
funcname = node.attrib['id'].split('.')[-1]
argspec = node.attrib.get('argspec')
if argspec:
argspec = re.sub('^[^(]*', '', argspec)
doc = "%s%s\n\n%s" % (funcname, argspec, doc)
obj = lambda: 0
obj.__argspec_is_invalid_ = True
if sys.version_info[0] >= 3:
obj.__name__ = funcname
else:
obj.func_name = funcname
obj.__name__ = name
obj.__doc__ = doc
if inspect.isclass(object_cache[parent]):
obj.__objclass__ = object_cache[parent]
else:
class Dummy(object): pass
obj = Dummy()
obj.__name__ = name
obj.__doc__ = doc
if inspect.isclass(object_cache[parent]):
obj.__get__ = lambda: None
object_cache[name] = obj
if parent:
if inspect.ismodule(object_cache[parent]):
obj.__module__ = parent
setattr(object_cache[parent], name.split('.')[-1], obj)
# Populate items
for node in root:
obj = object_cache.get(node.attrib['id'])
if obj is None: continue
for ref in node.findall('ref'):
if node.tag == 'class':
if ref.attrib['ref'].startswith(node.attrib['id'] + '.'):
setattr(obj, ref.attrib['name'],
object_cache.get(ref.attrib['ref']))
else:
setattr(obj, ref.attrib['name'],
object_cache.get(ref.attrib['ref']))
scikit-cuda-0.5.1/docs/sphinxext/plot_directive.py 0000664 0000000 0000000 00000050062 12614655073 0022301 0 ustar 00root root 0000000 0000000 """
A special directive for generating a matplotlib plot.
.. warning::
This is a hacked version of plot_directive.py from Matplotlib.
It's very much subject to change!
Usage
-----
Can be used like this::
.. plot:: examples/example.py
.. plot::
import matplotlib.pyplot as plt
plt.plot([1,2,3], [4,5,6])
.. plot::
A plotting example:
>>> import matplotlib.pyplot as plt
>>> plt.plot([1,2,3], [4,5,6])
The content is interpreted as doctest formatted if it has a line starting
with ``>>>``.
The ``plot`` directive supports the options
format : {'python', 'doctest'}
Specify the format of the input
include-source : bool
Whether to display the source code. Default can be changed in conf.py
and the ``image`` directive options ``alt``, ``height``, ``width``,
``scale``, ``align``, ``class``.
Configuration options
---------------------
The plot directive has the following configuration options:
plot_include_source
Default value for the include-source option
plot_pre_code
Code that should be executed before each plot.
plot_basedir
Base directory, to which plot:: file names are relative to.
(If None or empty, file names are relative to the directoly where
the file containing the directive is.)
plot_formats
File formats to generate. List of tuples or strings::
[(suffix, dpi), suffix, ...]
that determine the file format and the DPI. For entries whose
DPI was omitted, sensible defaults are chosen.
plot_html_show_formats
Whether to show links to the files in HTML.
TODO
----
* Refactor Latex output; now it's plain images, but it would be nice
to make them appear side-by-side, or in floats.
"""
from __future__ import division, absolute_import, print_function
import sys, os, glob, shutil, imp, warnings, re, textwrap, traceback
import sphinx
if sys.version_info[0] >= 3:
from io import StringIO
else:
from io import StringIO
import warnings
warnings.warn("A plot_directive module is also available under "
"matplotlib.sphinxext; expect this numpydoc.plot_directive "
"module to be deprecated after relevant features have been "
"integrated there.",
FutureWarning, stacklevel=2)
#------------------------------------------------------------------------------
# Registration hook
#------------------------------------------------------------------------------
def setup(app):
setup.app = app
setup.config = app.config
setup.confdir = app.confdir
app.add_config_value('plot_pre_code', '', True)
app.add_config_value('plot_include_source', False, True)
app.add_config_value('plot_formats', ['png', 'hires.png', 'pdf'], True)
app.add_config_value('plot_basedir', None, True)
app.add_config_value('plot_html_show_formats', True, True)
app.add_directive('plot', plot_directive, True, (0, 1, False),
**plot_directive_options)
#------------------------------------------------------------------------------
# plot:: directive
#------------------------------------------------------------------------------
from docutils.parsers.rst import directives
from docutils import nodes
def plot_directive(name, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
return run(arguments, content, options, state_machine, state, lineno)
plot_directive.__doc__ = __doc__
def _option_boolean(arg):
if not arg or not arg.strip():
# no argument given, assume used as a flag
return True
elif arg.strip().lower() in ('no', '0', 'false'):
return False
elif arg.strip().lower() in ('yes', '1', 'true'):
return True
else:
raise ValueError('"%s" unknown boolean' % arg)
def _option_format(arg):
return directives.choice(arg, ('python', 'lisp'))
def _option_align(arg):
return directives.choice(arg, ("top", "middle", "bottom", "left", "center",
"right"))
plot_directive_options = {'alt': directives.unchanged,
'height': directives.length_or_unitless,
'width': directives.length_or_percentage_or_unitless,
'scale': directives.nonnegative_int,
'align': _option_align,
'class': directives.class_option,
'include-source': _option_boolean,
'format': _option_format,
}
#------------------------------------------------------------------------------
# Generating output
#------------------------------------------------------------------------------
from docutils import nodes, utils
try:
# Sphinx depends on either Jinja or Jinja2
import jinja2
def format_template(template, **kw):
return jinja2.Template(template).render(**kw)
except ImportError:
import jinja
def format_template(template, **kw):
return jinja.from_string(template, **kw)
TEMPLATE = """
{{ source_code }}
{{ only_html }}
{% if source_link or (html_show_formats and not multi_image) %}
(
{%- if source_link -%}
`Source code <{{ source_link }}>`__
{%- endif -%}
{%- if html_show_formats and not multi_image -%}
{%- for img in images -%}
{%- for fmt in img.formats -%}
{%- if source_link or not loop.first -%}, {% endif -%}
`{{ fmt }} <{{ dest_dir }}/{{ img.basename }}.{{ fmt }}>`__
{%- endfor -%}
{%- endfor -%}
{%- endif -%}
)
{% endif %}
{% for img in images %}
.. figure:: {{ build_dir }}/{{ img.basename }}.png
{%- for option in options %}
{{ option }}
{% endfor %}
{% if html_show_formats and multi_image -%}
(
{%- for fmt in img.formats -%}
{%- if not loop.first -%}, {% endif -%}
`{{ fmt }} <{{ dest_dir }}/{{ img.basename }}.{{ fmt }}>`__
{%- endfor -%}
)
{%- endif -%}
{% endfor %}
{{ only_latex }}
{% for img in images %}
.. image:: {{ build_dir }}/{{ img.basename }}.pdf
{% endfor %}
"""
class ImageFile(object):
def __init__(self, basename, dirname):
self.basename = basename
self.dirname = dirname
self.formats = []
def filename(self, format):
return os.path.join(self.dirname, "%s.%s" % (self.basename, format))
def filenames(self):
return [self.filename(fmt) for fmt in self.formats]
def run(arguments, content, options, state_machine, state, lineno):
if arguments and content:
raise RuntimeError("plot:: directive can't have both args and content")
document = state_machine.document
config = document.settings.env.config
options.setdefault('include-source', config.plot_include_source)
# determine input
rst_file = document.attributes['source']
rst_dir = os.path.dirname(rst_file)
if arguments:
if not config.plot_basedir:
source_file_name = os.path.join(rst_dir,
directives.uri(arguments[0]))
else:
source_file_name = os.path.join(setup.confdir, config.plot_basedir,
directives.uri(arguments[0]))
code = open(source_file_name, 'r').read()
output_base = os.path.basename(source_file_name)
else:
source_file_name = rst_file
code = textwrap.dedent("\n".join(map(str, content)))
counter = document.attributes.get('_plot_counter', 0) + 1
document.attributes['_plot_counter'] = counter
base, ext = os.path.splitext(os.path.basename(source_file_name))
output_base = '%s-%d.py' % (base, counter)
base, source_ext = os.path.splitext(output_base)
if source_ext in ('.py', '.rst', '.txt'):
output_base = base
else:
source_ext = ''
# ensure that LaTeX includegraphics doesn't choke in foo.bar.pdf filenames
output_base = output_base.replace('.', '-')
# is it in doctest format?
is_doctest = contains_doctest(code)
if 'format' in options:
if options['format'] == 'python':
is_doctest = False
else:
is_doctest = True
# determine output directory name fragment
source_rel_name = relpath(source_file_name, setup.confdir)
source_rel_dir = os.path.dirname(source_rel_name)
while source_rel_dir.startswith(os.path.sep):
source_rel_dir = source_rel_dir[1:]
# build_dir: where to place output files (temporarily)
build_dir = os.path.join(os.path.dirname(setup.app.doctreedir),
'plot_directive',
source_rel_dir)
if not os.path.exists(build_dir):
os.makedirs(build_dir)
# output_dir: final location in the builder's directory
dest_dir = os.path.abspath(os.path.join(setup.app.builder.outdir,
source_rel_dir))
# how to link to files from the RST file
dest_dir_link = os.path.join(relpath(setup.confdir, rst_dir),
source_rel_dir).replace(os.path.sep, '/')
build_dir_link = relpath(build_dir, rst_dir).replace(os.path.sep, '/')
source_link = dest_dir_link + '/' + output_base + source_ext
# make figures
try:
results = makefig(code, source_file_name, build_dir, output_base,
config)
errors = []
except PlotError as err:
reporter = state.memo.reporter
sm = reporter.system_message(
2, "Exception occurred in plotting %s: %s" % (output_base, err),
line=lineno)
results = [(code, [])]
errors = [sm]
# generate output restructuredtext
total_lines = []
for j, (code_piece, images) in enumerate(results):
if options['include-source']:
if is_doctest:
lines = ['']
lines += [row.rstrip() for row in code_piece.split('\n')]
else:
lines = ['.. code-block:: python', '']
lines += [' %s' % row.rstrip()
for row in code_piece.split('\n')]
source_code = "\n".join(lines)
else:
source_code = ""
opts = [':%s: %s' % (key, val) for key, val in list(options.items())
if key in ('alt', 'height', 'width', 'scale', 'align', 'class')]
only_html = ".. only:: html"
only_latex = ".. only:: latex"
if j == 0:
src_link = source_link
else:
src_link = None
result = format_template(
TEMPLATE,
dest_dir=dest_dir_link,
build_dir=build_dir_link,
source_link=src_link,
multi_image=len(images) > 1,
only_html=only_html,
only_latex=only_latex,
options=opts,
images=images,
source_code=source_code,
html_show_formats=config.plot_html_show_formats)
total_lines.extend(result.split("\n"))
total_lines.extend("\n")
if total_lines:
state_machine.insert_input(total_lines, source=source_file_name)
# copy image files to builder's output directory
if not os.path.exists(dest_dir):
os.makedirs(dest_dir)
for code_piece, images in results:
for img in images:
for fn in img.filenames():
shutil.copyfile(fn, os.path.join(dest_dir,
os.path.basename(fn)))
# copy script (if necessary)
if source_file_name == rst_file:
target_name = os.path.join(dest_dir, output_base + source_ext)
f = open(target_name, 'w')
f.write(unescape_doctest(code))
f.close()
return errors
#------------------------------------------------------------------------------
# Run code and capture figures
#------------------------------------------------------------------------------
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import matplotlib.image as image
from matplotlib import _pylab_helpers
import exceptions
def contains_doctest(text):
try:
# check if it's valid Python as-is
compile(text, '', 'exec')
return False
except SyntaxError:
pass
r = re.compile(r'^\s*>>>', re.M)
m = r.search(text)
return bool(m)
def unescape_doctest(text):
"""
Extract code from a piece of text, which contains either Python code
or doctests.
"""
if not contains_doctest(text):
return text
code = ""
for line in text.split("\n"):
m = re.match(r'^\s*(>>>|\.\.\.) (.*)$', line)
if m:
code += m.group(2) + "\n"
elif line.strip():
code += "# " + line.strip() + "\n"
else:
code += "\n"
return code
def split_code_at_show(text):
"""
Split code at plt.show()
"""
parts = []
is_doctest = contains_doctest(text)
part = []
for line in text.split("\n"):
if (not is_doctest and line.strip() == 'plt.show()') or \
(is_doctest and line.strip() == '>>> plt.show()'):
part.append(line)
parts.append("\n".join(part))
part = []
else:
part.append(line)
if "\n".join(part).strip():
parts.append("\n".join(part))
return parts
class PlotError(RuntimeError):
pass
def run_code(code, code_path, ns=None):
# Change the working directory to the directory of the example, so
# it can get at its data files, if any.
pwd = os.getcwd()
old_sys_path = list(sys.path)
if code_path is not None:
dirname = os.path.abspath(os.path.dirname(code_path))
os.chdir(dirname)
sys.path.insert(0, dirname)
# Redirect stdout
stdout = sys.stdout
sys.stdout = StringIO()
# Reset sys.argv
old_sys_argv = sys.argv
sys.argv = [code_path]
try:
try:
code = unescape_doctest(code)
if ns is None:
ns = {}
if not ns:
exec(setup.config.plot_pre_code, ns)
exec(code, ns)
except (Exception, SystemExit) as err:
raise PlotError(traceback.format_exc())
finally:
os.chdir(pwd)
sys.argv = old_sys_argv
sys.path[:] = old_sys_path
sys.stdout = stdout
return ns
#------------------------------------------------------------------------------
# Generating figures
#------------------------------------------------------------------------------
def out_of_date(original, derived):
"""
Returns True if derivative is out-of-date wrt original,
both of which are full file paths.
"""
return (not os.path.exists(derived)
or os.stat(derived).st_mtime < os.stat(original).st_mtime)
def makefig(code, code_path, output_dir, output_base, config):
"""
Run a pyplot script *code* and save the images under *output_dir*
with file names derived from *output_base*
"""
# -- Parse format list
default_dpi = {'png': 80, 'hires.png': 200, 'pdf': 50}
formats = []
for fmt in config.plot_formats:
if isinstance(fmt, str):
formats.append((fmt, default_dpi.get(fmt, 80)))
elif type(fmt) in (tuple, list) and len(fmt)==2:
formats.append((str(fmt[0]), int(fmt[1])))
else:
raise PlotError('invalid image format "%r" in plot_formats' % fmt)
# -- Try to determine if all images already exist
code_pieces = split_code_at_show(code)
# Look for single-figure output files first
all_exists = True
img = ImageFile(output_base, output_dir)
for format, dpi in formats:
if out_of_date(code_path, img.filename(format)):
all_exists = False
break
img.formats.append(format)
if all_exists:
return [(code, [img])]
# Then look for multi-figure output files
results = []
all_exists = True
for i, code_piece in enumerate(code_pieces):
images = []
for j in range(1000):
img = ImageFile('%s_%02d_%02d' % (output_base, i, j), output_dir)
for format, dpi in formats:
if out_of_date(code_path, img.filename(format)):
all_exists = False
break
img.formats.append(format)
# assume that if we have one, we have them all
if not all_exists:
all_exists = (j > 0)
break
images.append(img)
if not all_exists:
break
results.append((code_piece, images))
if all_exists:
return results
# -- We didn't find the files, so build them
results = []
ns = {}
for i, code_piece in enumerate(code_pieces):
# Clear between runs
plt.close('all')
# Run code
run_code(code_piece, code_path, ns)
# Collect images
images = []
fig_managers = _pylab_helpers.Gcf.get_all_fig_managers()
for j, figman in enumerate(fig_managers):
if len(fig_managers) == 1 and len(code_pieces) == 1:
img = ImageFile(output_base, output_dir)
else:
img = ImageFile("%s_%02d_%02d" % (output_base, i, j),
output_dir)
images.append(img)
for format, dpi in formats:
try:
figman.canvas.figure.savefig(img.filename(format), dpi=dpi)
except exceptions.BaseException as err:
raise PlotError(traceback.format_exc())
img.formats.append(format)
# Results
results.append((code_piece, images))
return results
#------------------------------------------------------------------------------
# Relative pathnames
#------------------------------------------------------------------------------
try:
from os.path import relpath
except ImportError:
# Copied from Python 2.7
if 'posix' in sys.builtin_module_names:
def relpath(path, start=os.path.curdir):
"""Return a relative version of a path"""
from os.path import sep, curdir, join, abspath, commonprefix, \
pardir
if not path:
raise ValueError("no path specified")
start_list = abspath(start).split(sep)
path_list = abspath(path).split(sep)
# Work out how much of the filepath is shared by start and path.
i = len(commonprefix([start_list, path_list]))
rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
if not rel_list:
return curdir
return join(*rel_list)
elif 'nt' in sys.builtin_module_names:
def relpath(path, start=os.path.curdir):
"""Return a relative version of a path"""
from os.path import sep, curdir, join, abspath, commonprefix, \
pardir, splitunc
if not path:
raise ValueError("no path specified")
start_list = abspath(start).split(sep)
path_list = abspath(path).split(sep)
if start_list[0].lower() != path_list[0].lower():
unc_path, rest = splitunc(path)
unc_start, rest = splitunc(start)
if bool(unc_path) ^ bool(unc_start):
raise ValueError("Cannot mix UNC and non-UNC paths (%s and %s)"
% (path, start))
else:
raise ValueError("path is on drive %s, start on drive %s"
% (path_list[0], start_list[0]))
# Work out how much of the filepath is shared by start and path.
for i in range(min(len(start_list), len(path_list))):
if start_list[i].lower() != path_list[i].lower():
break
else:
i += 1
rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
if not rel_list:
return curdir
return join(*rel_list)
else:
raise RuntimeError("Unsupported platform (no relpath available!)")
scikit-cuda-0.5.1/docs/sphinxext/traitsdoc.py 0000664 0000000 0000000 00000010261 12614655073 0021256 0 ustar 00root root 0000000 0000000 """
=========
traitsdoc
=========
Sphinx extension that handles docstrings in the Numpy standard format, [1]
and support Traits [2].
This extension can be used as a replacement for ``numpydoc`` when support
for Traits is required.
.. [1] http://projects.scipy.org/numpy/wiki/CodingStyleGuidelines#docstring-standard
.. [2] http://code.enthought.com/projects/traits/
"""
from __future__ import division, absolute_import, print_function
import inspect
import os
import pydoc
import collections
from . import docscrape
from . import docscrape_sphinx
from .docscrape_sphinx import SphinxClassDoc, SphinxFunctionDoc, SphinxDocString
from . import numpydoc
from . import comment_eater
class SphinxTraitsDoc(SphinxClassDoc):
def __init__(self, cls, modulename='', func_doc=SphinxFunctionDoc):
if not inspect.isclass(cls):
raise ValueError("Initialise using a class. Got %r" % cls)
self._cls = cls
if modulename and not modulename.endswith('.'):
modulename += '.'
self._mod = modulename
self._name = cls.__name__
self._func_doc = func_doc
docstring = pydoc.getdoc(cls)
docstring = docstring.split('\n')
# De-indent paragraph
try:
indent = min(len(s) - len(s.lstrip()) for s in docstring
if s.strip())
except ValueError:
indent = 0
for n,line in enumerate(docstring):
docstring[n] = docstring[n][indent:]
self._doc = docscrape.Reader(docstring)
self._parsed_data = {
'Signature': '',
'Summary': '',
'Description': [],
'Extended Summary': [],
'Parameters': [],
'Returns': [],
'Raises': [],
'Warns': [],
'Other Parameters': [],
'Traits': [],
'Methods': [],
'See Also': [],
'Notes': [],
'References': '',
'Example': '',
'Examples': '',
'index': {}
}
self._parse()
def _str_summary(self):
return self['Summary'] + ['']
def _str_extended_summary(self):
return self['Description'] + self['Extended Summary'] + ['']
def __str__(self, indent=0, func_role="func"):
out = []
out += self._str_signature()
out += self._str_index() + ['']
out += self._str_summary()
out += self._str_extended_summary()
for param_list in ('Parameters', 'Traits', 'Methods',
'Returns','Raises'):
out += self._str_param_list(param_list)
out += self._str_see_also("obj")
out += self._str_section('Notes')
out += self._str_references()
out += self._str_section('Example')
out += self._str_section('Examples')
out = self._str_indent(out,indent)
return '\n'.join(out)
def looks_like_issubclass(obj, classname):
""" Return True if the object has a class or superclass with the given class
name.
Ignores old-style classes.
"""
t = obj
if t.__name__ == classname:
return True
for klass in t.__mro__:
if klass.__name__ == classname:
return True
return False
def get_doc_object(obj, what=None, config=None):
if what is None:
if inspect.isclass(obj):
what = 'class'
elif inspect.ismodule(obj):
what = 'module'
elif isinstance(obj, collections.Callable):
what = 'function'
else:
what = 'object'
if what == 'class':
doc = SphinxTraitsDoc(obj, '', func_doc=SphinxFunctionDoc, config=config)
if looks_like_issubclass(obj, 'HasTraits'):
for name, trait, comment in comment_eater.get_class_traits(obj):
# Exclude private traits.
if not name.startswith('_'):
doc['Traits'].append((name, trait, comment.splitlines()))
return doc
elif what in ('function', 'method'):
return SphinxFunctionDoc(obj, '', config=config)
else:
return SphinxDocString(pydoc.getdoc(obj), config=config)
def setup(app):
# init numpydoc
numpydoc.setup(app, get_doc_object)
scikit-cuda-0.5.1/ez_setup.py 0000664 0000000 0000000 00000026250 12614655073 0016143 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
"""
Setuptools bootstrapping installer.
Run this script to install or upgrade setuptools.
"""
import os
import shutil
import sys
import tempfile
import zipfile
import optparse
import subprocess
import platform
import textwrap
import contextlib
import warnings
from distutils import log
try:
from urllib.request import urlopen
except ImportError:
from urllib2 import urlopen
try:
from site import USER_SITE
except ImportError:
USER_SITE = None
DEFAULT_VERSION = "15.1"
DEFAULT_URL = "https://pypi.python.org/packages/source/s/setuptools/"
DEFAULT_SAVE_DIR = os.curdir
def _python_cmd(*args):
"""
Execute a command.
Return True if the command succeeded.
"""
args = (sys.executable,) + args
return subprocess.call(args) == 0
def _install(archive_filename, install_args=()):
"""Install Setuptools."""
with archive_context(archive_filename):
# installing
log.warn('Installing Setuptools')
if not _python_cmd('setup.py', 'install', *install_args):
log.warn('Something went wrong during the installation.')
log.warn('See the error message above.')
# exitcode will be 2
return 2
def _build_egg(egg, archive_filename, to_dir):
"""Build Setuptools egg."""
with archive_context(archive_filename):
# building an egg
log.warn('Building a Setuptools egg in %s', to_dir)
_python_cmd('setup.py', '-q', 'bdist_egg', '--dist-dir', to_dir)
# returning the result
log.warn(egg)
if not os.path.exists(egg):
raise IOError('Could not build the egg.')
class ContextualZipFile(zipfile.ZipFile):
"""Supplement ZipFile class to support context manager for Python 2.6."""
def __enter__(self):
return self
def __exit__(self, type, value, traceback):
self.close()
def __new__(cls, *args, **kwargs):
"""Construct a ZipFile or ContextualZipFile as appropriate."""
if hasattr(zipfile.ZipFile, '__exit__'):
return zipfile.ZipFile(*args, **kwargs)
return super(ContextualZipFile, cls).__new__(cls)
@contextlib.contextmanager
def archive_context(filename):
"""
Unzip filename to a temporary directory, set to the cwd.
The unzipped target is cleaned up after.
"""
tmpdir = tempfile.mkdtemp()
log.warn('Extracting in %s', tmpdir)
old_wd = os.getcwd()
try:
os.chdir(tmpdir)
with ContextualZipFile(filename) as archive:
archive.extractall()
# going in the directory
subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0])
os.chdir(subdir)
log.warn('Now working in %s', subdir)
yield
finally:
os.chdir(old_wd)
shutil.rmtree(tmpdir)
def _do_download(version, download_base, to_dir, download_delay):
"""Download Setuptools."""
egg = os.path.join(to_dir, 'setuptools-%s-py%d.%d.egg'
% (version, sys.version_info[0], sys.version_info[1]))
if not os.path.exists(egg):
archive = download_setuptools(version, download_base,
to_dir, download_delay)
_build_egg(egg, archive, to_dir)
sys.path.insert(0, egg)
# Remove previously-imported pkg_resources if present (see
# https://bitbucket.org/pypa/setuptools/pull-request/7/ for details).
if 'pkg_resources' in sys.modules:
del sys.modules['pkg_resources']
import setuptools
setuptools.bootstrap_install_from = egg
def use_setuptools(
version=DEFAULT_VERSION, download_base=DEFAULT_URL,
to_dir=DEFAULT_SAVE_DIR, download_delay=15):
"""
Ensure that a setuptools version is installed.
Return None. Raise SystemExit if the requested version
or later cannot be installed.
"""
to_dir = os.path.abspath(to_dir)
# prior to importing, capture the module state for
# representative modules.
rep_modules = 'pkg_resources', 'setuptools'
imported = set(sys.modules).intersection(rep_modules)
try:
import pkg_resources
pkg_resources.require("setuptools>=" + version)
# a suitable version is already installed
return
except ImportError:
# pkg_resources not available; setuptools is not installed; download
pass
except pkg_resources.DistributionNotFound:
# no version of setuptools was found; allow download
pass
except pkg_resources.VersionConflict as VC_err:
if imported:
_conflict_bail(VC_err, version)
# otherwise, unload pkg_resources to allow the downloaded version to
# take precedence.
del pkg_resources
_unload_pkg_resources()
return _do_download(version, download_base, to_dir, download_delay)
def _conflict_bail(VC_err, version):
"""
Setuptools was imported prior to invocation, so it is
unsafe to unload it. Bail out.
"""
conflict_tmpl = textwrap.dedent("""
The required version of setuptools (>={version}) is not available,
and can't be installed while this script is running. Please
install a more recent version first, using
'easy_install -U setuptools'.
(Currently using {VC_err.args[0]!r})
""")
msg = conflict_tmpl.format(**locals())
sys.stderr.write(msg)
sys.exit(2)
def _unload_pkg_resources():
del_modules = [
name for name in sys.modules
if name.startswith('pkg_resources')
]
for mod_name in del_modules:
del sys.modules[mod_name]
def _clean_check(cmd, target):
"""
Run the command to download target.
If the command fails, clean up before re-raising the error.
"""
try:
subprocess.check_call(cmd)
except subprocess.CalledProcessError:
if os.access(target, os.F_OK):
os.unlink(target)
raise
def download_file_powershell(url, target):
"""
Download the file at url to target using Powershell.
Powershell will validate trust.
Raise an exception if the command cannot complete.
"""
target = os.path.abspath(target)
ps_cmd = (
"[System.Net.WebRequest]::DefaultWebProxy.Credentials = "
"[System.Net.CredentialCache]::DefaultCredentials; "
"(new-object System.Net.WebClient).DownloadFile(%(url)r, %(target)r)"
% vars()
)
cmd = [
'powershell',
'-Command',
ps_cmd,
]
_clean_check(cmd, target)
def has_powershell():
"""Determine if Powershell is available."""
if platform.system() != 'Windows':
return False
cmd = ['powershell', '-Command', 'echo test']
with open(os.path.devnull, 'wb') as devnull:
try:
subprocess.check_call(cmd, stdout=devnull, stderr=devnull)
except Exception:
return False
return True
download_file_powershell.viable = has_powershell
def download_file_curl(url, target):
cmd = ['curl', url, '--silent', '--output', target]
_clean_check(cmd, target)
def has_curl():
cmd = ['curl', '--version']
with open(os.path.devnull, 'wb') as devnull:
try:
subprocess.check_call(cmd, stdout=devnull, stderr=devnull)
except Exception:
return False
return True
download_file_curl.viable = has_curl
def download_file_wget(url, target):
cmd = ['wget', url, '--quiet', '--output-document', target]
_clean_check(cmd, target)
def has_wget():
cmd = ['wget', '--version']
with open(os.path.devnull, 'wb') as devnull:
try:
subprocess.check_call(cmd, stdout=devnull, stderr=devnull)
except Exception:
return False
return True
download_file_wget.viable = has_wget
def download_file_insecure(url, target):
"""Use Python to download the file, without connection authentication."""
src = urlopen(url)
try:
# Read all the data in one block.
data = src.read()
finally:
src.close()
# Write all the data in one block to avoid creating a partial file.
with open(target, "wb") as dst:
dst.write(data)
download_file_insecure.viable = lambda: True
def get_best_downloader():
downloaders = (
download_file_powershell,
download_file_curl,
download_file_wget,
download_file_insecure,
)
viable_downloaders = (dl for dl in downloaders if dl.viable())
return next(viable_downloaders, None)
def download_setuptools(
version=DEFAULT_VERSION, download_base=DEFAULT_URL,
to_dir=DEFAULT_SAVE_DIR, delay=15,
downloader_factory=get_best_downloader):
"""
Download setuptools from a specified location and return its filename.
`version` should be a valid setuptools version number that is available
as an sdist for download under the `download_base` URL (which should end
with a '/'). `to_dir` is the directory where the egg will be downloaded.
`delay` is the number of seconds to pause before an actual download
attempt.
``downloader_factory`` should be a function taking no arguments and
returning a function for downloading a URL to a target.
"""
# making sure we use the absolute path
to_dir = os.path.abspath(to_dir)
zip_name = "setuptools-%s.zip" % version
url = download_base + zip_name
saveto = os.path.join(to_dir, zip_name)
if not os.path.exists(saveto): # Avoid repeated downloads
log.warn("Downloading %s", url)
downloader = downloader_factory()
downloader(url, saveto)
return os.path.realpath(saveto)
def _build_install_args(options):
"""
Build the arguments to 'python setup.py install' on the setuptools package.
Returns list of command line arguments.
"""
return ['--user'] if options.user_install else []
def _parse_args():
"""Parse the command line for options."""
parser = optparse.OptionParser()
parser.add_option(
'--user', dest='user_install', action='store_true', default=False,
help='install in user site package (requires Python 2.6 or later)')
parser.add_option(
'--download-base', dest='download_base', metavar="URL",
default=DEFAULT_URL,
help='alternative URL from where to download the setuptools package')
parser.add_option(
'--insecure', dest='downloader_factory', action='store_const',
const=lambda: download_file_insecure, default=get_best_downloader,
help='Use internal, non-validating downloader'
)
parser.add_option(
'--version', help="Specify which version to download",
default=DEFAULT_VERSION,
)
parser.add_option(
'--to-dir',
help="Directory to save (and re-use) package",
default=DEFAULT_SAVE_DIR,
)
options, args = parser.parse_args()
# positional arguments are ignored
return options
def _download_args(options):
"""Return args for download_setuptools function from cmdline args."""
return dict(
version=options.version,
download_base=options.download_base,
downloader_factory=options.downloader_factory,
to_dir=options.to_dir,
)
def main():
"""Install or upgrade setuptools and EasyInstall."""
options = _parse_args()
archive = download_setuptools(**_download_args(options))
return _install(archive, _build_install_args(options))
if __name__ == '__main__':
sys.exit(main())
scikit-cuda-0.5.1/scikits/ 0000775 0000000 0000000 00000000000 12614655073 0015377 5 ustar 00root root 0000000 0000000 scikit-cuda-0.5.1/scikits/__init__.py 0000664 0000000 0000000 00000000250 12614655073 0017505 0 ustar 00root root 0000000 0000000 try:
__import__('pkg_resources').declare_namespace(__name__)
except ImportError:
from pkgutil import extend_path
__path__ = extend_path(__path__, __name__)
scikit-cuda-0.5.1/scikits/cuda/ 0000775 0000000 0000000 00000000000 12614655073 0016313 5 ustar 00root root 0000000 0000000 scikit-cuda-0.5.1/scikits/cuda/__init__.py 0000664 0000000 0000000 00000001303 12614655073 0020421 0 ustar 00root root 0000000 0000000 from __future__ import absolute_import
import os
import warnings
warnings.warn('The scikits.cuda namespace package is deprecated and will be '
'removed in the future; please import the skcuda package '
'instead.', DeprecationWarning, stacklevel=2)
# This import must precede the invocation of extend_path() to work with Python
# 3:
import skcuda
from pkgutil import extend_path
__path__ = extend_path(__path__, 'skcuda')
from .info import __doc__
from .version import __version__
# Needed to ensure correct header location even when modules are import as
# scikits.cuda.something:
install_headers = skcuda.__file__.replace(os.path.basename(skcuda.__file__), '') + 'include'
scikit-cuda-0.5.1/setup.py 0000664 0000000 0000000 00000004433 12614655073 0015444 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import sys, os
from glob import glob
# Install setuptools if it isn't available:
try:
import setuptools
except ImportError:
from ez_setup import use_setuptools
use_setuptools()
from distutils.command.install_headers import install_headers
from setuptools import find_packages
from setuptools import setup
NAME = 'scikit-cuda'
VERSION = '0.5.1'
AUTHOR = 'Lev Givon'
AUTHOR_EMAIL = 'lev@columbia.edu'
URL = 'https://github.com/lebedov/scikit-cuda/'
DESCRIPTION = 'Python interface to GPU-powered libraries'
LONG_DESCRIPTION = DESCRIPTION
DOWNLOAD_URL = URL
LICENSE = 'BSD'
CLASSIFIERS = [
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3.4',
'Topic :: Scientific/Engineering',
'Topic :: Software Development']
NAMESPACE_PACKAGES = ['scikits']
PACKAGES = find_packages()
on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
if not on_rtd:
install_requires = ['mako >= 1.0.1',
'numpy >= 1.2.0',
'pycuda >= 2014.1']
tests_require = ['nose >= 0.11',
'scipy >= 0.14.0'],
extras_require = dict(scipy = ['scipy >= 0.14.0'],
sphinx_rtd_theme = ['sphinx_rtd_theme >= 0.1.6'])
else:
install_requires = []
tests_require = []
extras_require = {}
if __name__ == "__main__":
if os.path.exists('MANIFEST'):
os.remove('MANIFEST')
setup(
name = NAME,
version = VERSION,
author = AUTHOR,
author_email = AUTHOR_EMAIL,
license = LICENSE,
classifiers = CLASSIFIERS,
description = DESCRIPTION,
long_description = LONG_DESCRIPTION,
url = URL,
namespace_packages = NAMESPACE_PACKAGES,
packages = PACKAGES,
include_package_data = True,
install_requires = install_requires,
tests_require = tests_require,
extras_require = extras_require,
test_suite='nose.collector')
scikit-cuda-0.5.1/skcuda/ 0000775 0000000 0000000 00000000000 12614655073 0015200 5 ustar 00root root 0000000 0000000 scikit-cuda-0.5.1/skcuda/__init__.py 0000664 0000000 0000000 00000000603 12614655073 0017310 0 ustar 00root root 0000000 0000000 from __future__ import absolute_import
try:
__import__('pkg_resources').declare_namespace(__name__)
except ImportError:
from pkgutil import extend_path
__path__ = extend_path(__path__, __name__)
from .info import __doc__
from .version import __version__
# Location of headers:
import os
install_headers = \
__file__.replace(os.path.basename(__file__), '') + 'include'
scikit-cuda-0.5.1/skcuda/autoinit.py 0000664 0000000 0000000 00000000470 12614655073 0017407 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
"""
Autoinitialize CUDA tools.
"""
from __future__ import absolute_import
import atexit
from . import misc
try:
import cula
_has_cula = True
except (ImportError, OSError):
_has_cula = False
misc.init()
if _has_cula:
cula.culaInitialize()
atexit.register(misc.shutdown)
scikit-cuda-0.5.1/skcuda/cublas.py 0000664 0000000 0000000 00000757103 12614655073 0017040 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
"""
Python interface to CUBLAS functions.
Note: this module does not explicitly depend on PyCUDA.
"""
from __future__ import absolute_import
import re
import os
import sys
import warnings
import ctypes
import ctypes.util
import atexit
import numpy as np
from string import Template
from . import cuda
from . import utils
# Load library:
_version_list = [7.5, 7.0, 6.5, 6.0, 5.5, 5.0, 4.0]
if 'linux' in sys.platform:
_libcublas_libname_list = ['libcublas.so'] + \
['libcublas.so.%s' % v for v in _version_list]
elif sys.platform == 'darwin':
_libcublas_libname_list = ['libcublas.dylib']
elif sys.platform == 'win32':
if sys.maxsize > 2**32:
_libcublas_libname_list = ['cublas.dll'] + \
['cublas64_%s.dll' % int(10*v) for v in _version_list]
else:
_libcublas_libname_list = ['cublas.dll'] + \
['cublas32_%s.dll' % int(10*v) for v in _version_list]
else:
raise RuntimeError('unsupported platform')
# Print understandable error message when library cannot be found:
_libcublas = None
for _libcublas_libname in _libcublas_libname_list:
try:
if sys.platform == 'win32':
_libcublas = ctypes.windll.LoadLibrary(_libcublas_libname)
else:
_libcublas = ctypes.cdll.LoadLibrary(_libcublas_libname)
except OSError:
pass
else:
break
if _libcublas == None:
raise OSError('cublas library not found')
# Generic CUBLAS error:
class cublasError(Exception):
"""CUBLAS error"""
pass
# Exceptions corresponding to different CUBLAS errors:
class cublasNotInitialized(cublasError):
"""CUBLAS library not initialized."""
pass
class cublasAllocFailed(cublasError):
"""Resource allocation failed."""
pass
class cublasInvalidValue(cublasError):
"""Unsupported numerical value was passed to function."""
pass
class cublasArchMismatch(cublasError):
"""Function requires an architectural feature absent from the device."""
pass
class cublasMappingError(cublasError):
"""Access to GPU memory space failed."""
pass
class cublasExecutionFailed(cublasError):
"""GPU program failed to execute."""
pass
class cublasInternalError(cublasError):
"""An internal CUBLAS operation failed."""
pass
cublasExceptions = {
0x1: cublasNotInitialized,
0x3: cublasAllocFailed,
0x7: cublasInvalidValue,
0x8: cublasArchMismatch,
0xb: cublasMappingError,
0xd: cublasExecutionFailed,
0xe: cublasInternalError,
}
_CUBLAS_OP = {
0: 0, # CUBLAS_OP_N
'n': 0,
'N': 0,
1: 1, # CUBLAS_OP_T
't': 1,
'T': 1,
2: 2, # CUBLAS_OP_C
'c': 2,
'C': 2,
}
_CUBLAS_FILL_MODE = {
0: 0, # CUBLAS_FILL_MODE_LOWER
'l': 0,
'L': 0,
1: 1, # CUBLAS_FILL_MODE_UPPER
'u': 1,
'U': 1,
}
_CUBLAS_DIAG = {
0: 0, # CUBLAS_DIAG_NON_UNIT,
'n': 0,
'N': 0,
1: 1, # CUBLAS_DIAG_UNIT
'u': 1,
'U': 1,
}
_CUBLAS_SIDE_MODE = {
0: 0, # CUBLAS_SIDE_LEFT
'l': 0,
'L': 0,
1: 1, # CUBLAS_SIDE_RIGHT
'r': 1,
'R': 1
}
class _types:
"""Some alias types."""
handle = ctypes.c_void_p
stream = ctypes.c_void_p
def cublasCheckStatus(status):
"""
Raise CUBLAS exception
Raise an exception corresponding to the specified CUBLAS error
code.
Parameters
----------
status : int
CUBLAS error code.
See Also
--------
cublasExceptions
"""
if status != 0:
try:
raise cublasExceptions[status]
except KeyError:
raise cublasError
# Helper functions:
_libcublas.cublasCreate_v2.restype = int
_libcublas.cublasCreate_v2.argtypes = [_types.handle]
def cublasCreate():
"""
Initialize CUBLAS.
Initializes CUBLAS and creates a handle to a structure holding
the CUBLAS library context.
Returns
-------
handle : int
CUBLAS context.
References
----------
`cublasCreate `_
"""
handle = _types.handle()
status = _libcublas.cublasCreate_v2(ctypes.byref(handle))
cublasCheckStatus(status)
return handle.value
_libcublas.cublasDestroy_v2.restype = int
_libcublas.cublasDestroy_v2.argtypes = [_types.handle]
def cublasDestroy(handle):
"""
Release CUBLAS resources.
Releases hardware resources used by CUBLAS.
Parameters
----------
handle : int
CUBLAS context.
References
----------
`cublasDestroy `_
"""
status = _libcublas.cublasDestroy_v2(handle)
cublasCheckStatus(status)
_libcublas.cublasGetVersion_v2.restype = int
_libcublas.cublasGetVersion_v2.argtypes = [_types.handle,
ctypes.c_void_p]
def cublasGetVersion(handle):
"""
Get CUBLAS version.
Returns version number of installed CUBLAS libraries.
Parameters
----------
handle : int
CUBLAS context.
Returns
-------
version : int
CUBLAS version.
References
----------
`cublasGetVersion `_
"""
version = ctypes.c_int()
status = _libcublas.cublasGetVersion_v2(handle, ctypes.byref(version))
cublasCheckStatus(status)
return version.value
def _get_cublas_version():
"""
Get and save CUBLAS version using the CUBLAS library's SONAME.
This function tries to avoid calling cublasGetVersion because creating a
CUBLAS context can subtly affect the performance of subsequent
CUDA operations in certain circumstances.
Results
-------
version : str
Zeros are appended to match format of version returned
by cublasGetVersion() (e.g., '6050' corresponds to version 6.5).
Notes
-----
Since the version number does not appear to be obtainable from the
MacOSX CUBLAS library, this function must call cublasGetVersion() on
MacOSX (but raises a warning to let the user know).
"""
cublas_path = utils.find_lib_path('cublas')
try:
major, minor = re.search('[\D\.]+\.+(\d+)\.(\d+)',
utils.get_soname(cublas_path)).groups()
except:
# Create a temporary context to run cublasGetVersion():
warnings.warn('creating CUBLAS context to get version number')
h = cublasCreate()
version = cublasGetVersion(h)
cublasDestroy(h)
return str(version)
else:
return major.ljust(2, '0')+minor.ljust(2, '0')
_cublas_version = int(_get_cublas_version())
class _cublas_version_req(object):
"""
Decorator to replace function with a placeholder that raises an exception
if the installed CUBLAS version is not greater than `v`.
"""
def __init__(self, v):
self.vs = str(v)
if isinstance(v, int):
major = str(v)
minor = '0'
else:
major, minor = re.search('(\d+)\.(\d+)', self.vs).groups()
self.vi = major.ljust(2, '0')+minor.ljust(2, '0')
def __call__(self,f):
def f_new(*args,**kwargs):
raise NotImplementedError('CUBLAS '+self.vs+' required')
f_new.__doc__ = f.__doc__
if _cublas_version >= int(self.vi):
return f
else:
return f_new
_libcublas.cublasSetStream_v2.restype = int
_libcublas.cublasSetStream_v2.argtypes = [_types.handle,
_types.stream]
def cublasSetStream(handle, id):
"""
Set current CUBLAS library stream.
Parameters
----------
handle : id
CUBLAS context.
id : int
Stream ID.
References
----------
`cublasSetStream `_
"""
status = _libcublas.cublasSetStream_v2(handle, id)
cublasCheckStatus(status)
_libcublas.cublasGetStream_v2.restype = int
_libcublas.cublasGetStream_v2.argtypes = [_types.handle,
ctypes.c_void_p]
def cublasGetStream(handle):
"""
Set current CUBLAS library stream.
Parameters
----------
handle : int
CUBLAS context.
Returns
-------
id : int
Stream ID.
References
----------
`cublasGetStream `_
"""
id = _types.stream()
status = _libcublas.cublasGetStream_v2(handle, ctypes.byref(id))
cublasCheckStatus(status)
return id.value
try:
_libcublas.cublasGetCurrentCtx.restype = int
except AttributeError:
def cublasGetCurrentCtx():
raise NotImplementedError(
'cublasGetCurrentCtx() not found; CULA CUBLAS library probably\n'
'precedes NVIDIA CUBLAS library in library search path')
else:
def cublasGetCurrentCtx():
return _libcublas.cublasGetCurrentCtx()
cublasGetCurrentCtx.__doc__ = """
Get current CUBLAS context.
Returns the current context used by CUBLAS.
Returns
-------
handle : int
CUBLAS context.
"""
### BLAS Level 1 Functions ###
# ISAMAX, IDAMAX, ICAMAX, IZAMAX
I_AMAX_doc = Template(
"""
Index of maximum magnitude element.
Finds the smallest index of the maximum magnitude element of a
${precision} ${real} vector.
Note: for complex arguments x, the "magnitude" is defined as
`abs(x.real) + abs(x.imag)`, *not* as `abs(x)`.
Parameters
----------
handle : int
CUBLAS context.
n : int
Number of elements in input vector.
x : ctypes.c_void_p
Pointer to ${precision} ${real} input vector.
incx : int
Storage spacing between elements of `x`.
Returns
-------
idx : int
Index of maximum magnitude element.
Examples
--------
>>> import pycuda.autoinit
>>> import pycuda.gpuarray as gpuarray
>>> import numpy as np
>>> x = ${data}
>>> x_gpu = gpuarray.to_gpu(x)
>>> h = cublasCreate()
>>> m = ${func}(h, x_gpu.size, x_gpu.gpudata, 1)
>>> cublasDestroy(h)
>>> np.allclose(m, np.argmax(abs(x.real) + abs(x.imag)))
True
Notes
-----
This function returns a 0-based index.
References
----------
`cublasIamax `_
""")
_libcublas.cublasIsamax_v2.restype = int
_libcublas.cublasIsamax_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasIsamax(handle, n, x, incx):
result = ctypes.c_int()
status = \
_libcublas.cublasIsamax_v2(handle,
n, int(x), incx, ctypes.byref(result))
cublasCheckStatus(status)
return result.value-1
cublasIsamax.__doc__ = \
I_AMAX_doc.substitute(precision='single precision',
real='real',
data='np.random.rand(5).astype(np.float32)',
func='cublasIsamax')
_libcublas.cublasIdamax_v2.restype = int
_libcublas.cublasIdamax_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasIdamax(handle, n, x, incx):
result = ctypes.c_int()
status = \
_libcublas.cublasIdamax_v2(handle,
n, int(x), incx, ctypes.byref(result))
cublasCheckStatus(status)
return result.value-1
cublasIdamax.__doc__ = \
I_AMAX_doc.substitute(precision='double precision',
real='real',
data='np.random.rand(5).astype(np.float64)',
func='cublasIdamax')
_libcublas.cublasIcamax_v2.restype = int
_libcublas.cublasIcamax_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasIcamax(handle, n, x, incx):
result = ctypes.c_int()
status = \
_libcublas.cublasIcamax_v2(handle,
n, int(x), incx, ctypes.byref(result))
cublasCheckStatus(status)
return result.value-1
cublasIcamax.__doc__ = \
I_AMAX_doc.substitute(precision='single precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex64)',
func='cublasIcamax')
_libcublas.cublasIzamax_v2.restype = int
_libcublas.cublasIzamax_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasIzamax(handle, n, x, incx):
result = ctypes.c_int()
status = \
_libcublas.cublasIzamax_v2(handle,
n, int(x), incx, ctypes.byref(result))
cublasCheckStatus(status)
return result.value-1
cublasIzamax.__doc__ = \
I_AMAX_doc.substitute(precision='double precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex128)',
func='cublasIzamax')
# ISAMIN, IDAMIN, ICAMIN, IZAMIN
I_AMIN_doc = Template(
"""
Index of minimum magnitude element (${precision} ${real}).
Finds the smallest index of the minimum magnitude element of a
${precision} ${real} vector.
Note: for complex arguments x, the "magnitude" is defined as
`abs(x.real) + abs(x.imag)`, *not* as `abs(x)`.
Parameters
----------
handle : int
CUBLAS context.
n : int
Number of elements in input vector.
x : ctypes.c_void_p
Pointer to ${precision} ${real} input vector.
incx : int
Storage spacing between elements of `x`.
Returns
-------
idx : int
Index of minimum magnitude element.
Examples
--------
>>> import pycuda.autoinit
>>> import pycuda.gpuarray as gpuarray
>>> import numpy as np
>>> x = ${data}
>>> x_gpu = gpuarray.to_gpu(x)
>>> h = cublasCreate()
>>> m = ${func}(h, x_gpu.size, x_gpu.gpudata, 1)
>>> cublasDestroy(h)
>>> np.allclose(m, np.argmin(abs(x.real) + abs(x.imag)))
True
Notes
-----
This function returns a 0-based index.
References
----------
`cublasIamin `_
"""
)
_libcublas.cublasIsamin_v2.restype = int
_libcublas.cublasIsamin_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasIsamin(handle, n, x, incx):
result = ctypes.c_int()
status = \
_libcublas.cublasIsamin_v2(handle,
n, int(x), incx, ctypes.byref(result))
cublasCheckStatus(status)
return result.value-1
cublasIsamin.__doc__ = \
I_AMIN_doc.substitute(precision='single precision',
real='real',
data='np.random.rand(5).astype(np.float32)',
func='cublasIsamin')
_libcublas.cublasIdamin_v2.restype = int
_libcublas.cublasIdamin_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasIdamin(handle, n, x, incx):
result = ctypes.c_int()
status = \
_libcublas.cublasIdamin_v2(handle,
n, int(x), incx, ctypes.byref(result))
cublasCheckStatus(status)
return result.value-1
cublasIdamin.__doc__ = \
I_AMIN_doc.substitute(precision='double precision',
real='real',
data='np.random.rand(5).astype(np.float64)',
func='cublasIdamin')
_libcublas.cublasIcamin_v2.restype = int
_libcublas.cublasIcamin_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasIcamin(handle, n, x, incx):
result = ctypes.c_int()
status = \
_libcublas.cublasIcamin_v2(handle,
n, int(x), incx, ctypes.byref(result))
cublasCheckStatus(status)
return result.value-1
cublasIcamin.__doc__ = \
I_AMIN_doc.substitute(precision='single precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex64)',
func='cublasIcamin')
_libcublas.cublasIzamin_v2.restype = int
_libcublas.cublasIzamin_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasIzamin(handle, n, x, incx):
result = ctypes.c_int()
status = \
_libcublas.cublasIzamin_v2(handle,
n, int(x), incx, ctypes.byref(result))
cublasCheckStatus(status)
return result.value-1
cublasIzamin.__doc__ = \
I_AMIN_doc.substitute(precision='double precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex128)',
func='cublasIzamin')
# SASUM, DASUM, SCASUM, DZASUM
_ASUM_doc = Template(
"""
Sum of absolute values of ${precision} ${real} vector.
Computes the sum of the absolute values of the elements of a
${precision} ${real} vector.
Note: if the vector is complex, then this computes the sum
`sum(abs(x.real)) + sum(abs(x.imag))`
Parameters
----------
handle : int
CUBLAS context.
n : int
Number of elements in input vector.
x : ctypes.c_void_p
Pointer to ${precision} ${real} input vector.
incx : int
Storage spacing between elements of `x`.
Examples
--------
>>> import pycuda.autoinit
>>> import pycuda.gpuarray as gpuarray
>>> import numpy as np
>>> x = ${data}
>>> x_gpu = gpuarray.to_gpu(x)
>>> h = cublasCreate()
>>> s = ${func}(h, x_gpu.size, x_gpu.gpudata, 1)
>>> cublasDestroy(h)
>>> np.allclose(s, abs(x.real).sum() + abs(x.imag).sum())
True
Returns
-------
s : ${ret_type}
Sum of absolute values.
References
----------
`cublassum `_
"""
)
_libcublas.cublasSasum_v2.restype = int
_libcublas.cublasSasum_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasSasum(handle, n, x, incx):
result = ctypes.c_float()
status = _libcublas.cublasSasum_v2(handle,
n, int(x), incx, ctypes.byref(result))
cublasCheckStatus(status)
return np.float32(result.value)
cublasSasum.__doc__ = \
_ASUM_doc.substitute(precision='single precision',
real='real',
data='np.random.rand(5).astype(np.float32)',
func='cublasSasum',
ret_type='numpy.float32')
_libcublas.cublasDasum_v2.restype = int
_libcublas.cublasDasum_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasDasum(handle, n, x, incx):
result = ctypes.c_double()
status = _libcublas.cublasDasum_v2(handle,
n, int(x), incx, ctypes.byref(result))
cublasCheckStatus(status)
return np.float64(result.value)
cublasDasum.__doc__ = \
_ASUM_doc.substitute(precision='double precision',
real='real',
data='np.random.rand(5).astype(np.float64)',
func='cublasDasum',
ret_type='numpy.float64')
_libcublas.cublasScasum_v2.restype = int
_libcublas.cublasScasum_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasScasum(handle, n, x, incx):
result = ctypes.c_float()
status = _libcublas.cublasScasum_v2(handle,
n, int(x), incx, ctypes.byref(result))
cublasCheckStatus(status)
return np.float32(result.value)
cublasScasum.__doc__ = \
_ASUM_doc.substitute(precision='single precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex64)',
func='cublasScasum',
ret_type='numpy.float32')
_libcublas.cublasDzasum_v2.restype = int
_libcublas.cublasDzasum_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasDzasum(handle, n, x, incx):
result = ctypes.c_double()
status = _libcublas.cublasDzasum_v2(handle,
n, int(x), incx, ctypes.byref(result))
cublasCheckStatus(status)
return np.float64(result.value)
cublasDzasum.__doc__ = \
_ASUM_doc.substitute(precision='double precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex128)',
func='cublasDzasum',
ret_type='numpy.float64')
# SAXPY, DAXPY, CAXPY, ZAXPY
_AXPY_doc = Template(
"""
Vector addition (${precision} ${real}).
Computes the sum of a ${precision} ${real} vector scaled by a
${precision} ${real} scalar and another ${precision} ${real} vector.
Parameters
----------
handle : int
CUBLAS context.
n : int
Number of elements in input vectors.
alpha : ${type}
Scalar.
x : ctypes.c_void_p
Pointer to single precision input vector.
incx : int
Storage spacing between elements of `x`.
y : ctypes.c_void_p
Pointer to single precision input/output vector.
incy : int
Storage spacing between elements of `y`.
Examples
--------
>>> import pycuda.autoinit
>>> import pycuda.gpuarray as gpuarray
>>> import numpy as np
>>> alpha = ${alpha}
>>> x = ${data}
>>> y = ${data}
>>> x_gpu = gpuarray.to_gpu(x)
>>> y_gpu = gpuarray.to_gpu(y)
>>> h = cublasCreate()
>>> ${func}(h, x_gpu.size, alpha, x_gpu.gpudata, 1, y_gpu.gpudata, 1)
>>> cublasDestroy(h)
>>> np.allclose(y_gpu.get(), alpha*x+y)
True
Notes
-----
Both `x` and `y` must contain `n` elements.
References
----------
`cublasaxpy `_
"""
)
_libcublas.cublasSaxpy_v2.restype = int
_libcublas.cublasSaxpy_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasSaxpy(handle, n, alpha, x, incx, y, incy):
status = _libcublas.cublasSaxpy_v2(handle,
n, ctypes.byref(ctypes.c_float(alpha)),
int(x), incx, int(y), incy)
cublasCheckStatus(status)
cublasSaxpy.__doc__ = \
_AXPY_doc.substitute(precision='single precision',
real='real',
type='numpy.float32',
alpha='np.float32(np.random.rand())',
data='np.random.rand(5).astype(np.float32)',
func='cublasSaxpy')
_libcublas.cublasDaxpy_v2.restype = int
_libcublas.cublasDaxpy_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasDaxpy(handle, n, alpha, x, incx, y, incy):
status = _libcublas.cublasDaxpy_v2(handle,
n, ctypes.byref(ctypes.c_double(alpha)),
int(x), incx, int(y), incy)
cublasCheckStatus(status)
cublasDaxpy.__doc__ = \
_AXPY_doc.substitute(precision='double precision',
real='real',
type='numpy.float64',
alpha='np.float64(np.random.rand())',
data='np.random.rand(5).astype(np.float64)',
func='cublasDaxpy')
_libcublas.cublasCaxpy_v2.restype = int
_libcublas.cublasCaxpy_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasCaxpy(handle, n, alpha, x, incx, y, incy):
status = _libcublas.cublasCaxpy_v2(handle, n,
ctypes.byref(cuda.cuFloatComplex(alpha.real, alpha.imag)),
int(x), incx, int(y), incy)
cublasCheckStatus(status)
cublasCaxpy.__doc__ = \
_AXPY_doc.substitute(precision='single precision',
real='complex',
type='numpy.complex64',
alpha='np.complex64(np.random.rand()+1j*np.random.rand())',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex64)',
func='cublasCaxpy')
_libcublas.cublasZaxpy_v2.restype = int
_libcublas.cublasZaxpy_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasZaxpy(handle, n, alpha, x, incx, y, incy):
status = _libcublas.cublasZaxpy_v2(handle, n,
ctypes.byref(cuda.cuDoubleComplex(alpha.real, alpha.imag)),
int(x), incx, int(y), incy)
cublasCheckStatus(status)
cublasZaxpy.__doc__ = \
_AXPY_doc.substitute(precision='double precision',
real='complex',
type='numpy.complex128',
alpha='np.complex128(np.random.rand()+1j*np.random.rand())',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex128)',
func='cublasZaxpy')
# SCOPY, DCOPY, CCOPY, ZCOPY
_COPY_doc = Template(
"""
Vector copy (${precision} ${real})
Copies a ${precision} ${real} vector to another ${precision} ${real}
vector.
Parameters
----------
handle : int
CUBLAS context.
n : int
Number of elements in input vectors.
x : ctypes.c_void_p
Pointer to ${precision} ${real} input vector.
incx : int
Storage spacing between elements of `x`.
y : ctypes.c_void_p
Pointer to ${precision} ${real} output vector.
incy : int
Storage spacing between elements of `y`.
Examples
--------
>>> import pycuda.autoinit
>>> import pycuda.gpuarray as gpuarray
>>> import numpy as np
>>> x = ${data}
>>> x_gpu = gpuarray.to_gpu(x)
>>> y_gpu = gpuarray.zeros_like(x_gpu)
>>> h = cublasCreate()
>>> ${func}(h, x_gpu.size, x_gpu.gpudata, 1, y_gpu.gpudata, 1)
>>> cublasDestroy(h)
>>> np.allclose(y_gpu.get(), x_gpu.get())
True
Notes
-----
Both `x` and `y` must contain `n` elements.
References
----------
`cublascopy `_
""")
_libcublas.cublasScopy_v2.restype = int
_libcublas.cublasScopy_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasScopy(handle, n, x, incx, y, incy):
status = _libcublas.cublasScopy_v2(handle,
n, int(x), incx, int(y), incy)
cublasCheckStatus(status)
cublasScopy.__doc__ = \
_COPY_doc.substitute(precision='single precision',
real='real',
data='np.random.rand(5).astype(np.float32)',
func='cublasScopy')
_libcublas.cublasDcopy_v2.restype = int
_libcublas.cublasDcopy_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasDcopy(handle, n, x, incx, y, incy):
status = _libcublas.cublasDcopy_v2(handle,
n, int(x), incx, int(y), incy)
cublasCheckStatus(status)
cublasDcopy.__doc__ = \
_COPY_doc.substitute(precision='double precision',
real='real',
data='np.random.rand(5).astype(np.float64)',
func='cublasDcopy')
_libcublas.cublasCcopy_v2.restype = int
_libcublas.cublasCcopy_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasCcopy(handle, n, x, incx, y, incy):
status = _libcublas.cublasCcopy_v2(handle,
n, int(x), incx, int(y), incy)
cublasCheckStatus(status)
cublasCcopy.__doc__ = \
_COPY_doc.substitute(precision='single precision',
real='complex',
data='(np.random.rand(5)+np.random.rand(5)).astype(np.complex64)',
func='cublasCcopy')
_libcublas.cublasZcopy_v2.restype = int
_libcublas.cublasZcopy_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasZcopy(handle, n, x, incx, y, incy):
status = _libcublas.cublasZcopy_v2(handle,
n, int(x), incx, int(y), incy)
cublasCheckStatus(status)
cublasZcopy.__doc__ = \
_COPY_doc.substitute(precision='double precision',
real='complex',
data='(np.random.rand(5)+np.random.rand(5)).astype(np.complex128)',
func='cublasZcopy')
# SDOT, DDOT, CDOTU, CDOTC, ZDOTU, ZDOTC
_DOT_doc = Template(
"""
Vector dot product (${precision} ${real})
Computes the dot product of two ${precision} ${real} vectors.
cublasCdotc and cublasZdotc use the conjugate of the first vector
when computing the dot product.
Parameters
----------
handle : int
CUBLAS context.
n : int
Number of elements in input vectors.
x : ctypes.c_void_p
Pointer to ${precision} ${real} input vector.
incx : int
Storage spacing between elements of `x`.
y : ctypes.c_void_p
Pointer to ${precision} ${real} input/output vector.
incy : int
Storage spacing between elements of `y`.
Returns
-------
d : ${ret_type}
Dot product of `x` and `y`.
Examples
--------
>>> import pycuda.autoinit
>>> import pycuda.gpuarray as gpuarray
>>> import numpy as np
>>> x = ${data}
>>> y = ${data}
>>> x_gpu = gpuarray.to_gpu(x)
>>> y_gpu = gpuarray.to_gpu(y)
>>> h = cublasCreate()
>>> d = ${func}(h, x_gpu.size, x_gpu.gpudata, 1, y_gpu.gpudata, 1)
>>> cublasDestroy(h)
>>> ${check}
True
Notes
-----
Both `x` and `y` must contain `n` elements.
References
----------
`cublasdot `_
""")
_libcublas.cublasSdot_v2.restype = int
_libcublas.cublasSdot_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasSdot(handle, n, x, incx, y, incy):
result = ctypes.c_float()
status = _libcublas.cublasSdot_v2(handle, n,
int(x), incx, int(y), incy,
ctypes.byref(result))
cublasCheckStatus(status)
return np.float32(result.value)
cublasSdot.__doc__ = _DOT_doc.substitute(precision='single precision',
real='real',
data='np.float32(np.random.rand(5))',
ret_type='np.float32',
func='cublasSdot',
check='np.allclose(d, np.dot(x, y))')
_libcublas.cublasDdot_v2.restype = int
_libcublas.cublasDdot_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasDdot(handle, n, x, incx, y, incy):
result = ctypes.c_double()
status = _libcublas.cublasDdot_v2(handle, n,
int(x), incx, int(y), incy,
ctypes.byref(result))
cublasCheckStatus(status)
return np.float64(result.value)
cublasDdot.__doc__ = _DOT_doc.substitute(precision='double precision',
real='real',
data='np.float64(np.random.rand(5))',
ret_type='np.float64',
func='cublasDdot',
check='np.allclose(d, np.dot(x, y))')
_libcublas.cublasCdotu_v2.restype = int
_libcublas.cublasCdotu_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasCdotu(handle, n, x, incx, y, incy):
result = cuda.cuFloatComplex()
status = _libcublas.cublasCdotu_v2(handle, n,
int(x), incx, int(y), incy,
ctypes.byref(result))
cublasCheckStatus(status)
return np.complex64(result.value)
cublasCdotu.__doc__ = _DOT_doc.substitute(precision='single precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex64)',
ret_type='np.complex64',
func='cublasCdotu',
check='np.allclose(d, np.dot(x, y))')
_libcublas.cublasCdotc_v2.restype = int
_libcublas.cublasCdotc_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasCdotc(handle, n, x, incx, y, incy):
result = cuda.cuFloatComplex()
status = _libcublas.cublasCdotc_v2(handle, n,
int(x), incx, int(y), incy,
ctypes.byref(result))
cublasCheckStatus(status)
return np.complex64(result.value)
cublasCdotc.__doc__ = _DOT_doc.substitute(precision='single precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex64)',
ret_type='np.complex64',
func='cublasCdotc',
check='np.allclose(d, np.dot(np.conj(x), y))')
_libcublas.cublasZdotu_v2.restype = int
_libcublas.cublasZdotu_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasZdotu(handle, n, x, incx, y, incy):
result = cuda.cuDoubleComplex()
status = _libcublas.cublasZdotu_v2(handle, n,
int(x), incx, int(y), incy,
ctypes.byref(result))
cublasCheckStatus(status)
return np.complex128(result.value)
cublasZdotu.__doc__ = _DOT_doc.substitute(precision='double precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex128)',
ret_type='np.complex128',
func='cublasZdotu',
check='np.allclose(d, np.dot(x, y))')
_libcublas.cublasZdotc_v2.restype = int
_libcublas.cublasZdotc_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasZdotc(handle, n, x, incx, y, incy):
result = cuda.cuDoubleComplex()
status = _libcublas.cublasZdotc_v2(handle, n,
int(x), incx, int(y), incy,
ctypes.byref(result))
cublasCheckStatus(status)
return np.complex128(result.value)
cublasZdotc.__doc__ = _DOT_doc.substitute(precision='double precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex128)',
ret_type='np.complex128',
func='cublasZdotc',
check='np.allclose(d, np.dot(np.conj(x), y))')
# SNRM2, DNRM2, SCNRM2, DZNRM2
_NRM2_doc = Template(
"""
Euclidean norm (2-norm) of real vector.
Computes the Euclidean norm of a ${precision} ${real} vector.
Parameters
----------
handle : int
CUBLAS context.
n : int
Number of elements in input vectors.
x : ctypes.c_void_p
Pointer to ${precision} ${real} input vector.
incx : int
Storage spacing between elements of `x`.
Returns
-------
nrm : ${ret_type}
Euclidean norm of `x`.
Examples
--------
>>> import pycuda.autoinit
>>> import pycuda.gpuarray as gpuarray
>>> import numpy as np
>>> x = ${data}
>>> x_gpu = gpuarray.to_gpu(x)
>>> h = cublasCreate()
>>> nrm = ${func}(h, x.size, x_gpu.gpudata, 1)
>>> cublasDestroy(h)
>>> np.allclose(nrm, np.linalg.norm(x))
True
References
----------
`cublasnrm2 `_
""")
_libcublas.cublasSnrm2_v2.restype = int
_libcublas.cublasSnrm2_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasSnrm2(handle, n, x, incx):
result = ctypes.c_float()
status = _libcublas.cublasSnrm2_v2(handle,
n, int(x), incx,
ctypes.byref(result))
cublasCheckStatus(status)
return np.float32(result.value)
cublasSnrm2.__doc__ = \
_NRM2_doc.substitute(precision='single precision',
real='real',
data='np.float32(np.random.rand(5))',
ret_type = 'numpy.float32',
func='cublasSnrm2')
_libcublas.cublasDnrm2_v2.restype = int
_libcublas.cublasDnrm2_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasDnrm2(handle, n, x, incx):
result = ctypes.c_double()
status = _libcublas.cublasDnrm2_v2(handle,
n, int(x), incx,
ctypes.byref(result))
cublasCheckStatus(status)
return np.float64(result.value)
cublasDnrm2.__doc__ = \
_NRM2_doc.substitute(precision='double precision',
real='real',
data='np.float64(np.random.rand(5))',
ret_type = 'numpy.float64',
func='cublasDnrm2')
_libcublas.cublasScnrm2_v2.restype = int
_libcublas.cublasScnrm2_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasScnrm2(handle, n, x, incx):
result = ctypes.c_float()
status = _libcublas.cublasScnrm2_v2(handle,
n, int(x), incx,
ctypes.byref(result))
cublasCheckStatus(status)
return np.float32(result.value)
cublasScnrm2.__doc__ = \
_NRM2_doc.substitute(precision='single precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex64)',
ret_type = 'numpy.complex64',
func='cublasScnrm2')
_libcublas.cublasDznrm2_v2.restype = int
_libcublas.cublasDznrm2_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasDznrm2(handle, n, x, incx):
result = ctypes.c_double()
status = _libcublas.cublasDznrm2_v2(handle,
n, int(x), incx,
ctypes.byref(result))
cublasCheckStatus(status)
return np.float64(result.value)
cublasDznrm2.__doc__ = \
_NRM2_doc.substitute(precision='double precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex128)',
ret_type = 'numpy.complex128',
func='cublasDznrm2')
# SROT, DROT, CROT, CSROT, ZROT, ZDROT
_ROT_doc = Template(
"""
Apply a ${real} rotation to ${real} vectors (${precision})
Multiplies the ${precision} matrix `[[c, s], [-s.conj(), c]]`
with the 2 x `n` ${precision} matrix `[[x.T], [y.T]]`.
Parameters
----------
handle : int
CUBLAS context.
n : int
Number of elements in input vectors.
x : ctypes.c_void_p
Pointer to ${precision} ${real} input/output vector.
incx : int
Storage spacing between elements of `x`.
y : ctypes.c_void_p
Pointer to ${precision} ${real} input/output vector.
incy : int
Storage spacing between elements of `y`.
c : ${c_type}
Element of rotation matrix.
s : ${s_type}
Element of rotation matrix.
Notes
-----
Both `x` and `y` must contain `n` elements.
Examples
--------
>>> import pycuda.autoinit
>>> import pycuda.gpuarray as gpuarray
>>> import numpy as np
>>> s = ${s_val}; c = ${c_val};
>>> x = ${data}
>>> y = ${data}
>>> x_gpu = gpuarray.to_gpu(x)
>>> y_gpu = gpuarray.to_gpu(y)
>>> h = cublasCreate()
>>> ${func}(h, x.size, x_gpu.gpudata, 1, y_gpu.gpudata, 1, c, s)
>>> cublasDestroy(h)
>>> np.allclose(x_gpu.get(), c*x+s*y)
True
>>> np.allclose(y_gpu.get(), -s.conj()*x+c*y)
True
References
----------
`cublasrot `_
""")
_libcublas.cublasSrot_v2.restype = int
_libcublas.cublasSrot_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p]
def cublasSrot(handle, n, x, incx, y, incy, c, s):
status = _libcublas.cublasSrot_v2(handle,
n, int(x), incx,
int(y), incy,
ctypes.byref(ctypes.c_float(c)),
ctypes.byref(ctypes.c_float(s)))
cublasCheckStatus(status)
cublasSrot.__doc__ = _ROT_doc.substitute(precision='single precision',
real='real',
c_type='numpy.float32',
s_type='numpy.float32',
c_val='np.float32(np.random.rand())',
s_val='np.float32(np.random.rand())',
data='np.random.rand(5).astype(np.float32)',
func='cublasSrot')
_libcublas.cublasDrot_v2.restype = int
_libcublas.cublasDrot_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p]
def cublasDrot(handle, n, x, incx, y, incy, c, s):
status = _libcublas.cublasDrot_v2(handle,
n, int(x),
incx, int(y), incy,
ctypes.byref(ctypes.c_double(c)),
ctypes.byref(ctypes.c_double(s)))
cublasCheckStatus(status)
cublasDrot.__doc__ = _ROT_doc.substitute(precision='double precision',
real='real',
c_type='numpy.float64',
s_type='numpy.float64',
c_val='np.float64(np.random.rand())',
s_val='np.float64(np.random.rand())',
data='np.random.rand(5).astype(np.float64)',
func='cublasDrot')
_libcublas.cublasCrot_v2.restype = int
_libcublas.cublasCrot_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p]
def cublasCrot(handle, n, x, incx, y, incy, c, s):
status = _libcublas.cublasCrot_v2(handle,
n, int(x),
incx, int(y), incy,
ctypes.byref(ctypes.c_float(c)),
ctypes.byref(cuda.cuFloatComplex(s.real,
s.imag)))
cublasCheckStatus(status)
cublasCrot.__doc__ = _ROT_doc.substitute(precision='single precision',
real='complex',
c_type='numpy.float32',
s_type='numpy.complex64',
c_val='np.float32(np.random.rand())',
s_val='np.complex64(np.random.rand()+1j*np.random.rand())',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex64)',
func='cublasCrot')
_libcublas.cublasCsrot_v2.restype = int
_libcublas.cublasCsrot_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p]
def cublasCsrot(handle, n, x, incx, y, incy, c, s):
status = _libcublas.cublasCsrot_v2(handle,
n, int(x),
incx, int(y), incy,
ctypes.byref(ctypes.c_float(c)),
ctypes.byref(ctypes.c_float(s)))
cublasCheckStatus(status)
cublasCsrot.__doc__ = _ROT_doc.substitute(precision='single precision',
real='complex',
c_type='numpy.float32',
s_type='numpy.float32',
c_val='np.float32(np.random.rand())',
s_val='np.float32(np.random.rand())',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex64)',
func='cublasCsrot')
_libcublas.cublasZrot_v2.restype = int
_libcublas.cublasZrot_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p]
def cublasZrot(handle, n, x, incx, y, incy, c, s):
status = _libcublas.cublasZrot_v2(handle,
n, int(x),
incx, int(y), incy,
ctypes.byref(ctypes.c_double(c)),
ctypes.byref(cuda.cuDoubleComplex(s.real,
s.imag)))
cublasCheckStatus(status)
cublasZrot.__doc__ = _ROT_doc.substitute(precision='double precision',
real='complex',
c_type='numpy.float64',
s_type='numpy.complex128',
c_val='np.float64(np.random.rand())',
s_val='np.complex128(np.random.rand()+1j*np.random.rand())',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex128)',
func='cublasZrot')
_libcublas.cublasZdrot_v2.restype = int
_libcublas.cublasZdrot_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p]
def cublasZdrot(handle, n, x, incx, y, incy, c, s):
status = _libcublas.cublasZdrot_v2(handle,
n, int(x),
incx, int(y), incy,
ctypes.byref(ctypes.c_double(c)),
ctypes.byref(ctypes.c_double(s)))
cublasCheckStatus(status)
cublasZdrot.__doc__ = _ROT_doc.substitute(precision='double precision',
real='complex',
c_type='numpy.float64',
s_type='numpy.float64',
c_val='np.float64(np.random.rand())',
s_val='np.float64(np.random.rand())',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex128)',
func='cublasZdrot')
# SROTG, DROTG, CROTG, ZROTG
_ROTG_doc = Template(
"""
Construct a ${precision} ${real} Givens rotation matrix.
Constructs the ${precision} ${real} Givens rotation matrix
`G = [[c, s], [-s.conj(), c]]` such that
`dot(G, [[a], [b]] == [[r], [0]]`, where
`c**2+s**2 == 1` and `r == a**2+b**2` for real numbers and
`c**2+(conj(s)*s) == 1` and `r ==
(a/abs(a))*sqrt(abs(a)**2+abs(b)**2)` for `a != 0` and `r == b`
for `a == 0`.
Parameters
----------
handle : int
CUBLAS context.
a, b : ${type}
Entries of vector whose second entry should be zeroed
out by the rotation.
Returns
-------
r : ${type}
Defined above.
c : ${c_type}
Cosine component of rotation matrix.
s : ${s_type}
Sine component of rotation matrix.
Examples
--------
>>> import pycuda.autoinit
>>> import pycuda.gpuarray as gpuarray
>>> import numpy as np
>>> a = ${a_val}
>>> b = ${b_val}
>>> h = cublasCreate()
>>> r, c, s = ${func}(h, a, b)
>>> cublasDestroy(h)
>>> np.allclose(np.dot(np.array([[c, s], [-np.conj(s), c]]), np.array([[a], [b]])), np.array([[r], [0.0]]), atol=1e-6)
True
References
----------
`cublasrotg `_
""")
_libcublas.cublasSrotg_v2.restype = int
_libcublas.cublasSrotg_v2.argtypes = [_types.handle,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p]
def cublasSrotg(handle, a, b):
_a = ctypes.c_float(a)
_b = ctypes.c_float(b)
_c = ctypes.c_float()
_s = ctypes.c_float()
status = _libcublas.cublasSrotg_v2(handle,
ctypes.byref(_a), ctypes.byref(_b),
ctypes.byref(_c), ctypes.byref(_s))
cublasCheckStatus(status)
return np.float32(_a.value), np.float32(_c.value), np.float32(_s.value)
cublasSrotg.__doc__ = \
_ROTG_doc.substitute(precision='single precision',
real='real',
type='numpy.float32',
c_type='numpy.float32',
s_type='numpy.float32',
a_val='np.float32(np.random.rand())',
b_val='np.float32(np.random.rand())',
func='cublasSrotg')
_libcublas.cublasDrotg_v2.restype = int
_libcublas.cublasDrotg_v2.argtypes = [_types.handle,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p]
def cublasDrotg(handle, a, b):
_a = ctypes.c_double(a)
_b = ctypes.c_double(b)
_c = ctypes.c_double()
_s = ctypes.c_double()
status = _libcublas.cublasDrotg_v2(handle,
ctypes.byref(_a), ctypes.byref(_b),
ctypes.byref(_c), ctypes.byref(_s))
cublasCheckStatus(status)
return np.float64(_a.value), np.float64(_c.value), np.float64(_s.value)
cublasDrotg.__doc__ = \
_ROTG_doc.substitute(precision='double precision',
real='real',
type='numpy.float64',
c_type='numpy.float64',
s_type='numpy.float64',
a_val='np.float64(np.random.rand())',
b_val='np.float64(np.random.rand())',
func='cublasDrotg')
_libcublas.cublasCrotg_v2.restype = int
_libcublas.cublasCrotg_v2.argtypes = [_types.handle,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p]
def cublasCrotg(handle, a, b):
_a = cuda.cuFloatComplex(a.real, a.imag)
_b = cuda.cuFloatComplex(b.real, b.imag)
_c = ctypes.c_float()
_s = cuda.cuFloatComplex()
status = _libcublas.cublasCrotg_v2(handle,
ctypes.byref(_a), ctypes.byref(_b),
ctypes.byref(_c), ctypes.byref(_s))
cublasCheckStatus(status)
return np.complex64(_a.value), np.float32(_c.value), np.complex64(_s.value)
cublasCrotg.__doc__ = \
_ROTG_doc.substitute(precision='single precision',
real='complex',
type='numpy.complex64',
c_type='numpy.float32',
s_type='numpy.complex64',
a_val='np.complex64(np.random.rand()+1j*np.random.rand())',
b_val='np.complex64(np.random.rand()+1j*np.random.rand())',
func='cublasCrotg')
_libcublas.cublasZrotg_v2.restype = int
_libcublas.cublasZrotg_v2.argtypes = [_types.handle,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p]
def cublasZrotg(handle, a, b):
_a = cuda.cuDoubleComplex(a.real, a.imag)
_b = cuda.cuDoubleComplex(b.real, b.imag)
_c = ctypes.c_double()
_s = cuda.cuDoubleComplex()
status = _libcublas.cublasZrotg_v2(handle,
ctypes.byref(_a), ctypes.byref(_b),
ctypes.byref(_c), ctypes.byref(_s))
cublasCheckStatus(status)
return np.complex128(_a.value), np.float64(_c.value), np.complex128(_s.value)
cublasZrotg.__doc__ = \
_ROTG_doc.substitute(precision='double precision',
real='complex',
type='numpy.complex128',
c_type='numpy.float64',
s_type='numpy.complex128',
a_val='np.complex128(np.random.rand()+1j*np.random.rand())',
b_val='np.complex128(np.random.rand()+1j*np.random.rand())',
func='cublasZrotg')
# SROTM, DROTM (need to add example)
_ROTM_doc = Template(
"""
Apply a ${precision} real modified Givens rotation.
Applies the ${precision} real modified Givens rotation matrix `h`
to the 2 x `n` matrix `[[x.T], [y.T]]`.
Parameters
----------
handle : int
CUBLAS context.
n : int
Number of elements in input vectors.
x : ctypes.c_void_p
Pointer to ${precision} real input/output vector.
incx : int
Storage spacing between elements of `x`.
y : ctypes.c_void_p
Pointer to ${precision} real input/output vector.
incy : int
Storage spacing between elements of `y`.
sparam : numpy.ndarray
sparam[0] contains the `flag` described below;
sparam[1:5] contains the values `[h00, h10, h01, h11]`
that determine the rotation matrix `h`.
Notes
-----
The rotation matrix may assume the following values:
for `flag` == -1.0, `h` == `[[h00, h01], [h10, h11]]`
for `flag` == 0.0, `h` == `[[1.0, h01], [h10, 1.0]]`
for `flag` == 1.0, `h` == `[[h00, 1.0], [-1.0, h11]]`
for `flag` == -2.0, `h` == `[[1.0, 0.0], [0.0, 1.0]]`
Both `x` and `y` must contain `n` elements.
References
----------
`cublassrotm `_
""")
_libcublas.cublasSrotm_v2.restype = int
_libcublas.cublasSrotm_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasSrotm(handle, n, x, incx, y, incy, sparam):
status = _libcublas.cublasSrotm_v2(handle,
n, int(x), incx, int(y),
incy, int(sparam.ctypes.data))
cublasCheckStatus(status)
cublasSrotm.__doc__ = \
_ROTM_doc.substitute(precision='single precision')
_libcublas.cublasDrotm_v2.restype = int
_libcublas.cublasDrotm_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasDrotm(handle, n, x, incx, y, incy, sparam):
status = _libcublas.cublasDrotm_v2(handle,
n, int(x), incx, int(y),
incy, int(sparam.ctypes.data))
cublasCheckStatus(status)
cublasDrotm.__doc__ = \
_ROTM_doc.substitute(precision='double precision')
# SROTMG, DROTMG (need to add example)
_ROTMG_doc = Template(
"""
Construct a ${precision} real modified Givens rotation matrix.
Constructs the ${precision} real modified Givens rotation matrix
`h = [[h11, h12], [h21, h22]]` that zeros out the second entry of
the vector `[[sqrt(d1)*x1], [sqrt(d2)*x2]]`.
Parameters
----------
handle : int
CUBLAS context.
d1 : ${type}
${precision} real value.
d2 : ${type}
${precision} real value.
x1 : ${type}
${precision} real value.
x2 : ${type}
${precision} real value.
Returns
-------
sparam : numpy.ndarray
sparam[0] contains the `flag` described below;
sparam[1:5] contains the values `[h00, h10, h01, h11]`
that determine the rotation matrix `h`.
Notes
-----
The rotation matrix may assume the following values:
for `flag` == -1.0, `h` == `[[h00, h01], [h10, h11]]`
for `flag` == 0.0, `h` == `[[1.0, h01], [h10, 1.0]]`
for `flag` == 1.0, `h` == `[[h00, 1.0], [-1.0, h11]]`
for `flag` == -2.0, `h` == `[[1.0, 0.0], [0.0, 1.0]]`
References
----------
`cublasrotmg `_
""")
_libcublas.cublasSrotmg_v2.restype = int
_libcublas.cublasSrotmg_v2.argtypes = [_types.handle,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p]
def cublasSrotmg(handle, d1, d2, x1, y1):
_d1 = ctypes.c_float(d1)
_d2 = ctypes.c_float(d2)
_x1 = ctypes.c_float(x1)
_y1 = ctypes.c_float(y1)
sparam = np.empty(5, np.float32)
status = _libcublas.cublasSrotmg_v2(handle,
ctypes.byref(_d1), ctypes.byref(_d2),
ctypes.byref(_x1), ctypes.byref(_y1),
int(sparam.ctypes.data))
cublasCheckStatus(status)
return sparam
cublasSrotmg.__doc__ = \
_ROTMG_doc.substitute(precision='single precision',
type='numpy.float32')
_libcublas.cublasDrotmg_v2.restype = int
_libcublas.cublasDrotmg_v2.argtypes = [_types.handle,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p]
def cublasDrotmg(handle, d1, d2, x1, y1):
_d1 = ctypes.c_double(d1)
_d2 = ctypes.c_double(d2)
_x1 = ctypes.c_double(x1)
_y1 = ctypes.c_double(y1)
sparam = np.empty(5, np.float64)
status = _libcublas.cublasDrotmg_v2(handle,
ctypes.byref(_d1), ctypes.byref(_d2),
ctypes.byref(_x1), ctypes.byref(_y1),
int(sparam.ctypes.data))
cublasCheckStatus(status)
return sparam
cublasDrotmg.__doc__ = \
_ROTMG_doc.substitute(precision='double precision',
type='numpy.float64')
# SSCAL, DSCAL, CSCAL, CSCAL, CSSCAL, ZSCAL, ZDSCAL
_SCAL_doc = Template(
"""
Scale a ${precision} ${real} vector by a ${precision} ${a_real} scalar.
Replaces a ${precision} ${real} vector `x` with
`alpha * x`.
Parameters
----------
handle : int
CUBLAS context.
n : int
Number of elements in input vectors.
alpha : ${a_type}
Scalar multiplier.
x : ctypes.c_void_p
Pointer to ${precision} ${real} input/output vector.
incx : int
Storage spacing between elements of `x`.
Examples
--------
>>> import pycuda.autoinit
>>> import pycuda.gpuarray as gpuarray
>>> import numpy as np
>>> x = ${data}
>>> x_gpu = gpuarray.to_gpu(x)
>>> alpha = ${alpha}
>>> h = cublasCreate()
>>> ${func}(h, x.size, alpha, x_gpu.gpudata, 1)
>>> cublasDestroy(h)
>>> np.allclose(x_gpu.get(), alpha*x)
True
References
----------
`cublasscal `_
""")
_libcublas.cublasSscal_v2.restype = int
_libcublas.cublasSscal_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasSscal(handle, n, alpha, x, incx):
status = _libcublas.cublasSscal_v2(handle, n,
ctypes.byref(ctypes.c_float(alpha)),
int(x), incx)
cublasCheckStatus(status)
cublasSscal.__doc__ = \
_SCAL_doc.substitute(precision='single precision',
real='real',
a_real='real',
a_type='numpy.float32',
alpha='np.float32(np.random.rand())',
data='np.random.rand(5).astype(np.float32)',
func='cublasSscal')
_libcublas.cublasDscal_v2.restype = int
_libcublas.cublasDscal_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasDscal(handle, n, alpha, x, incx):
status = _libcublas.cublasDscal_v2(handle, n,
ctypes.byref(ctypes.c_double(alpha)),
int(x), incx)
cublasCheckStatus(status)
cublasDscal.__doc__ = \
_SCAL_doc.substitute(precision='double precision',
real='real',
a_real='real',
a_type='numpy.float64',
alpha='np.float64(np.random.rand())',
data='np.random.rand(5).astype(np.float64)',
func='cublasDscal')
_libcublas.cublasCscal_v2.restype = int
_libcublas.cublasCscal_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasCscal(handle, n, alpha, x, incx):
status = _libcublas.cublasCscal_v2(handle, n,
ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(x), incx)
cublasCheckStatus(status)
cublasCscal.__doc__ = \
_SCAL_doc.substitute(precision='single precision',
real='complex',
a_real='complex',
a_type='numpy.complex64',
alpha='np.complex64(np.random.rand()+1j*np.random.rand())',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex64)',
func='cublasCscal')
_libcublas.cublasCsscal_v2.restype = int
_libcublas.cublasCsscal_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasCsscal(handle, n, alpha, x, incx):
status = _libcublas.cublasCsscal_v2(handle, n,
ctypes.byref(ctypes.c_float(alpha)),
int(x), incx)
cublasCheckStatus(status)
cublasCsscal.__doc__ = \
_SCAL_doc.substitute(precision='single precision',
real='complex',
a_real='real',
a_type='numpy.float32',
alpha='np.float32(np.random.rand())',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex64)',
func='cublasCsscal')
_libcublas.cublasZscal_v2.restype = int
_libcublas.cublasZscal_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasZscal(handle, n, alpha, x, incx):
status = _libcublas.cublasZscal_v2(handle, n,
ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(x), incx)
cublasCheckStatus(status)
cublasZscal.__doc__ = \
_SCAL_doc.substitute(precision='double precision',
real='complex',
a_real='complex',
a_type='numpy.complex128',
alpha='np.complex128(np.random.rand()+1j*np.random.rand())',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex128)',
func='cublasZscal')
_libcublas.cublasZdscal_v2.restype = int
_libcublas.cublasZdscal_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasZdscal(handle, n, alpha, x, incx):
status = _libcublas.cublasZdscal_v2(handle, n,
ctypes.byref(ctypes.c_double(alpha)),
int(x), incx)
cublasCheckStatus(status)
cublasZdscal.__doc__ = \
_SCAL_doc.substitute(precision='double precision',
real='complex',
a_real='real',
a_type='numpy.float64',
alpha='np.float64(np.random.rand())',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex128)',
func='cublasZdscal')
# SSWAP, DSWAP, CSWAP, ZSWAP
_SWAP_doc = Template(
"""
Swap ${precision} ${real} vectors.
Swaps the contents of one ${precision} ${real} vector with those
of another ${precision} ${real} vector.
Parameters
----------
handle : int
CUBLAS context.
n : int
Number of elements in input vectors.
x : ctypes.c_void_p
Pointer to ${precision} ${real} input/output vector.
incx : int
Storage spacing between elements of `x`.
y : ctypes.c_void_p
Pointer to ${precision} ${real} input/output vector.
incy : int
Storage spacing between elements of `y`.
Examples
--------
>>> import pycuda.autoinit
>>> import pycuda.gpuarray as gpuarray
>>> import numpy as np
>>> x = ${data}
>>> y = ${data}
>>> x_gpu = gpuarray.to_gpu(x)
>>> y_gpu = gpuarray.to_gpu(y)
>>> h = cublasCreate()
>>> ${func}(h, x.size, x_gpu.gpudata, 1, y_gpu.gpudata, 1)
>>> cublasDestroy(h)
>>> np.allclose(x_gpu.get(), y)
True
>>> np.allclose(y_gpu.get(), x)
True
Notes
-----
Both `x` and `y` must contain `n` elements.
References
----------
`cublasswap `_
""")
_libcublas.cublasSswap_v2.restype = int
_libcublas.cublasSswap_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasSswap(handle, n, x, incx, y, incy):
status = _libcublas.cublasSswap_v2(handle,
n, int(x), incx, int(y), incy)
cublasCheckStatus(status)
cublasSswap.__doc__ = \
_SWAP_doc.substitute(precision='single precision',
real='real',
data='np.random.rand(5).astype(np.float32)',
func='cublasSswap')
_libcublas.cublasDswap_v2.restype = int
_libcublas.cublasDswap_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasDswap(handle, n, x, incx, y, incy):
status = _libcublas.cublasDswap_v2(handle,
n, int(x), incx, int(y), incy)
cublasCheckStatus(status)
cublasDswap.__doc__ = \
_SWAP_doc.substitute(precision='double precision',
real='real',
data='np.random.rand(5).astype(np.float64)',
func='cublasDswap')
_libcublas.cublasCswap_v2.restype = int
_libcublas.cublasCswap_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasCswap(handle, n, x, incx, y, incy):
status = _libcublas.cublasCswap_v2(handle,
n, int(x), incx, int(y), incy)
cublasCheckStatus(status)
cublasCswap.__doc__ = \
_SWAP_doc.substitute(precision='single precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex64)',
func='cublasCswap')
_libcublas.cublasZswap_v2.restype = int
_libcublas.cublasZswap_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasZswap(handle, n, x, incx, y, incy):
status = _libcublas.cublasZswap_v2(handle,
n, int(x), incx, int(y), incy)
cublasCheckStatus(status)
cublasZswap.__doc__ = \
_SWAP_doc.substitute(precision='double precision',
real='complex',
data='(np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex128)',
func='cublasZswap')
### BLAS Level 2 Functions ###
# SGBMV, DGVMV, CGBMV, ZGBMV
_libcublas.cublasSgbmv_v2.restype = int
_libcublas.cublasSgbmv_v2.argtypes = [_types.handle,
ctypes.c_char,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasSgbmv(handle, trans, m, n, kl, ku, alpha, A, lda,
x, incx, beta, y, incy):
"""
Matrix-vector product for real single precision general banded matrix.
References
----------
`cublasgbmv `_
"""
trans = trans.encode('ascii')
status = _libcublas.cublasSgbmv_v2(handle,
trans, m, n, kl, ku,
ctypes.byref(ctypes.c_float(alpha)),
int(A), lda,
int(x), incx,
ctypes.byref(ctypes.c_float(beta)),
int(y), incy)
cublasCheckStatus(status)
_libcublas.cublasDgbmv_v2.restype = int
_libcublas.cublasDgbmv_v2.argtypes = [_types.handle,
ctypes.c_char,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasDgbmv(handle, trans, m, n, kl, ku, alpha, A, lda,
x, incx, beta, y, incy):
"""
Matrix-vector product for real double precision general banded matrix.
References
----------
`cublasgbmv `_
"""
trans = trans.encode('ascii')
status = _libcublas.cublasDgbmv_v2(handle,
trans, m, n, kl, ku,
ctypes.byref(ctypes.c_float(alpha)),
int(A), lda, int(x), incx,
ctypes.byref(ctypes.c_float(beta)),
int(y), incy)
cublasCheckStatus(status)
_libcublas.cublasCgbmv_v2.restype = int
_libcublas.cublasCgbmv_v2.argtypes = [_types.handle,
ctypes.c_char,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasCgbmv(handle, trans, m, n, kl, ku, alpha, A, lda,
x, incx, beta, y, incy):
"""
Matrix-vector product for complex single precision general banded matrix.
References
----------
`cublasgbmv `_
"""
trans = trans.encode('ascii')
status = _libcublas.cublasCgbmv_v2(handle,
trans, m, n, kl, ku,
ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(A), lda, int(x), incx,
ctypes.byref(cuda.cuFloatComplex(beta.real,
beta.imag)),
int(y), incy)
cublasCheckStatus(status)
_libcublas.cublasZgbmv_v2.restype = int
_libcublas.cublasZgbmv_v2.argtypes = [ctypes.c_char,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasZgbmv(handle, trans, m, n, kl, ku, alpha, A, lda,
x, incx, beta, y, incy):
"""
Matrix-vector product for complex double precision general banded matrix.
References
----------
`cublasgbmv `_
"""
trans = trans.encode('ascii')
status = _libcublas.cublasZgbmv_v2(handle,
trans, m, n, kl, ku,
ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(A), lda, int(x), incx,
ctypes.byref(cuda.cuDoubleComplex(beta.real,
beta.imag)),
int(y), incy)
cublasCheckStatus(status)
# SGEMV, DGEMV, CGEMV, ZGEMV # XXX need to adjust
# _GEMV_doc = Template(
# """
# Matrix-vector product for ${precision} ${real} general matrix.
# Computes the product `alpha*op(A)*x+beta*y`, where `op(A)` == `A`
# or `op(A)` == `A.T`, and stores it in `y`.
# Parameters
# ----------
# trans : char
# If `upper(trans)` in `['T', 'C']`, assume that `A` is
# transposed.
# m : int
# Number of rows in `A`.
# n : int
# Number of columns in `A`.
# alpha : ${a_type}
# `A` is multiplied by this quantity.
# A : ctypes.c_void_p
# Pointer to ${precision} matrix. The matrix has
# shape `(lda, n)` if `upper(trans)` == 'N', `(lda, m)`
# otherwise.
# lda : int
# Leading dimension of `A`.
# X : ctypes.c_void_p
# Pointer to ${precision} array of length at least
# `(1+(n-1)*abs(incx))` if `upper(trans) == 'N',
# `(1+(m+1)*abs(incx))` otherwise.
# incx : int
# Spacing between elements of `x`. Must be nonzero.
# beta : ${a_type}
# `y` is multiplied by this quantity. If zero, `y` is ignored.
# y : ctypes.c_void_p
# Pointer to ${precision} array of length at least
# `(1+(m+1)*abs(incy))` if `upper(trans)` == `N`,
# `(1+(n+1)*abs(incy))` otherwise.
# incy : int
# Spacing between elements of `y`. Must be nonzero.
# Examples
# --------
# >>> import pycuda.autoinit
# >>> import pycuda.gpuarray as gpuarray
# >>> import numpy as np
# >>> a = np.random.rand(2, 3).astype(np.float32)
# >>> x = np.random.rand(3, 1).astype(np.float32)
# >>> a_gpu = gpuarray.to_gpu(a.T.copy())
# >>> x_gpu = gpuarray.to_gpu(x)
# >>> y_gpu = gpuarray.empty((2, 1), np.float32)
# >>> alpha = np.float32(1.0)
# >>> beta = np.float32(0)
# >>> h = cublasCreate()
# >>> ${func}(h, 'n', 2, 3, alpha, a_gpu.gpudata, 2, x_gpu.gpudata, 1, beta, y_gpu.gpudata, 1)
# >>> cublasDestroy(h)
# >>> np.allclose(y_gpu.get(), np.dot(a, x))
# True
# """
_libcublas.cublasSgemv_v2.restype = int
_libcublas.cublasSgemv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasSgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix-vector product for real single precision general matrix.
References
----------
`cublasgemv `_
"""
status = _libcublas.cublasSgemv_v2(handle,
_CUBLAS_OP[trans], m, n,
ctypes.byref(ctypes.c_float(alpha)), int(A), lda,
int(x), incx,
ctypes.byref(ctypes.c_float(beta)), int(y), incy)
cublasCheckStatus(status)
_libcublas.cublasDgemv_v2.restype = int
_libcublas.cublasDgemv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasDgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix-vector product for real double precision general matrix.
References
----------
`cublasgemv `_
"""
status = _libcublas.cublasDgemv_v2(handle,
_CUBLAS_OP[trans], m, n,
ctypes.byref(ctypes.c_double(alpha)),
int(A), lda, int(x), incx,
ctypes.byref(ctypes.c_double(beta)),
int(y), incy)
cublasCheckStatus(status)
_libcublas.cublasCgemv_v2.restype = int
_libcublas.cublasCgemv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasCgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix-vector product for complex single precision general matrix.
References
----------
`cublasgemv `_
"""
status = _libcublas.cublasCgemv_v2(handle,
_CUBLAS_OP[trans], m, n,
ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(A), lda, int(x), incx,
ctypes.byref(cuda.cuFloatComplex(beta.real,
beta.imag)),
int(y), incy)
cublasCheckStatus(status)
_libcublas.cublasZgemv_v2.restype = int
_libcublas.cublasZgemv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasZgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix-vector product for complex double precision general matrix.
References
----------
`cublasgemv `_
"""
status = _libcublas.cublasZgemv_v2(handle,
_CUBLAS_OP[trans], m, n,
ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(A), lda, int(x), incx,
ctypes.byref(cuda.cuDoubleComplex(beta.real,
beta.imag)),
int(y), incy)
cublasCheckStatus(status)
# SGER, DGER, CGERU, CGERC, ZGERU, ZGERC
_libcublas.cublasSger_v2.restype = int
_libcublas.cublasSger_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasSger(handle, m, n, alpha, x, incx, y, incy, A, lda):
"""
Rank-1 operation on real single precision general matrix.
References
----------
`cublasger `_
"""
status = _libcublas.cublasSger_v2(handle,
m, n,
ctypes.byref(ctypes.c_float(alpha)),
int(x), incx,
int(y), incy, int(A), lda)
cublasCheckStatus(status)
_libcublas.cublasDger_v2.restype = int
_libcublas.cublasDger_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasDger(handle, m, n, alpha, x, incx, y, incy, A, lda):
"""
Rank-1 operation on real double precision general matrix.
References
----------
`cublasger `_
"""
status = _libcublas.cublasDger_v2(handle,
m, n,
ctypes.byref(ctypes.c_double(alpha)),
int(x), incx,
int(y), incy, int(A), lda)
cublasCheckStatus(status)
_libcublas.cublasCgerc_v2.restype = int
_libcublas.cublasCgerc_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasCgerc(handle, m, n, alpha, x, incx, y, incy, A, lda):
"""
Rank-1 operation on complex single precision general matrix.
References
----------
`cublasger `_
"""
status = _libcublas.cublasCgerc_v2(handle,
m, n, ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(x), incx, int(y), incy, int(A), lda)
cublasCheckStatus(status)
_libcublas.cublasCgeru_v2.restype = int
_libcublas.cublasCgeru_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasCgeru(handle, m, n, alpha, x, incx, y, incy, A, lda):
"""
Rank-1 operation on complex single precision general matrix.
References
----------
`cublasger `_
"""
status = _libcublas.cublasCgeru_v2(handle,
m, n, ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(x), incx, int(y), incy, int(A), lda)
cublasCheckStatus(status)
_libcublas.cublasZgerc_v2.restype = int
_libcublas.cublasZgerc_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasZgerc(handle, m, n, alpha, x, incx, y, incy, A, lda):
"""
Rank-1 operation on complex double precision general matrix.
References
----------
`cublasger `_
"""
status = _libcublas.cublasZgerc_v2(handle,
m, n, ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(x), incx, int(y), incy, int(A), lda)
cublasCheckStatus(status)
_libcublas.cublasZgeru_v2.restype = int
_libcublas.cublasZgeru_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasZgeru(handle, m, n, alpha, x, incx, y, incy, A, lda):
"""
Rank-1 operation on complex double precision general matrix.
References
----------
`cublasger `_
"""
status = _libcublas.cublasZgeru_v2(handle,
m, n, ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(x), incx, int(y), incy, int(A), lda)
cublasCheckStatus(status)
# SSBMV, DSBMV
_libcublas.cublasSsbmv_v2.restype = int
_libcublas.cublasSsbmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasSsbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix-vector product for real single precision symmetric-banded matrix.
References
----------
`cublassbmv `_
"""
status = _libcublas.cublasSsbmv_v2(handle,
_CUBLAS_FILL_MODE[uplo], n, k,
ctypes.byref(ctypes.c_float(alpha)),
int(A), lda, int(x), incx,
ctypes.byref(ctypes.c_float(beta)),
int(y), incy)
cublasCheckStatus(status)
_libcublas.cublasDsbmv_v2.restype = int
_libcublas.cublasDsbmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasDsbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix-vector product for real double precision symmetric-banded matrix.
References
----------
`cublasger `_
"""
status = _libcublas.cublasDsbmv_v2(handle,
_CUBLAS_FILL_MODE[uplo], n, k,
ctypes.byref(ctypes.c_double(alpha)),
int(A), lda, int(x), incx,
ctypes.byref(ctypes.c_double(beta)),
int(y), incy)
cublasCheckStatus(status)
# SSPMV, DSPMV
_libcublas.cublasSspmv_v2.restype = int
_libcublas.cublasSspmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasSspmv(handle, uplo, n, alpha, AP, x, incx, beta, y, incy):
"""
Matrix-vector product for real single precision symmetric packed matrix.
References
----------
`cublasspmv `_
"""
status = _libcublas.cublasSspmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n,
ctypes.byref(ctypes.c_float(alpha)),
ctypes.byref(ctypes.c_float(AP)),
int(x),
incx,
ctypes.byref(ctypes.c_float(beta)),
int(y),
incy)
cublasCheckStatus(status)
_libcublas.cublasDspmv_v2.restype = int
_libcublas.cublasDspmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasDspmv(handle, uplo, n, alpha, AP, x, incx, beta, y, incy):
"""
Matrix-vector product for real double precision symmetric packed matrix.
References
----------
`cublasspmv `_
"""
status = _libcublas.cublasDspmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n,
ctypes.byref(ctypes.c_double(alpha)),
ctypes.byref(ctypes.c_double(AP)),
int(x),
incx,
ctypes.byref(ctypes.c_double(beta)),
int(y),
incy)
cublasCheckStatus(status)
# SSPR, DSPR
_libcublas.cublasSspr_v2.restype = int
_libcublas.cublasSspr_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasSspr(handle, uplo, n, alpha, x, incx, AP):
"""
Rank-1 operation on real single precision symmetric packed matrix.
References
----------
`cublasspr `_
"""
status = _libcublas.cublasSspr_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(ctypes.c_float(alpha)),
int(x), incx, int(AP))
cublasCheckStatus(status)
_libcublas.cublasDspr_v2.restype = int
_libcublas.cublasDspr_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasDspr(handle, uplo, n, alpha, x, incx, AP):
"""
Rank-1 operation on real double precision symmetric packed matrix.
References
----------
`cublasspr `_
"""
status = _libcublas.cublasDspr_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(ctypes.c_double(alpha)),
int(x), incx, int(AP))
cublasCheckStatus(status)
# SSPR2, DSPR2
_libcublas.cublasSspr2_v2.restype = int
_libcublas.cublasSspr2_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasSspr2(handle, uplo, n, alpha, x, incx, y, incy, AP):
"""
Rank-2 operation on real single precision symmetric packed matrix.
References
----------
`cublasspr2 `_
"""
status = _libcublas.cublasSspr2_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(ctypes.c_float(alpha)),
int(x), incx, int(y), incy, int(AP))
cublasCheckStatus(status)
_libcublas.cublasDspr2_v2.restype = int
_libcublas.cublasDspr2_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasDspr2(handle, uplo, n, alpha, x, incx, y, incy, AP):
"""
Rank-2 operation on real double precision symmetric packed matrix.
References
----------
`cublasspr2 `_
"""
status = _libcublas.cublasDspr2_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(ctypes.c_double(alpha)),
int(x), incx, int(y), incy, int(AP))
cublasCheckStatus(status)
# SSYMV, DSYMV, CSYMV, ZSYMV
_libcublas.cublasSsymv_v2.restype = int
_libcublas.cublasSsymv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasSsymv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix-vector product for real symmetric matrix.
References
----------
`cublassymv `_
"""
status = _libcublas.cublasSsymv_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(ctypes.c_float(alpha)),
int(A), lda, int(x), incx,
ctypes.byref(ctypes.c_float(beta)),
int(y), incy)
cublasCheckStatus(status)
_libcublas.cublasDsymv_v2.restype = int
_libcublas.cublasDsymv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasDsymv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix-vector product for real double precision symmetric matrix.
References
----------
`cublassymv `_
"""
status = _libcublas.cublasDsymv_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(ctypes.c_double(alpha)),
int(A), lda, int(x), incx,
ctypes.byref(ctypes.c_double(beta)),
int(y), incy)
cublasCheckStatus(status)
if _cublas_version >= 5000:
_libcublas.cublasCsymv_v2.restype = int
_libcublas.cublasCsymv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
@_cublas_version_req(5.0)
def cublasCsymv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix-vector product for complex single precision symmetric matrix.
References
----------
`cublassymv `_
"""
status = _libcublas.cublasCsymv_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(A), lda, int(x), incx,
ctypes.byref(cuda.cuFloatComplex(beta.real,
beta.imag)),
int(y), incy)
cublasCheckStatus(status)
if _cublas_version >= 5000:
_libcublas.cublasZsymv_v2.restype = int
_libcublas.cublasZsymv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
@_cublas_version_req(5.0)
def cublasZsymv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix-vector product for complex double precision symmetric matrix.
References
----------
`cublassymv `_
"""
status = _libcublas.cublasZsymv_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(A), lda, int(x), incx,
ctypes.byref(cuda.cuDoubleComplex(beta.real,
beta.imag)),
int(y), incy)
cublasCheckStatus(status)
# SSYR, DSYR, CSYR, ZSYR
_libcublas.cublasSsyr_v2.restype = int
_libcublas.cublasSsyr_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasSsyr(handle, uplo, n, alpha, x, incx, A, lda):
"""
Rank-1 operation on real single precision symmetric matrix.
References
----------
`cublassyr `_
"""
status = _libcublas.cublasSsyr_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(ctypes.c_float(alpha)),
int(x), incx, int(A), lda)
cublasCheckStatus(status)
_libcublas.cublasDsyr_v2.restype = int
_libcublas.cublasDsyr_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasDsyr(handle, uplo, n, alpha, x, incx, A, lda):
"""
Rank-1 operation on real double precision symmetric matrix.
References
----------
`cublassyr `_
"""
status = _libcublas.cublasDsyr_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(ctypes.c_double(alpha)),
int(x), incx, int(A), lda)
cublasCheckStatus(status)
if _cublas_version >= 5000:
_libcublas.cublasCsyr_v2.restype = int
_libcublas.cublasCsyr_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
@_cublas_version_req(5.0)
def cublasCsyr(handle, uplo, n, alpha, x, incx, A, lda):
"""
Rank-1 operation on complex single precision symmetric matrix.
References
----------
`cublassyr `_
"""
status = _libcublas.cublasCsyr_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(x), incx, int(A), lda)
cublasCheckStatus(status)
if _cublas_version >= 5000:
_libcublas.cublasZsyr_v2.restype = int
_libcublas.cublasZsyr_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
@_cublas_version_req(5.0)
def cublasZsyr(handle, uplo, n, alpha, x, incx, A, lda):
"""
Rank-1 operation on complex double precision symmetric matrix.
References
----------
`cublassyr `_
"""
status = _libcublas.cublasZsyr_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(x), incx, int(A), lda)
cublasCheckStatus(status)
# SSYR2, DSYR2, CSYR2, ZSYR2
_libcublas.cublasSsyr2_v2.restype = int
_libcublas.cublasSsyr2_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasSsyr2(handle, uplo, n, alpha, x, incx, y, incy, A, lda):
"""
Rank-2 operation on real single precision symmetric matrix.
References
----------
`cublassyr2 `_
"""
status = _libcublas.cublasSsyr2_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(ctypes.c_float(alpha)),
int(x), incx, int(y), incy,
int(A), lda)
cublasCheckStatus(status)
_libcublas.cublasDsyr2_v2.restype = int
_libcublas.cublasDsyr2_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasDsyr2(handle, uplo, n, alpha, x, incx, y, incy, A, lda):
"""
Rank-2 operation on real double precision symmetric matrix.
References
----------
`cublassyr2 `_
"""
status = _libcublas.cublasDsyr2_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(ctypes.c_double(alpha)),
int(x), incx, int(y), incy,
int(A), lda)
cublasCheckStatus(status)
if _cublas_version >= 5000:
_libcublas.cublasCsyr2_v2.restype = int
_libcublas.cublasCsyr2_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
@_cublas_version_req(5.0)
def cublasCsyr2(handle, uplo, n, alpha, x, incx, y, incy, A, lda):
"""
Rank-2 operation on complex single precision symmetric matrix.
References
----------
`cublassyr2 `_
"""
status = _libcublas.cublasCsyr2_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(x), incx, int(y), incy,
int(A), lda)
cublasCheckStatus(status)
if _cublas_version >= 5000:
_libcublas.cublasZsyr2_v2.restype = int
_libcublas.cublasZsyr2_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
@_cublas_version_req(5.0)
def cublasZsyr2(handle, uplo, n, alpha, x, incx, y, incy, A, lda):
"""
Rank-2 operation on complex double precision symmetric matrix.
References
----------
`cublassyr2 `_
"""
status = _libcublas.cublasZsyr2_v2(handle,
_CUBLAS_FILL_MODE[uplo], n,
ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(x), incx, int(y), incy,
int(A), lda)
cublasCheckStatus(status)
# STBMV, DTBMV, CTBMV, ZTBMV
_libcublas.cublasStbmv_v2.restype = int
_libcublas.cublasStbmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasStbmv(handle, uplo, trans, diag, n, k, A, lda, x, incx):
"""
Matrix-vector product for real single precision triangular banded matrix.
References
----------
`cublastbmv `_
"""
status = _libcublas.cublasStbmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, k, int(A), lda, int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasDtbmv_v2.restype = int
_libcublas.cublasDtbmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasDtbmv(handle, uplo, trans, diag, n, k, A, lda, x, incx):
"""
Matrix-vector product for real double precision triangular banded matrix.
References
----------
`cublastbmv `_
"""
status = _libcublas.cublasDtbmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, k, int(A), lda, int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasCtbmv_v2.restype = int
_libcublas.cublasCtbmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasCtbmv(handle, uplo, trans, diag, n, k, A, lda, x, incx):
"""
Matrix-vector product for complex single precision triangular banded matrix.
References
----------
`cublastbmv `_
"""
status = _libcublas.cublasCtbmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, k, int(A), lda, int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasZtbmv_v2.restype = int
_libcublas.cublasZtbmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasZtbmv(handle, uplo, trans, diag, n, k, A, lda, x, incx):
"""
Matrix-vector product for complex double triangular banded matrix.
References
----------
`cublastbmv `_
"""
status = _libcublas.cublasZtbmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, k, int(A), lda, int(x), incx)
cublasCheckStatus(status)
# STBSV, DTBSV, CTBSV, ZTBSV
_libcublas.cublasStbsv_v2.restype = int
_libcublas.cublasStbsv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasStbsv(handle, uplo, trans, diag, n, k, A, lda, x, incx):
"""
Solve real single precision triangular banded system with one right-hand side.
References
----------
`cublastbsv `_
"""
status = _libcublas.cublasStbsv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, k, int(A), lda, int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasDtbsv_v2.restype = int
_libcublas.cublasDtbsv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasDtbsv(handle, uplo, trans, diag, n, k, A, lda, x, incx):
"""
Solve real double precision triangular banded system with one right-hand side.
References
----------
`cublastbsv `_
"""
status = _libcublas.cublasDtbsv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, k, int(A), lda, int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasCtbsv_v2.restype = int
_libcublas.cublasCtbsv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasCtbsv(handle, uplo, trans, diag, n, k, A, lda, x, incx):
"""
Solve complex single precision triangular banded system with one right-hand side.
References
----------
`cublastbsv `_
"""
status = _libcublas.cublasCtbsv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, k, int(A), lda, int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasZtbsv_v2.restype = int
_libcublas.cublasZtbsv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasZtbsv(handle, uplo, trans, diag, n, k, A, lda, x, incx):
"""
Solve complex double precision triangular banded system with one right-hand side.
References
----------
`cublastbsv `_
"""
status = _libcublas.cublasZtbsv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, k, int(A), lda, int(x), incx)
cublasCheckStatus(status)
# STPMV, DTPMV, CTPMV, ZTPMV
_libcublas.cublasStpmv_v2.restype = int
_libcublas.cublasStpmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasStpmv(handle, uplo, trans, diag, n, AP, x, incx):
"""
Matrix-vector product for real single precision triangular packed matrix.
References
----------
`cublastpmv `_
"""
status = _libcublas.cublasStpmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(AP), int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasCtpmv_v2.restype = int
_libcublas.cublasCtpmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasCtpmv(handle, uplo, trans, diag, n, AP, x, incx):
"""
Matrix-vector product for complex single precision triangular packed matrix.
References
----------
`cublastpmv `_
"""
status = _libcublas.cublasCtpmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(AP), int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasDtpmv_v2.restype = int
_libcublas.cublasDtpmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasDtpmv(handle, uplo, trans, diag, n, AP, x, incx):
"""
Matrix-vector product for real double precision triangular packed matrix.
References
----------
`cublastpmv `_
"""
status = _libcublas.cublasDtpmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(AP), int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasZtpmv_v2.restype = int
_libcublas.cublasZtpmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasZtpmv(handle, uplo, trans, diag, n, AP, x, incx):
"""
Matrix-vector product for complex double precision triangular packed matrix.
References
----------
`cublastpmv `_
"""
status = _libcublas.cublasZtpmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(AP), int(x), incx)
cublasCheckStatus(status)
# STPSV, DTPSV, CTPSV, ZTPSV
_libcublas.cublasStpsv_v2.restype = int
_libcublas.cublasStpsv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasStpsv(handle, uplo, trans, diag, n, AP, x, incx):
"""
Solve real triangular packed system with one right-hand side.
References
----------
`cublastpsv `_
"""
status = _libcublas.cublasStpsv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(AP), int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasDtpsv_v2.restype = int
_libcublas.cublasDtpsv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasDtpsv(handle, uplo, trans, diag, n, AP, x, incx):
"""
Solve real double precision triangular packed system with one right-hand side.
References
----------
`cublastpsv `_
"""
status = _libcublas.cublasDtpsv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(AP), int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasCtpsv_v2.restype = int
_libcublas.cublasCtpsv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasCtpsv(handle, uplo, trans, diag, n, AP, x, incx):
"""
Solve complex single precision triangular packed system with one right-hand side.
References
----------
`cublastpsv `_
"""
status = _libcublas.cublasCtpsv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(AP), int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasZtpsv_v2.restype = int
_libcublas.cublasZtpsv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasZtpsv(handle, uplo, trans, diag, n, AP, x, incx):
"""
Solve complex double precision triangular packed system with one right-hand size.
References
----------
`cublastpsv `_
"""
status = _libcublas.cublasZtpsv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(AP), int(x), incx)
cublasCheckStatus(status)
# STRMV, DTRMV, CTRMV, ZTRMV
_libcublas.cublasStrmv_v2.restype = int
_libcublas.cublasStrmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasStrmv(handle, uplo, trans, diag, n, A, lda, x, inx):
"""
Matrix-vector product for real single precision triangular matrix.
References
----------
`cublastrmv `_
"""
status = _libcublas.cublasStrmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(A), lda, int(x), inx)
cublasCheckStatus(status)
_libcublas.cublasCtrmv_v2.restype = int
_libcublas.cublasCtrmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasCtrmv(handle, uplo, trans, diag, n, A, lda, x, incx):
"""
Matrix-vector product for complex single precision triangular matrix.
References
----------
`cublastrmv `_
"""
status = _libcublas.cublasCtrmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(A), lda, int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasDtrmv_v2.restype = int
_libcublas.cublasDtrmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasDtrmv(handle, uplo, trans, diag, n, A, lda, x, inx):
"""
Matrix-vector product for real double precision triangular matrix.
References
----------
`cublastrmv `_
"""
status = _libcublas.cublasDtrmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(A), lda, int(x), inx)
cublasCheckStatus(status)
_libcublas.cublasZtrmv_v2.restype = int
_libcublas.cublasZtrmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasZtrmv(handle, uplo, trans, diag, n, A, lda, x, incx):
"""
Matrix-vector product for complex double precision triangular matrix.
References
----------
`cublastrmv `_
"""
status = _libcublas.cublasZtrmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(A), lda, int(x), incx)
cublasCheckStatus(status)
# STRSV, DTRSV, CTRSV, ZTRSV
_libcublas.cublasStrsv_v2.restype = int
_libcublas.cublasStrsv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasStrsv(handle, uplo, trans, diag, n, A, lda, x, incx):
"""
Solve real triangular system with one right-hand side.
References
----------
`cublastrsv `_
"""
status = _libcublas.cublasStrsv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(A), lda, int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasDtrsv_v2.restype = int
_libcublas.cublasDtrsv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasDtrsv(handle, uplo, trans, diag, n, A, lda, x, incx):
"""
Solve real double precision triangular system with one right-hand side.
References
----------
`cublastrsv `_
"""
status = _libcublas.cublasDtrsv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(A), lda, int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasCtrsv_v2.restype = int
_libcublas.cublasCtrsv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasCtrsv(handle, uplo, trans, diag, n, A, lda, x, incx):
"""
Solve complex single precision triangular system with one right-hand side.
References
----------
`cublastrsv `_
"""
status = _libcublas.cublasCtrsv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(A), lda, int(x), incx)
cublasCheckStatus(status)
_libcublas.cublasZtrsv_v2.restype = int
_libcublas.cublasZtrsv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasZtrsv(handle, uplo, trans, diag, n, A, lda, x, incx):
"""
Solve complex double precision triangular system with one right-hand side.
References
----------
`cublastrsv `_
"""
status = _libcublas.cublasZtrsv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
_CUBLAS_DIAG[diag],
n, int(A), lda, int(x), incx)
cublasCheckStatus(status)
# CHEMV, ZHEMV
_libcublas.cublasChemv_v2.restype = int
_libcublas.cublasChemv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasChemv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix vector product for single precision Hermitian matrix.
References
----------
`cublashemv `_
"""
status = _libcublas.cublasChemv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(A), lda, int(x), incx,
ctypes.byref(cuda.cuFloatComplex(beta.real,
beta.imag)),
int(y), incy)
cublasCheckStatus(status)
_libcublas.cublasZhemv_v2.restype = int
_libcublas.cublasZhemv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasZhemv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix-vector product for double precision Hermitian matrix.
References
----------
`cublashemv `_
"""
status = _libcublas.cublasZhemv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(A), lda, int(x), incx,
ctypes.byref(cuda.cuDoubleComplex(beta.real,
beta.imag)),
int(y), incy)
cublasCheckStatus(status)
# CHBMV, ZHBMV
_libcublas.cublasChbmv_v2.restype = int
_libcublas.cublasChbmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasChbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix-vector product for single precision Hermitian banded matrix.
References
----------
`cublashbmv `_
"""
status = _libcublas.cublasChbmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, k,
ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(A), lda, int(x), incx,
ctypes.byref(cuda.cuFloatComplex(beta.real,
beta.imag)),
int(y), incy)
cublasCheckStatus(status)
_libcublas.cublasZhbmv_v2.restype = int
_libcublas.cublasZhbmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasZhbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy):
"""
Matrix-vector product for double precision Hermitian banded matrix.
References
----------
`cublashbmv `_
"""
status = _libcublas.cublasZhbmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, k,
ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(A), lda, int(x), incx,
ctypes.byref(cuda.cuDoubleComplex(beta.real,
beta.imag)),
int(y), incy)
cublasCheckStatus(status)
# CHPMV, ZHPMV
_libcublas.cublasChpmv_v2.restype = int
_libcublas.cublasChpmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasChpmv(handle, uplo, n, alpha, AP, x, incx, beta, y, incy):
"""
Matrix-vector product for single precision Hermitian packed matrix.
References
----------
`cublashpmv `_
"""
status = _libcublas.cublasChpmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(AP), int(x), incx,
ctypes.byref(cuda.cuFloatComplex(beta.real,
beta.imag)),
int(y), incy)
cublasCheckStatus(status)
_libcublas.cublasZhpmv_v2.restype = int
_libcublas.cublasZhpmv_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasZhpmv(handle, uplo, n, alpha, AP, x, incx, beta, y, incy):
"""
Matrix-vector product for double precision Hermitian packed matrix.
References
----------
`cublashpmv `_
"""
status = _libcublas.cublasZhpmv_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(AP), int(x), incx,
ctypes.byref(cuda.cuDoubleComplex(beta.real,
beta.imag)),
int(y), incy)
cublasCheckStatus(status)
# CHER, ZHER
_libcublas.cublasCher_v2.restype = int
_libcublas.cublasCher_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasCher(handle, uplo, n, alpha, x, incx, A, lda):
"""
Rank-1 operation on single precision Hermitian matrix.
References
----------
`cublasher `_
"""
status = _libcublas.cublasCher_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, alpha, int(x), incx, int(A), lda)
cublasCheckStatus(status)
_libcublas.cublasZher_v2.restype = int
_libcublas.cublasZher_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasZher(handle, uplo, n, alpha, x, incx, A, lda):
"""
Rank-1 operation on double precision Hermitian matrix.
References
----------
`cublasher `_
"""
status = _libcublas.cublasZher_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, alpha, int(x), incx, int(A), lda)
cublasCheckStatus(status)
# CHER2, ZHER2
_libcublas.cublasCher2_v2.restype = int
_libcublas.cublasCher2_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasCher2(handle, uplo, n, alpha, x, incx, y, incy, A, lda):
"""
Rank-2 operation on single precision Hermitian matrix.
References
----------
`cublasher2 `_
"""
status = _libcublas.cublasCher2_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(x), incx, int(y), incy, int(A), lda)
cublasCheckStatus(status)
_libcublas.cublasZher2_v2.restype = int
_libcublas.cublasZher2_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int]
def cublasZher2(handle, uplo, n, alpha, x, incx, y, incy, A, lda):
"""
Rank-2 operation on double precision Hermitian matrix.
References
----------
`cublasher2 `_
"""
status = _libcublas.cublasZher2_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(x), incx, int(y), incy, int(A), lda)
cublasCheckStatus(status)
# CHPR, ZHPR
_libcublas.cublasChpr_v2.restype = int
_libcublas.cublasChpr_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasChpr(handle, uplo, n, alpha, x, incx, AP):
"""
Rank-1 operation on single precision Hermitian packed matrix.
References
----------
`cublashpr `_
"""
status = _libcublas.cublasChpr_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, ctypes.byref(ctypes.c_float(alpha)),
int(x), incx, int(AP))
cublasCheckStatus(status)
_libcublas.cublasZhpr_v2.restype = int
_libcublas.cublasZhpr_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasZhpr(handle, uplo, n, alpha, x, incx, AP):
"""
Rank-1 operation on double precision Hermitian packed matrix.
References
----------
`cublashpr `_
"""
status = _libcublas.cublasZhpr_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, ctypes.byref(ctypes.c_double(alpha)),
int(x), incx, int(AP))
cublasCheckStatus(status)
# CHPR2, ZHPR2
_libcublas.cublasChpr2.restype = int
_libcublas.cublasChpr2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasChpr2(handle, uplo, n, alpha, x, inx, y, incy, AP):
"""
Rank-2 operation on single precision Hermitian packed matrix.
References
----------
`cublashpr2 `_
"""
status = _libcublas.cublasChpr2_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(x), incx, int(y), incy, int(AP))
cublasCheckStatus(status)
_libcublas.cublasZhpr2_v2.restype = int
_libcublas.cublasZhpr2_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p]
def cublasZhpr2(handle, uplo, n, alpha, x, inx, y, incy, AP):
"""
Rank-2 operation on double precision Hermitian packed matrix.
References
----------
`cublashpr2 `_
"""
status = _libcublas.cublasZhpr2_v2(handle,
_CUBLAS_FILL_MODE[uplo],
n, ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(x), incx, int(y), incy, int(AP))
cublasCheckStatus(status)
# SGEMM, CGEMM, DGEMM, ZGEMM
_libcublas.cublasSgemm_v2.restype = int
_libcublas.cublasSgemm_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasSgemm(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc):
"""
Matrix-matrix product for real single precision general matrix.
References
----------
`cublasgemm `_
"""
status = _libcublas.cublasSgemm_v2(handle,
_CUBLAS_OP[transa],
_CUBLAS_OP[transb], m, n, k,
ctypes.byref(ctypes.c_float(alpha)),
int(A), lda, int(B), ldb,
ctypes.byref(ctypes.c_float(beta)),
int(C), ldc)
cublasCheckStatus(status)
_libcublas.cublasCgemm_v2.restype = int
_libcublas.cublasCgemm_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasCgemm(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc):
"""
Matrix-matrix product for complex single precision general matrix.
References
----------
`cublasgemm `_
"""
status = _libcublas.cublasCgemm_v2(handle,
_CUBLAS_OP[transa],
_CUBLAS_OP[transb], m, n, k,
ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(A), lda, int(B), ldb,
ctypes.byref(cuda.cuFloatComplex(beta.real,
beta.imag)),
int(C), ldc)
cublasCheckStatus(status)
_libcublas.cublasDgemm_v2.restype = int
_libcublas.cublasDgemm_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasDgemm(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc):
"""
Matrix-matrix product for real double precision general matrix.
References
----------
`cublasgemm `_
"""
status = _libcublas.cublasDgemm_v2(handle,
_CUBLAS_OP[transa],
_CUBLAS_OP[transb], m, n, k,
ctypes.byref(ctypes.c_double(alpha)),
int(A), lda, int(B), ldb,
ctypes.byref(ctypes.c_double(beta)),
int(C), ldc)
cublasCheckStatus(status)
_libcublas.cublasZgemm_v2.restype = int
_libcublas.cublasZgemm_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasZgemm(handle, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc):
"""
Matrix-matrix product for complex double precision general matrix.
References
----------
`cublasgemm `_
"""
status = _libcublas.cublasZgemm_v2(handle,
_CUBLAS_OP[transa],
_CUBLAS_OP[transb], m, n, k,
ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(A), lda, int(B), ldb,
ctypes.byref(cuda.cuDoubleComplex(beta.real,
beta.imag)),
int(C), ldc)
cublasCheckStatus(status)
# SSYMM, DSYMM, CSYMM, ZSYMM
_libcublas.cublasSsymm_v2.restype = int
_libcublas.cublasSsymm_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasSsymm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc):
"""
Matrix-matrix product for real single precision symmetric matrix.
References
----------
`cublassymm `_
"""
status = _libcublas.cublasSsymm_v2(handle,
_CUBLAS_SIDE_MODE[side],
_CUBLAS_FILL_MODE[uplo],
m, n, ctypes.byref(ctypes.c_float(alpha)),
int(A), lda, int(B), ldb,
ctypes.byref(ctypes.c_float(beta)),
int(C), ldc)
cublasCheckStatus(status)
_libcublas.cublasDsymm_v2.restype = int
_libcublas.cublasDsymm_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasDsymm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc):
"""
Matrix-matrix product for real double precision symmetric matrix.
References
----------
`cublassymm `_
"""
status = _libcublas.cublasDsymm_v2(handle,
_CUBLAS_SIDE_MODE[side],
_CUBLAS_FILL_MODE[uplo],
m, n, ctypes.byref(ctypes.c_double(alpha)),
int(A), lda, int(B), ldb,
ctypes.byref(ctypes.c_double(beta)),
int(C), ldc)
cublasCheckStatus(status)
_libcublas.cublasCsymm_v2.restype = int
_libcublas.cublasCsymm_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasCsymm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc):
"""
Matrix-matrix product for complex single precision symmetric matrix.
References
----------
`cublassymm `_
"""
status = _libcublas.cublasCsymm_v2(handle,
_CUBLAS_SIDE_MODE[side],
_CUBLAS_FILL_MODE[uplo],
m, n, ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(A), lda, int(B), ldb,
ctypes.byref(cuda.cuFloatComplex(beta.real,
beta.imag)),
int(C), ldc)
cublasCheckStatus(status)
_libcublas.cublasZsymm_v2.restype = int
_libcublas.cublasZsymm_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasZsymm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc):
"""
Matrix-matrix product for complex double precision symmetric matrix.
References
----------
`cublassymm `_
"""
status = _libcublas.cublasZsymm_v2(handle,
_CUBLAS_SIDE_MODE[side],
_CUBLAS_FILL_MODE[uplo], m, n,
ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(A), lda, int(B), ldb,
ctypes.byref(cuda.cuDoubleComplex(beta.real,
beta.imag)),
int(C), ldc)
cublasCheckStatus(status)
# SSYRK, DSYRK, CSYRK, ZSYRK
_libcublas.cublasSsyrk_v2.restype = int
_libcublas.cublasSsyrk_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasSsyrk(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc):
"""
Rank-k operation on real single precision symmetric matrix.
References
----------
`cublassyrk `_
"""
status = _libcublas.cublasSsyrk_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
n, k, ctypes.byref(ctypes.c_float(alpha)),
int(A), lda,
ctypes.byref(ctypes.c_float(beta)),
int(C), ldc)
cublasCheckStatus(status)
_libcublas.cublasDsyrk_v2.restype = int
_libcublas.cublasDsyrk_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasDsyrk(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc):
"""
Rank-k operation on real double precision symmetric matrix.
References
----------
`cublassyrk `_
"""
status = _libcublas.cublasDsyrk_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
n, k, ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(A), lda,
ctypes.byref(cuda.cuFloatComplex(beta.real,
beta.imag)),
int(C), ldc)
cublasCheckStatus(status)
_libcublas.cublasCsyrk_v2.restype = int
_libcublas.cublasCsyrk_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasCsyrk(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc):
"""
Rank-k operation on complex single precision symmetric matrix.
References
----------
`cublassyrk `_
"""
status = _libcublas.cublasCsyrk_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
n, k, ctypes.byref(cuda.cuFloatComplex(alpha.real,
alpha.imag)),
int(A), lda,
ctypes.byref(cuda.cuFloatComplex(beta.real,
beta.imag)),
int(C), ldc)
cublasCheckStatus(status)
_libcublas.cublasZsyrk_v2.restype = int
_libcublas.cublasZsyrk_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasZsyrk(handle, uplo, trans, n, k, alpha, A, lda, beta, C, ldc):
"""
Rank-k operation on complex double precision symmetric matrix.
References
----------
`cublassyrk `_
"""
status = _libcublas.cublasZsyrk_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
n, k, ctypes.byref(cuda.cuDoubleComplex(alpha.real,
alpha.imag)),
int(A), lda,
ctypes.byref(cuda.cuDoubleComplex(beta.real,
beta.imag)),
int(C), ldc)
cublasCheckStatus(status)
# SSYR2K, DSYR2K, CSYR2K, ZSYR2K
_libcublas.cublasSsyr2k_v2.restype = int
_libcublas.cublasSsyr2k_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasSsyr2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc):
"""
Rank-2k operation on real single precision symmetric matrix.
References
----------
`cublassyr2k `_
"""
status = _libcublas.cublasSsyr2k_v2(handle,
_CUBLAS_FILL_MODE[uplo],
_CUBLAS_OP[trans],
n, k, ctypes.byref(ctypes.c_float(alpha)),
int(A), lda, int(B), ldb,
ctypes.byref(ctypes.c_float(beta)),
int(C), ldc)
cublasCheckStatus(status)
_libcublas.cublasDsyr2k_v2.restype = int
_libcublas.cublasDsyr2k_v2.argtypes = [_types.handle,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_int,
ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_int]
def cublasDsyr2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc):
"""
Rank-2k operation on real double precision symmetric matrix.
References
----------
`cublas