pyviennacl-1.0.2+dfsg.orig/0000755000000000000000000000000012332260016014231 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/pyviennacl/0000755000000000000000000000000012332260016016401 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/pyviennacl/vclmath.py0000644000000000000000000000253212307335633020425 0ustar rootroot""" This submodule provides convenience functions for performing basic mathematical operations, akin to the standard Python module `math'. ``pyviennacl.vclmath`` is also accessible under ``pyviennacl.math``, for simplicity Convenient equivalences ^^^^^^^^^^^^^^^^^^^^^^^ ========= ======================= ``abs`` ``pycore.ElementAbs`` ``acos`` ``pycore.ElementAcos`` ``asin`` ``pycore.ElementAsin`` ``atan`` ``pycore.ElementAtan`` ``ceil`` ``pycore.ElementCeil`` ``cos`` ``pycore.ElementCos`` ``cosh`` ``pycore.ElementCosh`` ``exp`` ``pycore.ElementExp`` ``fabs`` ``pycore.ElementFabs`` ``floor`` ``pycore.ElementFloor`` ``log`` ``pycore.ElementLog`` ``log10`` ``pycore.ElementLog10`` ``sin`` ``pycore.ElementSin`` ``sinh`` ``pycore.ElementSinh`` ``sqrt`` ``pycore.ElementSqrt`` ``tan`` ``pycore.ElementTan`` ``tanh`` ``pycore.ElementTanh`` ========= ======================= """ from pyviennacl import pycore abs = pycore.ElementAbs acos = pycore.ElementAcos asin = pycore.ElementAsin atan = pycore.ElementAtan ceil = pycore.ElementCeil cos = pycore.ElementCos cosh = pycore.ElementCosh exp = pycore.ElementExp fabs = pycore.ElementFabs floor = pycore.ElementFloor log = pycore.ElementLog log10 = pycore.ElementLog10 sin = pycore.ElementSin sinh = pycore.ElementSinh sqrt = pycore.ElementSqrt tan = pycore.ElementTan tanh = pycore.ElementTanh pyviennacl-1.0.2+dfsg.orig/pyviennacl/util.py0000644000000000000000000000203512307335633017742 0ustar rootrootfrom . import _viennacl import logging default_log_handler = logging.StreamHandler() default_log_handler.setFormatter(logging.Formatter( "%(levelname)s %(asctime)s %(name)s %(lineno)d %(funcName)s\n %(message)s" )) logging.getLogger('pyviennacl').addHandler(default_log_handler) def backend_finish(): """ Block until any computation active on the compute backend is finished. """ return _viennacl.backend_finish() def from_ndarray(obj): """ Convert a NumPy ``ndarray`` into a PyViennaCL object of appropriate dimensionality. Parameters ---------- obj : array-like Returns ------- new : {Vector, Matrix} ``Vector`` if ``obj`` has 1 dimension; ``Matrix`` if 2. Raises ------ AttributeError If ``obj`` has less than 1 or more than 2 dimensions. """ if obj.ndim == 1: new = Vector(obj) elif obj.ndim == 2: new = Matrix(obj) else: raise AttributeError("Cannot cope with %d dimensions!" % self.operands[0].ndim) return new pyviennacl-1.0.2+dfsg.orig/pyviennacl/version.py0000644000000000000000000000015212332117255020444 0ustar rootrootVERSION = (1, 0, 2) VERSION_STATUS = "" VERSION_TEXT = ".".join(str(x) for x in VERSION) + VERSION_STATUS pyviennacl-1.0.2+dfsg.orig/pyviennacl/linalg.py0000644000000000000000000003404712317236474020247 0ustar rootrootfrom pyviennacl import _viennacl as _v from pyviennacl.pycore import (Matrix, SparseMatrixBase, ScalarBase, Vector, Node, MagicMethods, Mul, vcl_statement_node_numeric_type_strings) from numpy import (ndarray, array, dtype, result_type as np_result_type) import logging log = logging.getLogger(__name__) class no_precond: vcl_precond = _v.no_precond() class precond_tag: pass class lower_tag: """ Instruct the solver to solve for a lower triangular system matrix """ vcl_tag = _v.lower_tag() def vcl_solve_call(self, *args): return _v.direct_solve(*args) class unit_lower_tag: """ Instruct the solver to solve for a unit lower triangular system matrix """ vcl_tag = _v.unit_lower_tag() def vcl_solve_call(self, *args): return _v.direct_solve(*args) class upper_tag: """ Instruct the solver to solve for an upper triangular system matrix """ vcl_tag = _v.upper_tag() def vcl_solve_call(self, *args): return _v.direct_solve(*args) class unit_upper_tag: """ Instruct the solver to solve for a unit upper triangular system matrix """ vcl_tag = _v.unit_upper_tag() def vcl_solve_call(self, *args): return _v.direct_solve(*args) class cg_tag(precond_tag): """ Instruct the solver to solve using the conjugate gradient solver. Assumes that the system matrix is symmetric positive definite. Used for supplying solver parameters. """ def vcl_solve_call(self, *args): return _v.iterative_solve(*args) def __init__(self, tolerance = 1e-8, max_iterations = 300): """ Construct a cg_tag. Parameters ---------- tolerance : float, optional Relative tolerance for the residual (solver quits if ||r|| < tolerance * ||r_initial|| obtains) max_iterations : int, optional The maximum number of iterations """ self.vcl_tag = _v.cg_tag(tolerance, max_iterations) @property def tolerance(self): """ The relative tolerance """ return self.vcl_tag.tolerance @property def max_iterations(self): """ The maximum number of iterations """ return self.vcl_tag.max_iterations @property def iters(self): """ The number of solver iterations """ return self.vcl_tag.iters @property def error(self): """ The estimated relative error at the end of the solver run """ return self.vcl_tag.error class bicgstab_tag(precond_tag): """ Instruct the solver to solve using the stabilised bi-conjugate gradient (BiCGStab) solver. Assumes that the system matrix is non-symmetric. Used for supplying solver parameters. """ def vcl_solve_call(self, *args): return _v.iterative_solve(*args) def __init__(self, tolerance = 1e-8, max_iterations = 400, max_iterations_before_restart = 200): """ Construct a bicgstab_tag. Parameters ---------- tolerance : float, optional Relative tolerance for the residual (solver quits if ||r|| < tolerance * ||r_initial|| obtains) max_iterations : int, optional Maximum number of iterations max_iterations_before restart : int, optional Maximum number of iterations before BiCGStab is reinitialised, to avoid accumulation of round-off errors. """ self.vcl_tag = _v.bicgstab_tag(tolerance, max_iterations, max_iterations_before_restart) @property def tolerance(self): """ The relative tolerance """ return self.vcl_tag.tolerance @property def max_iterations(self): """ The maximum number of iterations """ return self.vcl_tag.max_iterations @property def max_iterations(self): """ The maximum number of iterations before a restart """ return self.vcl_tag.max_iterations_before_restart @property def iters(self): """ The number of solver iterations """ return self.vcl_tag.iters @property def error(self): """ The estimated relative error at the end of the solver run """ return self.vcl_tag.error class gmres_tag(precond_tag): """ Instruct the solver to solve using the GMRES solver. Used for supplying solver parameters. """ def vcl_solve_call(self, *args): return _v.iterative_solve(*args) def __init__(self,tolerance = 1e-8, max_iterations = 300, krylov_dim = 20): """ Construct a gmres_tag Parameters ---------- tolerance : float, optional Relative tolerance for the residual (solver quits if ||r|| < tolerance * ||r_initial|| obtains) max_iterations : int, optional Maximum number of iterations, including restarts krylov_dim : int, optional The maximum dimension of the Krylov space before restart (number of restarts can be computed as max_iterations / krylov_dim) """ self.vcl_tag = _v.gmres_tag(tolerance, max_iterations, krylov_dim) @property def tolerance(self): """ The relative tolerance """ return self.vcl_tag.tolerance @property def max_iterations(self): """ The maximum number of iterations """ return self.vcl_tag.max_iterations @property def krylov_dim(self): """ The maximum dimension of the Krylov space before restart """ return self.vcl_tag.krylov_dim @property def max_restarts(self): """ The maximum number of GMRES restarts """ return self.vcl_tag.max_restarts @property def iters(self): """ The number of solver iterations """ return self.vcl_tag.iters @property def error(self): """ The estimated relative error at the end of the solver run """ return self.vcl_tag.error class power_iter_tag: """ Instruct the eigenvalue computation to use the power iteration algorithm. Used for supplying eigenvalue computation parameters. """ def __init__(self, factor = 1e-8, max_iterations = 50000): """ Construct a power_iter_tag. Parameters ---------- factor : float, optional Halt when the eigenvalue does not change more than this value. max_iterations : int, optional Maximum number of iterations to compute. """ self.vcl_tag = _v.power_iter_tag(factor, max_iterations) @property def factor(self): """ The termination factor. If the eigenvalue does not change more than this value, the algorithm stops. """ return self.vcl_tag.factor @property def max_iterations(self): """ The maximum number of iterations """ return self.vcl_tag.max_iterations class lanczos_tag: """ Instruct the eigenvalue computation to use the Lanczos algorithm. Used for supplying eigenvalue computation parameters. """ def __init__(self, factor = 0.75, num_eig = 10, method = 0, krylov = 100): """ Construct a lanczos_tag. Parameters ---------- factor : float Exponent of epsilon (reorthogonalisation batch tolerance) num_eig : int Number of eigenvalues to return method : {0, 1, 2} 0 for partial reorthogonalisation 1 for full reorthogonalisation 2 for Lanczos without reorthogonalisation krylov : int Maximum Krylov-space size """ self.vcl_tag = _v.lanczos_tag(factor, num_eig, method, krylov) @property def factor(self): """ The tolerance factor for reorthogonalisation batches, expressed as the exponent of epsilon. """ return self.vcl_tag.factor @property def num_eigenvalues(self): """ The number of eigenvalues to return. """ return self.vcl_tag.num_eigenvalues @property def krylov_size(self): """ The size of the Kylov space. """ return self.vcl_tag.krylov_size @property def method(self): """ The reorthogonalisation method choice. """ return self.vcl_tag.method def plane_rotation(vec1, vec2, alpha, beta): """ Computes (vec1, vec2) <- (alpha*vec1+beta*vec2, -beta*vec1+alpha*vec2) Parameters ---------- vec1 : Vector vec2 : Vector alpha : any Python, NumPy or PyViennaCL scalar (real or integer) beta : any Python, NumPy or PyViennaCL scalar (real or integer) Returns ------- None Notes ----- The dtypes of the parameters must match. Operates in-place on vec1 and vec2. """ # Do an assortment of type and dtype checks... if isinstance(vec1, Node): vec1 = vec1.result if isinstance(vec2, Node): vec2 = vec2.result if isinstance(alpha, Node): alpha = alpha.result if isinstance(beta, Node): beta = beta.result if isinstance(vec1, Vector): x = vec1.vcl_leaf if isinstance(vec2, Vector): if vec1.dtype != vec2.dtype: raise TypeError("Vector dtypes must be the same") y = vec2.vcl_leaf else: y = vec2 else: x = vec1 if isinstance(vec2, Vector): y = vec2.vcl_leaf else: y = vec2 if isinstance(alpha, ScalarBase): if isinstance(vec1, Vector): if alpha.dtype != vec1.dtype: raise TypeError("Vector and scalar dtypes must be the same") a = alpha.value else: a = alpha if isinstance(beta, ScalarBase): if isinstance(vec1, Vector): if beta.dtype != vec1.dtype: raise TypeError("Vector and scalar dtypes must be the same") b = beta.value else: b = beta return _v.plane_rotation(x, y, a, b) def norm(x, ord=None): """ Returns the vector norm of ``x``, if that is defined. The norm returned depends on the ``ord`` parameter, as in SciPy. Parameters ---------- ord : {1, 2, inf} Order of the norm. inf means NumPy's ``inf`` object. """ return x.norm(ord) def prod(A, B): """ Returns ``Mul(A, B)`` where that is defined (see the help for ``Mul``), otherwise returns ``(A * B)``. """ if not isinstance(A, MagicMethods): return Mul(A, B) return (A * B) def solve(A, B, tag, precond = None): """ Solve the linear system expressed by ``A x = B`` for ``x``. Parameters ---------- A : (M, M) dense or sparse Matrix A square matrix B : {Vector, Matrix} Right-hand side in ``A x = B`` tag : solver tag instance Describes the system matrix and solver algorithm. Must be one of: * upper_tag * unit_upper_tag * lower_tag * unit_lower_tag * cg_tag * bicgstab_tag * gmres_tag See the help for each tag class for more information. Returns ------- x : {Vector, Matrix} Shape and class of ``x`` matches shape and class of ``B``. Raises ------ TypeError If ``A`` is not a ``Matrix`` or ``SparseMatrixBase`` instance, or ``B`` is neither a ``Matrix`` nor a ``Vector`` instance, or if ``tag`` is unsupported. """ if not (isinstance(A, Matrix) or isinstance(A, SparseMatrixBase)): raise TypeError("A must be dense or sparse matrix type") if isinstance(B, Matrix): result_type = Matrix elif isinstance(B, Vector): result_type = Vector if not isinstance(B.vcl_leaf, getattr(_v, "vector_" + vcl_statement_node_numeric_type_strings[ B.statement_node_numeric_type])): B = Vector(B) else: raise TypeError("B must be Matrix or Vector type") try: if isinstance(tag, precond_tag) and not (precond is None): return result_type(tag.vcl_solve_call(A.vcl_leaf, B.vcl_leaf, tag.vcl_tag, precond.vcl_precond), dtype = B.dtype, layout = B.layout) else: return result_type(tag.vcl_solve_call(A.vcl_leaf, B.vcl_leaf, tag.vcl_tag), dtype = B.dtype, layout = B.layout) except AttributeError: raise TypeError("tag must be a supported solver tag!") Matrix.solve = solve # for convenience.. SparseMatrixBase.solve = solve # def eig(A, tag): """ Solve an eigenvalue problem for matrix ``A``, with results depending on ``tag``. Parameters ---------- A : Matrix tag : eigenvalue computation tag instance Must be one of * power_iter_tag * lanczos_tag See the help for each tag class for more information. Returns ------- x : {scalar, array-like} Return type depends on ``tag`` * if power_iter_tag, then a scalar of type ``dtype(A).type`` * if lanczos_tag, then an ``ndarray`` vector with same dtype as ``A`` Raises ------ TypeError If ``A`` is not a ``Matrix`` instance, or if ``tag`` is not understood """ #if not isinstance(A, Matrix): # raise TypeError("A must be a Matrix type") if isinstance(tag, power_iter_tag): return _v.eig(A.vcl_leaf, tag.vcl_tag) elif isinstance(tag, lanczos_tag): return _v.eig(A.vcl_leaf, tag.vcl_tag).as_ndarray() else: raise TypeError("tag must be a supported eigenvalue tag!") Matrix.eig = eig SparseMatrixBase.eig = eig def ilu(A, config): return NotImplemented ## And QR decomposition..? pyviennacl-1.0.2+dfsg.orig/pyviennacl/pycore.py0000644000000000000000000031160112324471245020267 0ustar rootroot""" This submodule contains PyViennaCL's core functionality, including types for representing and manipulating scalars, vectors and matrices on the host and compute device, with a variety of numerical data types (equivalent to the NumPy concept of ``dtype``). Also provided are routines for type conversion, arithmetic and linear algebra, to BLAS level 3. Vector and matrix types can be sensibly converted to and from NumPy arrays, and support for SciPy sparse matrix types is forth- coming. Background information ---------------------- Because in heterogeneous computing systems copying data across the bus from host memory to device memory (or vice versa) commonly incurs a proportionally substantial wait, PyViennaCL adopts a policy of delayed execution. Arithmetical expressions are represented as a binary tree, and are only dispatched to be computed when the result of the computation is necessary. Thus, the result of adding two Matrix objects is not another Matrix object, but an Add object, which is converted to a Matrix when the result is accessed. Consequently, this submodule provides a number of classes for elementary arithmetical operations, such as Add, for representation in an expression tree. Each of these expression tree classes is a subclass of Node type, with Node providing basic functionality for the construction of the expression tree. In the language of ViennaCL, 'data' classes such as Scalar, Vector and Matrix constitute leaves on the expression tree, and as such, each of these data classes inherits from the Leaf type, which provides general functionality for leaf construction. Node and Leaf instances are flattened into a Statement object when the expression is executed. The Statement class recursively constructs the C++ object equivalent to the expression tree as represented in Python, and this is then dispatched to the compute device. The result is cached so that multiple identical computations are not made. On object construction and access ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ For the same reasons of bus and compute latency, PyViennaCL does not support the elementwise construction of Matrix or Vector objects, or the accessing of individual scalar elements from any such type; the waits incurred make such access painfully slow. Instead, you must construct dense matrices and vectors using preconstructed types: NumPy ``array``s can be supplied to construct both matrices and vectors -- as long as the arrays are of the correct dimensionality -- and Python lists can be supplied to construct vectors, as long as the ``dtype`` of the list is comprehensible. Construction from lists, but not arrays, is supported if the element type is a PyViennaCL scalar type. In both the list case and the array case, you can use Python or NumPy numeric data types: NumPy ``dtype``s are recommended, since these are more explicit. Elementwise accesses to array-like PyViennaCL types incur the computation of any expression, the transfer of the result to the host, the representation of that result as a NumPy ``ndarray`` (which may incur a large memory cost), and then the accessing of the element from that array. The exception to this rule is the set of PyViennaCL sparse matrix types, which do support elementwise construction and access, because they are backed by a transparent host-memory cache which is only flushed to and from the device when necessary, in the manner of the delayed execution described above. To force the execution of an expression or the flushing of a matrix, access the ``result`` attribute. To retrieve a NumPy ``array`` containing the data of the PyViennaCL Leaf or Node, use the ``as_ndarray()`` method. If you are not particularly concerned about the type of object you retrieve, access the ``value`` attribute: for PyViennaCL scalars, this provides a NumPy / Python scalar object; for vectors and matrices, it provides an appropriate NumPy ``array``. Ranges and slices of matrices and vectors are well supported, including the assignment of one matrix to a sub-matrix of another, as long as the matrix dimensions are commensurable. For instance:: >>> a[5:10, 5:10] = b # doctest: +SKIP Submodule contents ------------------ Leaf types ^^^^^^^^^^ ================ ================================== HostScalar Represents a scalar in host memory Scalar Represents a scalar in compute device memory Vector Represents a vector in compute device memory CompressedMatrix Represents a sparse matrix with compressed-row storage in compute device memory CoordinateMatrix Represents a sparse matrix with a coordinate storage format in compute device memory ELLMatrix Represents a sparse matrix with an ELL storage format in compute device memory HybridMatrix Represents a sparse matrix with a hybrid storage format, combining ELL and compressed-row storage, in compute device memory Matrix Represents a dense matrix, with either row-major (default) or column-major storage. ================ ================================== Supported numeric data types: int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64. Many operations are only currently supported using a floating poit numeric data type, but wider numeric support is forthcoming in later versions. Node types ^^^^^^^^^^ ============ ============================================================= Norm_1 Order-1 norm Norm_2 Order-2 norm Norm_Inf Infinity norm ElementAbs Elementwise abs ElementAcos Elementwise acos ElementAsin Elementwise asin ElementAtan Elementwise atan ElementCeil Elementwise ceil ElementCos Elementwise cos ElementCosh Elementwise cosh ElementExp Elementwise exp ElementFabs Elementwise fabs ElementFloor Elementwise floor ElementLog Elementwise log ElementLog10 Elementwise log10 ElementSin Elementwise sin ElementSinh Elementwise sinh ElementSqrt Elementwise sqrt ElementTan Elementwise tan ElementTanh Elementwise tanh Trans Matrix transpose Assign Assign (copy) the values of one object to another of the same type. You can Assign across different matrix layouts. InplaceAdd In-place addition InplaceSub In-place subtraction Add Addition (allocates returns a new object) Sub Subtraction (allocates returns a new object) Mul Multiplication: * Scalar by scalar -> scalar; * scalar by vector -> scaled vector; * scalar by matrix -> scaled matrix; * vector by vector -> undefined; * vector by matrix -> undefined; * matrix by vector -> matrix-vector product; * matrix by matrix -> matrix-matrix product. The concern in defining these semantics has been to preserve the dimensionality of the operands in the result. The Mul class does not map directly onto the * operator for every class. Div Scalar division ElementProd Elementwise scalar multiplication ElementDiv Elementwise scalar division Dot Inner (dot) product of two vectors ============ ============================================================= Most of these expression classes are implicitly constructed by arithmetical convenience functions, including the standard Python arithmetic operators. For instance, for two commensurate objects ``a`` and ``b``:: >>> ((a + b) == p.Add(a, b)).all() # doctest: +SKIP True For more information about the semantics of the arithmetic operators, such as *, +, -, **, / and //, see the docstrings for the individual classes involved; for the default semantics, see the docstrings for the ``MagicMethods`` class. The equality operator falls back to NumPy's ``equal`` function for all classes that are not scalars, or that do not produce scalars as a result; in the scalar case, simple numerical equality is used. """ from __future__ import division import logging, math from pyviennacl import (_viennacl as _v, util) from numpy import (ndarray, array, zeros, inf, nan, dtype, equal as np_equal, array_equal, result_type as np_result_type, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64) try: from scipy import sparse WITH_SCIPY = True except: WITH_SCIPY = False log = logging.getLogger(__name__) # This dict maps ViennaCL container subtypes onto the strings used for them vcl_statement_node_subtype_strings = { _v.statement_node_subtype.INVALID_SUBTYPE: 'node', _v.statement_node_subtype.HOST_SCALAR_TYPE: 'host', _v.statement_node_subtype.DEVICE_SCALAR_TYPE: 'scalar', _v.statement_node_subtype.DENSE_VECTOR_TYPE: 'vector', _v.statement_node_subtype.IMPLICIT_VECTOR_TYPE: 'implicit_vector', _v.statement_node_subtype.DENSE_ROW_MATRIX_TYPE: 'matrix_row', _v.statement_node_subtype.DENSE_COL_MATRIX_TYPE: 'matrix_col', _v.statement_node_subtype.IMPLICIT_MATRIX_TYPE: 'implicit_matrix', _v.statement_node_subtype.COMPRESSED_MATRIX_TYPE: 'compressed_matrix', _v.statement_node_subtype.COORDINATE_MATRIX_TYPE: 'coordinate_matrix', _v.statement_node_subtype.ELL_MATRIX_TYPE: 'ell_matrix', _v.statement_node_subtype.HYB_MATRIX_TYPE: 'hyb_matrix' } # This dict maps ViennaCL numeric types onto the C++ strings used for them vcl_statement_node_numeric_type_strings = { _v.statement_node_numeric_type.INVALID_NUMERIC_TYPE: 'index', _v.statement_node_numeric_type.CHAR_TYPE: 'char', _v.statement_node_numeric_type.UCHAR_TYPE: 'uchar', _v.statement_node_numeric_type.SHORT_TYPE: 'short', _v.statement_node_numeric_type.USHORT_TYPE: 'ushort', _v.statement_node_numeric_type.INT_TYPE: 'int', _v.statement_node_numeric_type.UINT_TYPE: 'uint', _v.statement_node_numeric_type.LONG_TYPE: 'long', _v.statement_node_numeric_type.ULONG_TYPE: 'ulong', _v.statement_node_numeric_type.HALF_TYPE: 'half', _v.statement_node_numeric_type.FLOAT_TYPE: 'float', _v.statement_node_numeric_type.DOUBLE_TYPE: 'double', } # This dict is used to map NumPy dtypes onto OpenCL/ViennaCL numeric types HostScalarTypes = { 'int8': _v.statement_node_numeric_type.CHAR_TYPE, 'int16': _v.statement_node_numeric_type.SHORT_TYPE, 'int32': _v.statement_node_numeric_type.INT_TYPE, 'int64': _v.statement_node_numeric_type.LONG_TYPE, 'uint8': _v.statement_node_numeric_type.UCHAR_TYPE, 'uint16': _v.statement_node_numeric_type.USHORT_TYPE, 'uint32': _v.statement_node_numeric_type.UINT_TYPE, 'uint64': _v.statement_node_numeric_type.ULONG_TYPE, 'float16': _v.statement_node_numeric_type.HALF_TYPE, 'float32': _v.statement_node_numeric_type.FLOAT_TYPE, 'float64': _v.statement_node_numeric_type.DOUBLE_TYPE, 'float': _v.statement_node_numeric_type.DOUBLE_TYPE } # Constants for choosing matrix storage layout ROW_MAJOR = 1 COL_MAJOR = 2 vcl_layout_strings = { ROW_MAJOR: 'row', COL_MAJOR: 'col' } class NoResult(object): """ This no-op class is used to represent when some ViennaCL operation produces no explicit result, aside from any effects it may have on the operands. For instance, in-place operations can return NoResult, as can Assign. """ pass class MagicMethods(object): """ A class to provide convenience methods for arithmetic and BLAS access. Classes derived from this will inherit lots of useful features applicable to PyViennaCL. For more information, see the individual methods below. """ flushed = False def result_container_type(self): """ This function should be overridden, with the following semantics. Parameters ---------- None Returns ------- x : type The type that the operation or object represented by an instance of this class should return as a result on execution. Raises ------ NotImplementedError If you do not override this function in a class derived from MagicMethods. """ raise NotImplementedError("Why is this happening to you?") def copy(self): """ Returns a new instance of this class representing a new copy of this instance's data. """ return type(self)(self) def norm(self, ord=None): """ Returns a norm of this instance, if that is defined. The norm returned depends on the ``ord`` parameter, as in SciPy. * If this instance is a ``Matrix``, then ``ord`` must be ``None``, and the only norm supported is the Frobenius norm. Parameters ---------- ord : {1, 2, inf, 'fro', None} Order of the norm. inf means NumPy's ``inf`` object. 'fro' means the string 'fro', and denotes the Frobenius norm. If None and self is a Matrix instance, then assumes 'fro'. """ if ord == 1: #return Norm_1(self) TODO NOT WORKING WITH SCHEDULER return Scalar(_v.norm_1(self.vcl_leaf), dtype = self.dtype) elif ord == 2: #return Norm_2(self) return Scalar(_v.norm_2(self.vcl_leaf), dtype = self.dtype) elif ord == inf: #return Norm_Inf(self) return Scalar(_v.norm_inf(self.vcl_leaf), dtype = self.dtype) else: return Scalar(_v.norm_frobenius(self.vcl_leaf), dtype = self.dtype) #@property #def norm_1(self): # return Norm_1(self) #.result #@property #def norm_2(self): # return Norm_2(self) #.result #@property #def norm_inf(self): # return Norm_Inf(self) #.result def prod(self, rhs): """ Returns ``(self * rhs)``. """ return (self * rhs) def element_prod(self, rhs): """ Returns the elementwise product of ``self`` and ``rhs``, for some ``rhs`` (right-hand side). """ return ElementProd(self, rhs) element_mul = element_prod def element_div(self, rhs): """ Returns the elementwise division of ``self`` and ``rhs``, for some ``rhs`` (right-hand side). """ return ElementDiv(self, rhs) def __pow__(self, rhs): """ x.__pow__(y) <==> x**y Notes ----- For array-like types, this is computed elementwise. But ViennaCL does not currently support elementwise exponentiation in the scheduler, so this incurs the computation of the expression represented by ``y`` at this point. Nonetheless, the result is the appropriate PyViennaCL type. """ if isinstance(rhs, MagicMethods): if not self.shape == rhs.shape: raise TypeError("Operands must have the same shape!") return self.result_container_type(_v.element_pow(self.vcl_leaf, rhs.vcl_leaf), dtype = self.dtype, layout = self.layout) else: return self.result_container_type(self.value ** rhs, dtype = self.dtype, layout = self.layout) def __rpow__(self, rhs): """ x.__rpow__(y) <==> y**x """ if isinstance(rhs, MagicMethods): if not self.shape == rhs.shape: raise TypeError("Operands must have the same shape!") return self.result_container_type(_v.element_pow(rhs.vcl_leaf, self.vcl_leaf), dtype = self.dtype) else: return self.result_container_type(rhs ** self.value, dtype = self.dtype) def __eq__(self, rhs): """ The equality operator. Parameters ---------- rhs : {scalar, Vector, Matrix, ndarray, etc} Comparator Returns ------- retval : {bool, ndarray} If the r.h.s. is elementwise comparable with a Vector, Matrix or ndarray, then an array of boolean values is returned; see NumPy's ``equal`` function. If the r.h.s. is a scalar, then a boolean value is returned. Otherwise, the behaviour is undefined, but the Python ``==`` operator is used to compare the ``result`` attribute of ``self`` to the r.h.s., in an attempt at meaningfulness. """ if issubclass(self.result_container_type, ScalarBase): if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): return self.value == rhs.value else: return self.value == rhs if self.flushed: if isinstance(rhs, MagicMethods): return np_equal(self.as_ndarray(), rhs.as_ndarray()) elif isinstance(rhs, ndarray): return np_equal(self.as_ndarray(), rhs) else: return self.value == rhs else: return self.result == rhs def __ne__(self, rhs): return not (self == rhs) def __hash__(self): ## TODO implement better hash function return object.__hash__(self) #return id(self) def __contains__(self, item): return (item in self.as_ndarray()) def __str__(self): return self.value.__str__() def __repr__(self): return self.value.__repr__() def __add__(self, rhs): """ x.__add__(y) <==> x+y """ if issubclass(self.result_container_type, ScalarBase): if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): return self.result_container_type(self.value + rhs.value, dtype = self.dtype) else: return self.value + rhs op = Add(self, rhs) return op def __sub__(self, rhs): """ x.__sub__(y) <==> x-y """ if issubclass(self.result_container_type, ScalarBase): if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): return self.result_container_type(self.value - rhs.value, dtype = self.dtype) else: return self.value - rhs op = Sub(self, rhs) return op def __mul__(self, rhs): """ x.__mul__(y) <==> x*y Returns ------- z : {Mul(x, y), (x.value * rhs)} Returns a Mul instance if defined. """ if issubclass(self.result_container_type, ScalarBase): if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): return self.result_container_type(self.value * rhs.value, dtype = self.dtype) else: return self.value * rhs op = Mul(self, rhs) return op def __floordiv__(self, rhs): """ x.__floordiv__(y) <==> x//y """ if issubclass(self.result_container_type, ScalarBase): if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): return self.result_container_type(self.value // rhs.value, dtype = self.dtype) else: return self.value // rhs op = math.floor(Div(self, rhs)) return op def __truediv__(self, rhs): """ x.__truediv__(y) <==> x/y Notes ----- PyViennaCL automatically adopts Python 3.0 division semantics, so the ``/`` division operator is never floor (integer) division, and always true floating point division. """ if issubclass(self.result_container_type, ScalarBase): if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): return self.result_container_type(self.value / rhs.value, dtype = self.dtype) else: return self.value / rhs op = Div(self, rhs) return op __div__ = __truediv__ def __iadd__(self, rhs): """ x.__iadd__(y) <==> x+=y """ if issubclass(self.result_container_type, ScalarBase): if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): self.value += rhs.value else: self.value += rhs return self if isinstance(self, Node): return Add(self, rhs) else: op = InplaceAdd(self, rhs) op.execute() return self def __isub__(self, rhs): """ x.__isub__(y) <==> x-=y """ if issubclass(self.result_container_type, ScalarBase): if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): self.value -= rhs.value else: self.value -= rhs return self if isinstance(self, Node): return Sub(self, rhs) else: op = InplaceSub(self, rhs) op.execute() return self def __imul__(self, rhs): """ x.__imul__(y) <==> x*=y Notes ----- See the definition of the ``*`` operator for more information about the semantics of ``*=``. """ if issubclass(self.result_container_type, ScalarBase): if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): self.value *= rhs.value else: self.value *= rhs return self if isinstance(self, Node): return Mul(self, rhs) else: op = Mul(self, rhs) return op.result def __ifloordiv__(self, rhs): """ x.__ifloordiv__(y) <==> x//=y """ if issubclass(self.result_container_type, ScalarBase): if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): self.value //= rhs.value else: self.value //= rhs return self if isinstance(self, Node): return math.floor(Div(self, rhs)) else: op = math.floor(Div(self, rhs)) return op.result def __itruediv__(self, rhs): """ x.__itruediv__(y) <==> x/=y Notes ----- PyViennaCL automatically adopts Python 3.0 division semantics, so the ``/`` division operator is never floor (integer) division, and always true floating point division. """ if issubclass(self.result_container_type, ScalarBase): if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): self.value /= rhs.value else: self.value /= rhs return self if isinstance(self, Node): return Div(self, rhs) else: op = Div(self, rhs) return op.result def __radd__(self, rhs): """ x.__radd__(y) <==> y+x Notes ----- Addition is commutative. """ return self + rhs def __rsub__(self, rhs): """ x.__rsub__(y) <==> y-x """ if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): return rhs.result_container_type(rhs.value - self.value, dtype = rhs.dtype) return rhs - self return rhs - self.value def __rmul__(self, rhs): """ x.__rmul__(y) <==> y*x Notes ----- Multiplication is commutative. """ return self * rhs def __rfloordiv__(self, rhs): """ x.__rfloordiv__(y) <==> y//x """ if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): return rhs.result_container_type(rhs.value // self.value, dtype = rhs.dtype) return rhs // self return rhs // self.value def __rtruediv__(self, rhs): """ x.__rtruediv__(y) <==> y/x Notes ----- PyViennaCL automatically adopts Python 3.0 division semantics, so the ``/`` division operator is never floor (integer) division, and always true floating point division. """ if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, ScalarBase): return rhs.result_container_type(rhs.value / self.value, dtype = rhs.dtype) return rhs / self return rhs / self.value __rdiv__ = __rtruediv__ def __neg__(self): """ x.__neg__() <==> -x """ if issubclass(self.result_container_type, ScalarBase): return self.result_container_type(-self.value, dtype = self.dtype) return Mul(self.dtype.type(-1), self) def __abs__(self): """ x.__abs__() <==> abs(x) Notes ----- OpenCL does not provide for ``abs`` on floating point types, so if your instance has a floating point data type, ``abs(x)`` is equivalent to ``fabs(x)``. On array-like types, this is computed elementwise. """ if issubclass(self.result_container_type, ScalarBase): return self.result_container_type(abs(self.value), dtype = self.dtype) elif issubclass(np_result_type(self).type, float): # No floating abs in OpenCL return ElementFabs(self) else: return ElementAbs(self) def __floor__(self): """ x.__floor__() <==> math.floor(self) Notes ----- On array-like types, this is computed elementwise. """ if issubclass(self.result_container_type, ScalarBase): return self.result_container_type(math.floor(self.value), dtype = self.dtype) return ElementFloor(self) def __ceil__(self): """ x.__ceil__() <==> math.ceil(self) Notes ----- On array-like types, this is computed elementwise. """ if issubclass(self.result_container_type, ScalarBase): return self.result_container_type(math.ceil(self.value), dtype = self.dtype) return ElementCeil(self) class View(object): """ This class represents a C++ ViennaCL range or slice, as a 'view' on an object. A View instance is object-independent; i.e., it represents an abstract view. """ start = None stop = None step = None def __init__(self, key, axis_size): """ Construct a View object. Parameters ---------- key : slice axis_size : int The number of elements along the axis of which the instance of this class is a view. """ start, stop, step = key.indices(axis_size) if step == 1: # then range -- or slice! self.vcl_view = _v.slice(start, 1, (stop-start)) else: # then slice self.vcl_view = _v.slice(start, step, int(math.ceil((stop-start)/step))) self.slice = key self.start = start self.stop = stop self.step = step class Leaf(MagicMethods): """ This is the base class for all ``leaves`` in the ViennaCL expression tree system. A leaf is any type that can store data for use in an operation, such as a scalar, a vector, or a matrix. """ shape = None # No shape yet -- not even 0 dimensions flushed = True # Are host and device data synchronised? complexity = 0 # A leaf does not contribute computationally to a tree def __init__(self, *args, **kwargs): """ Do initialisation tasks common to all Leaf subclasses, then pass control onto the overridden _init_leaf function. Tasks include expression computation and configuration of data types and views. """ for arg in args: if isinstance(arg, list): for item in arg: if isinstance(item, MagicMethods): arg[arg.index(item)] = item.value if 'dtype' in kwargs.keys(): dt = dtype(kwargs['dtype']) self.dtype = dt else: self.dtype = None if 'view_of' in kwargs.keys(): self.view_of = kwargs['view_of'] if 'view' in kwargs.keys(): self.view = kwargs['view'] self._init_leaf(args, kwargs) def __setitem__(self, key, value): if isinstance(value, Node): value = value.result ## TODO: This involves both a get and a set, if it works, so not very efficient.. item = self[key] ## get if type(item) != type(value): if isinstance(item, ScalarBase): if isinstance(value, ScalarBase): value = value.value if np_result_type(item) != np_result_type(value): try: value = np_result_type(item).type(value) except: log.exception("Failed to convert value dtype (%s) to item dtype (%s)" % (np_result_type(item), np_result_type(value))) try: try: # Assume matrix type return self.vcl_leaf.set_entry(key[0], key[1], value) ## set except: # Otherwise, assume vector return self.vcl_leaf.set_entry(key, value) ## set except: log.exception("Failed to set vcl entry") raise TypeError("Cannot assign %s to %s" % (type(value), type(item))) if item.dtype != value.dtype: raise TypeError("Cannot assign across different dtypes! (%s and %s)" % (item.dtype, value.dtype)) if item.shape != value.shape: raise TypeError("Cannot assign across different shapes! (%s and %s)" % (item.shape, value.shape)) Assign(item, value).execute() ## set def _init_leaf(self, args, kwargs): """ By default, leaf subclasses inherit a no-op further init function. If you're deriving from Leaf, then you probably want to override this, with the following semantics: Parameters ---------- args : list kwargs : dict Returns ------- None Raises ------ NotImplementedError Unless overridden by a derived class. Notes ----- The derived class should take ``args`` and ``kwargs`` and construct the leaf appropriately. """ raise NotImplementedError("Help") def flush(self): """ Override this function to implement caching functionality. """ raise NotImplementedError("Should you be trying to flush this type?") @property def result_container_type(self): """ The result_container_type for a leaf is always its own type. """ return type(self) @property def result(self): """ The result of an expression or subexpression consisting of a leaf is just the leaf itself. """ return self def express(self, statement=""): """ Construct a human-readable version of a ViennaCL expression tree statement from this leaf. """ statement += type(self).__name__ return statement def as_ndarray(self): """ Return a NumPy ``ndarray`` containing the data within the underlying ViennaCL type. """ return array(self.vcl_leaf.as_ndarray(), dtype=self.dtype) @property def value(self): """ Return a NumPy ``ndarray`` containing the data within the underlying ViennaCL type. """ return self.as_ndarray() class ScalarBase(Leaf): """ This is the base class for all scalar types, regardless of their memory and backend context. It represents the dtype and the value of the scalar independently of one another. Because scalars are leaves in the ViennaCL expression graph, this class derives from the Leaf base class. """ statement_node_type_family = _v.statement_node_type_family.SCALAR_TYPE_FAMILY ndim = 0 # Scalars are point-like, and thus 0-dimensional def _init_leaf(self, args, kwargs): """ Do Scalar-specific initialisation tasks. 1. Set the scalar value to the value given, or 0. 2. If no dtype yet set, use the NumPy type promotion rules to deduce a dtype. """ if 'value' in kwargs.keys(): self._value = kwargs['value'] elif len(args) > 0: if isinstance(args[0], ScalarBase): self._value = args[0].value else: self._value = args[0] else: self._value = 0 if self.dtype is None: self.dtype = np_result_type(self._value) try: self.statement_node_numeric_type = HostScalarTypes[self.dtype.name] except KeyError: raise TypeError("dtype %s not supported" % self.dtype.name) except: raise self._init_scalar() def _init_scalar(self): """ By default, scalar subclasses inherit a no-op further init function. If you're deriving from ScalarBase, then you probably want to override this, with the following semantics: Parameters ---------- None Returns ------- None Raises ------ NotImplementedError Unless overridden by a derived class. Notes ----- The derived class should take the class and construct the scalar value representation appropriately. """ raise NotImplementedError("Help!") @property def shape(self): """ Scalars are 0-dimensional and thus have no shape. """ return () @property def value(self): """ The stored value of the scalar. """ return self._value @value.setter def value(self, value): self._value = self.dtype.type(value) self._init_scalar() def as_ndarray(self): """ Return a point-like ndarray containing only the value of this Scalar, with the dtype set accordingly. """ return array(self.value, dtype=self.dtype) def __pow__(self, rhs): """ x.__pow__(y) <==> x**y """ if isinstance(rhs, ScalarBase): return self.result_container_type(self.value ** rhs.value, dtype = self.dtype) else: return self.result_container_type(self.value ** rhs, dtype = self.dtype) def __rpow__(self, rhs): """ x.__rpow__(y) <==> y**x Notes ----- For array-like types, this is computed elementwise. But ViennaCL does not currently support elementwise exponentiation in the scheduler, so this incurs the computation of the expression represented by ``y`` at this point. Nonetheless the result is the appropriate PyViennaCL type. """ if isinstance(rhs, ScalarBase): return self.result_container_type(rhs ** self, dtype = self.dtype) else: return self.result_container_type(rhs ** self.value, dtype = self.dtype) class HostScalar(ScalarBase): """ This class is used to represent a ``host scalar``: a scalar type that is stored in main CPU RAM, and that is usually represented using a standard NumPy scalar dtype, such as int32 or float64. It derives from ScalarBase. """ statement_node_subtype = _v.statement_node_subtype.HOST_SCALAR_TYPE def _init_scalar(self): self.vcl_leaf = self._value class Scalar(ScalarBase): """ This class is used to represent a ViennaCL scalar: a scalar type that is usually stored in OpenCL global memory, but which can be converted to a HostScalar, and thence to a standard NumPy scalar dtype, such as int32 or float64. It derives from ScalarBase. """ statement_node_subtype = _v.statement_node_subtype.DEVICE_SCALAR_TYPE def _init_scalar(self): try: vcl_type = getattr(_v, "scalar_" + vcl_statement_node_numeric_type_strings[self.statement_node_numeric_type]) except (KeyError, AttributeError): raise TypeError("ViennaCL type %s not supported" % self.statement_node_numeric_type) if isinstance(self._value, vcl_type): self.vcl_leaf = self._value self._value = self._value.to_host() else: self.vcl_leaf = vcl_type(self._value) class Vector(Leaf): """ A generalised Vector class: represents ViennaCL vector objects of all supported scalar types. Can be constructed in a number of ways: * from an ndarray of the correct dtype * from a list * from an integer: produces an empty Vector of that size * from a tuple: first element an int (for size), second for scalar value Also provides convenience functions for arithmetic. """ ndim = 1 layout = None statement_node_type_family = _v.statement_node_type_family.VECTOR_TYPE_FAMILY statement_node_subtype = _v.statement_node_subtype.DENSE_VECTOR_TYPE def _init_leaf(self, args, kwargs): """ Construct the underlying ViennaCL vector object according to the given arguments and types. """ if 'shape' in kwargs.keys(): if len(kwargs['shape']) != 1: raise TypeError("Vector can only have a 1-d shape") args = list(args) args.insert(0, kwargs['shape'][0]) # TODO: Create Vector from row or column matrix.. if len(args) == 0: def get_leaf(vcl_t): return vcl_t() elif len(args) == 1: if isinstance(args[0], MagicMethods): if issubclass(args[0].result_container_type, Vector): if self.dtype is None: self.dtype = args[0].result.dtype def get_leaf(vcl_t): return vcl_t(args[0].result.vcl_leaf) else: raise TypeError("Vectors can only be constructed like this from one-dimensional objects") elif isinstance(args[0], ndarray): if args[0].ndim > 1: one_d = [x for x in args[0].shape if x > 1] if len(one_d) != 1: raise TypeError("Vector can only be constructed from a one-dimensional array!") a = args[0].flatten() else: a = args[0] self.dtype = np_result_type(args[0]) def get_leaf(vcl_t): return vcl_t(a) elif isinstance(args[0], _v.vector_base): # This doesn't do any dtype checking, so beware... def get_leaf(vcl_t): return args[0] else: # This doesn't do any dtype checking, so beware... def get_leaf(vcl_t): return vcl_t(args[0]) elif len(args) == 2: if self.dtype is None: try: self.dtype = dtype(args[1]) except TypeError: self.dtype = np_result_type(args[1]) def get_leaf(vcl_t): return vcl_t(args[0], args[1]) else: raise TypeError("Vector cannot be constructed in this way") if self.dtype is None: # ie, still None, even after checks -- so guess self.dtype = dtype(float64) self.statement_node_numeric_type = HostScalarTypes[self.dtype.name] try: vcl_type = getattr(_v, "vector_" + vcl_statement_node_numeric_type_strings[ self.statement_node_numeric_type]) except (KeyError, AttributeError): raise TypeError( "dtype %s not supported" % self.statement_node_numeric_type) self.vcl_leaf = get_leaf(vcl_type) self.size = self.vcl_leaf.size self.shape = (self.size,) self.internal_size = self.vcl_leaf.internal_size def __getitem__(self, key): if isinstance(key, slice): view = View(key, self.size) project = getattr(_v, "project_vector_" + vcl_statement_node_numeric_type_strings[ self.statement_node_numeric_type]) return Vector(project(self.vcl_leaf, view.vcl_view), dtype=self.dtype, view_of=self, view=(view,)) elif isinstance(key, tuple) or isinstance(key, list): if len(key) == 0: return self elif len(key) == 1: return self[key[0]] else: raise IndexError("Too many indices") elif isinstance(key, int) or isinstance(key, long): # TODO: key is probably an int -- be sure? return HostScalar(self.vcl_leaf.get_entry(key), dtype=self.dtype) else: raise IndexError("Can't understand index") @property def index_norm_inf(self): """ Returns the index of the L^inf norm on the vector. """ return self.vcl_leaf.index_norm_inf def outer(self, rhs): """ Returns the outer product of ``self`` and ``rhs``. Parameters ---------- rhs : Vector Returns ------- result : Matrix Raises ------ TypeError If anything but a Vector is supplied. Notes ----- ViennaCL currently does not support outer product computation in the expression tree, so this forces the computation of ``rhs``, if ``rhs`` represents a complex expression. """ if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, Vector): return Matrix(_v.outer(self.vcl_leaf, rhs.vcl_leaf), dtype=self.dtype, layout=COL_MAJOR) # I don't know why COL_MAJOR.. raise TypeError("Cannot calculate the outer-product of non-vector type: %s" % type(rhs)) def dot(self, rhs): """ Returns an expression representing the inner product of ``self`` and ``rhs``: ``Dot(self, rhs)``. """ #return Dot(self, rhs) NOT WORKING WITH SCHEDULER return Scalar(_v.inner_prod(self.vcl_leaf, rhs.vcl_leaf), dtype = self.dtype) inner = dot def as_column(self): """ Returns a representation of this instance as a column Matrix. """ tmp = self.vcl_leaf.as_ndarray() tmp.resize(self.size, 1) return Matrix(tmp, dtype=self.dtype, layout=COL_MAJOR) def as_row(self): """ Returns a representation of this instance as a row Matrix. """ tmp = self.vcl_leaf.as_ndarray() tmp.resize(1, self.size) return Matrix(tmp, dtype=self.dtype, layout=ROW_MAJOR) def as_diag(self): """ Returns a representation of this instance as a diagonal Matrix. """ tmp_v = self.as_ndarray() tmp_m = zeros((self.size, self.size), dtype=self.dtype) for i in range(self.size): tmp_m[i][i] = tmp_v[i] return Matrix(tmp_m, dtype=self.dtype) # TODO: Ought to be sparse here def __mul__(self, rhs): """ x.__mul__(rhs) <==> x*rhs Returns ------- z : {ElementProd(x, rhs), Mul(x, rhs)} Returns an ElementProd instance if rhs is a Vector, otherwise returns a Mul instance, which may or may not be well defined. """ if isinstance(rhs, MagicMethods): if issubclass(rhs.result_container_type, Vector): return ElementProd(self, rhs) return Mul(self, rhs) class SparseMatrixBase(Leaf): """ This is the base class for all sparse matrix types, regardless of their storage format. Because sparse matrices are leaves in the ViennaCL expression graph, this class derives from the Leaf base class. It is not expected that any instances of this class will be created, but instead its functionality is provided to derived sparse matrix types. The specific sparse matrix subclass representing data on the compute device is not actually constructed until it is required; data is initially and transparently cached in RAM for speed of construction and access. A sparse matrix instance can be constructed in a number of ways: * as an empty instance, with no parameters; * by passing a 2-tuple representing the shape or a 3-tuple representing both the shape and the number of nonzeros, to pre-allocate memory; * from a ``Matrix`` instance; * from another sparse matrix instance; * from an expression resulting in a ``Matrix`` or sparse matrix; * from a NumPy ``ndarray``. Support for converting PyViennaCL sparse matrix types to and from SciPy sparse matrix types is not currently available, but is planned. """ ndim = 2 flushed = False statement_node_type_family = _v.statement_node_type_family.MATRIX_TYPE_FAMILY @property def vcl_leaf_factory(self): """ Derived classes should construct and return the C++ object representing the appropriate sparse matrix on the compute device by overriding this function. """ raise NotImplementedError("This is only a base class!") def _init_leaf(self, args, kwargs): """ Do general sparse-matrix-specific construction tasks, like setting up the shape, layout, dtype and host memory cache. """ if 'shape' in kwargs.keys(): if len(kwargs['shape']) != 2: raise TypeError("Sparse matrix can only have a 2-d shape") args = list(args) args.insert(0, kwargs['shape']) if 'layout' in kwargs.keys(): if kwargs['layout'] == COL_MAJOR: raise TypeError("COL_MAJOR sparse layout not yet supported") self.layout = COL_MAJOR else: self.layout = ROW_MAJOR else: self.layout = ROW_MAJOR if len(args) == 0: # 0: empty -> empty def get_cpu_leaf(cpu_t): return cpu_t() elif len(args) == 1: if isinstance(args[0], tuple): if len(args[0]) == 2: # 1: 2-tuple -> shape def get_cpu_leaf(cpu_t): return cpu_t(args[0][0], args[0][1]) elif len(args[0]) == 3: # 1: 3-tuple -> shape+nnz def get_cpu_leaf(cpu_t): return cpu_t(args[0][0], args[0][1], args[0][2]) else: # error! raise TypeError("Sparse matrix cannot be constructed thus") elif isinstance(args[0], Matrix): # 1: Matrix instance -> copy if self.dtype is None: self.dtype = args[0].dtype self.layout = args[0].layout def get_cpu_leaf(cpu_t): return cpu_t(args[0].as_ndarray()) elif isinstance(args[0], SparseMatrixBase): # 1: SparseMatrixBase instance -> copy if self.dtype is None: self.dtype = args[0].dtype self.layout = args[0].layout def get_cpu_leaf(cpu_t): return args[0].cpu_leaf elif isinstance(args[0], Node): # 1: Node instance -> get result and copy result = args[0].result if isinstance(result, SparseMatrixBase): if self.dtype is None: self.dtype = result.dtype self.layout = result.layout def get_cpu_leaf(cpu_t): return result.cpu_leaf elif isinstance(result, Matrix): if self.dtype is None: self.dtype = result.dtype self.layout = result.layout def get_cpu_leaf(cpu_t): return cpu_t(result.as_ndarray()) else: raise TypeError( "Sparse matrix cannot be constructed thus") elif isinstance(args[0], ndarray): # 1: ndarray -> init and fill if self.dtype is None: self.dtype = np_result_type(args[0]) def get_cpu_leaf(cpu_t): return cpu_t(args[0]) else: if WITH_SCIPY: # then test for scipy.sparse matrix raise NotImplementedError("SciPy support comes later") else: # error! raise TypeError("Sparse matrix cannot be constructed thus") elif len(args) == 2: # 2: 2 ints -> shape def get_cpu_leaf(cpu_t): return cpu_t(args[0], args[1]) elif len(args) == 3: # 3: 3 ints -> shape+nnz def get_cpu_leaf(cpu_t): return cpu_t(args[0], args[1], args[2]) else: raise TypeError("Sparse matrix cannot be constructed thus") if self.dtype is None: self.dtype = dtype(float64) self.statement_node_numeric_type = HostScalarTypes[self.dtype.name] try: self.cpu_leaf_type = getattr( _v, "cpu_compressed_matrix_" + vcl_statement_node_numeric_type_strings[ self.statement_node_numeric_type]) except (KeyError, AttributeError): raise TypeError("dtype %s not supported" % self.statement_node_numeric_type) self.cpu_leaf = get_cpu_leaf(self.cpu_leaf_type) self.base = self @property def nonzeros(self): """ A ``list`` of coordinates of the nonzero elements of the matrix. """ return self.cpu_leaf.nonzeros @property def nnz(self): """ The number of nonzero elements stored in the matrix, as an integer. """ return self.cpu_leaf.nnz @property def size1(self): """ The size of the first axis of the matrix. """ return self.cpu_leaf.size1 @property def size2(self): """ The size of the second axis of the matrix. """ return self.cpu_leaf.size2 @property def size(self): """ The flat size (area) of the matrix, as it would be in dense form. """ return self.size1 * self.size2 # Flat size @property def shape(self): """ The shape of the matrix as a 2-tuple, with one entry for each axis. """ return (self.size1, self.size2) #TODO: this doesn't work right now #def resize(self, size1, size2): # """ # Resize the sparse matrix, not preserving elements. # """ # self.flushed = False # return self.cpu_leaf.resize(size1, size2) def as_ndarray(self): """ Returns the sparse matrix as a dense NumPy ``ndarray``. """ return self.cpu_leaf.as_ndarray() def as_dense(self): """ Returns the sparse matrix as a dense PyViennaCL ``Matrix``. """ return Matrix(self) @property def vcl_leaf(self): """ The underlying C++ ViennaCL object representing the matrix on the compute device. """ if not self.flushed: self.flush() return self._vcl_leaf def __getitem__(self, key): # TODO: extend beyond tuple keys #if not isinstance(key, tuple): # raise KeyError("Key must be a 2-tuple") #if len(key) != 2: # raise KeyError("Key must be a 2-tuple") #if not (isinstance(key[0], int) and isinstance(key[1], int)): # raise KeyError("Only integer keys are currently supported") return np_result_type(self).type(self.cpu_leaf.get_entry(key[0], key[1])) def __setitem__(self, key, value): #if not isinstance(key, tuple): # raise KeyError("Key must be a 2-tuple") #if len(key) != 2: # raise KeyError("Key must be a 2-tuple") #if not (isinstance(key[0], int) and isinstance(key[1], int)): # raise KeyError("Only integer keys are currently supported") self.flushed = False if isinstance(value, ScalarBase): value = value.value #if np_result_type(self) != np_result_type(value): # value = np_result_type(self).type(value) self.cpu_leaf.set_entry(key[0], key[1], value) #self.nnz # Updates nonzero list def __delitem__(self, key): #if not isinstance(key, tuple): # raise KeyError("Key must be a 2-tuple") #if len(key) != 2: # raise KeyError("Key must be a 2-tuple") #if not (isinstance(key[0], int) and isinstance(key[1], int)): # raise KeyError("Only integer keys are currently supported") self.flushed = False self[key] = 0 #self.nnz # Updates nonzero list def __str__(self): out = [] for coord in self.nonzeros: out += ["(", "{}".format(coord[0]), ",", "{}".format(coord[1]), ")\t\t", "{}".format(self[coord]), "\n"] out = out[:-1] return "".join(out) __repr__ = __str__ class CompressedMatrix(SparseMatrixBase): """ This class represents a sparse matrix on the ViennaCL compute device, in a compressed-row storage format. For information on construction, see the help for SparseMatrixBase. """ statement_node_subtype = _v.statement_node_subtype.COMPRESSED_MATRIX_TYPE def flush(self): self._vcl_leaf = self.cpu_leaf.as_compressed_matrix() self.flushed = True class CoordinateMatrix(SparseMatrixBase): """ This class represents a sparse matrix on the ViennaCL compute device, in a `coordinate` storage format: entries are stored as triplets ``(i, j, val)``, where ``i`` is the row index, ``j`` is the column index and ``val`` is the entry. For information on construction, see the help for SparseMatrixBase. """ statement_node_subtype = _v.statement_node_subtype.COORDINATE_MATRIX_TYPE def flush(self): self._vcl_leaf = self.cpu_leaf.as_coordinate_matrix() self.flushed = True class ELLMatrix(SparseMatrixBase): """ This class represents a sparse matrix on the ViennaCL compute device, in ELL storage format. In this format, the matrix is stored in a block of memory of size N by n_max, where N is the number of rows of the matrix and n_max is the maximum number of nonzeros per row. Rows with less than n_max entries are padded with zeros. In a second memory block, the respective column indices are stored. The ELL format is well suited for matrices where most rows have approximately the same number of nonzeros. This is often the case for matrices arising from the discretization of partial differential equations using e.g. the finite element method. On the other hand, the ELL format introduces substantial overhead if the number of nonzeros per row varies a lot. [description adapted from the ViennaCL manual] For information on construction, see the help for SparseMatrixBase. """ statement_node_subtype = _v.statement_node_subtype.ELL_MATRIX_TYPE def flush(self): self._vcl_leaf = self.cpu_leaf.as_ell_matrix() self.flushed = True class HybridMatrix(SparseMatrixBase): """ This class represents a sparse matrix on the ViennaCL compute device, in a hybrid storage format, combining the higher performance of the ELL format for matrices with approximately the same number of entries per row with the higher flexibility of the compressed row format. The main part of the matrix is stored in ELL format and excess entries are stored in compressed row format. [description adapted from the ViennaCL manual] For information on construction, see the help for SparseMatrixBase. """ statement_node_subtype = _v.statement_node_subtype.HYB_MATRIX_TYPE def flush(self): self._vcl_leaf = self.cpu_leaf.as_hyb_matrix() self.flushed = True # TODO: add ndarray flushing class Matrix(Leaf): """ This class represents a dense matrix object on the compute device, and it can be constructed in a number of ways: * with no parameters, as an empty matrix; * from an integer tuple: produces an empty Matrix of that shape; * from a tuple: first two values shape, third scalar value for each element; * from an ndarray of the correct dtype; * from a ViennaCL sparse matrix; * from a ViennaCL ``Matrix`` instance (to make a copy); * from an expression resulting in a Matrix. Both ROW_MAJOR and COL_MAJOR layouts are supported; to determine, provide ``layout`` as a keyword argument to the initialisation. The default layout is row-major. Thus, to construct a 5-by-5 column-major Matrix instance with a numeric data type of ``float32`` (C++ ``float``) and each element being equal to ``3.141``, type: >>> import pyviennacl as p >>> mat = p.Matrix(10, 10, 3.141, dtype=p.float32, layout=p.COL_MAJOR) >>> print(mat) [[ 3.14100003 3.14100003 3.14100003 3.14100003 3.14100003] [ 3.14100003 3.14100003 3.14100003 3.14100003 3.14100003] [ 3.14100003 3.14100003 3.14100003 3.14100003 3.14100003] [ 3.14100003 3.14100003 3.14100003 3.14100003 3.14100003] [ 3.14100003 3.14100003 3.14100003 3.14100003 3.14100003]] """ ndim = 2 statement_node_type_family = _v.statement_node_type_family.MATRIX_TYPE_FAMILY def _init_leaf(self, args, kwargs): """ Construct the underlying ViennaCL vector object according to the given arguments and types. """ if 'shape' in kwargs.keys(): if len(kwargs['shape']) != 2: raise TypeError("Matrix can only have a 2-d shape") args = list(args) args.insert(0, kwargs['shape']) if 'layout' in kwargs.keys(): if kwargs['layout'] == COL_MAJOR: self.layout = COL_MAJOR self.statement_node_subtype = _v.statement_node_subtype.DENSE_COL_MATRIX_TYPE else: self.layout = ROW_MAJOR self.statement_node_subtype = _v.statement_node_subtype.DENSE_ROW_MATRIX_TYPE else: self.layout = ROW_MAJOR self.statement_node_subtype = _v.statement_node_subtype.DENSE_ROW_MATRIX_TYPE if len(args) == 0: def get_leaf(vcl_t): return vcl_t() elif len(args) == 1: if isinstance(args[0], MagicMethods): if issubclass(args[0].result_container_type, SparseMatrixBase): if self.dtype is None: self.dtype = args[0].result.dtype self.layout = args[0].result.layout def get_leaf(vcl_t): return vcl_t(args[0].result.as_ndarray()) elif issubclass(args[0].result_container_type, Matrix): if self.dtype is None: self.dtype = args[0].result.dtype self.layout = args[0].result.layout def get_leaf(vcl_t): return vcl_t(args[0].result.vcl_leaf) else: raise TypeError( "Matrix cannot be constructed in this way") elif isinstance(args[0], tuple) or isinstance(args[0], list): def get_leaf(vcl_t): return vcl_t(args[0][0], args[0][1]) elif isinstance(args[0], ndarray): if self.dtype is None: self.dtype = args[0].dtype def get_leaf(vcl_t): return vcl_t(args[0]) else: # This doesn't do any dtype checking, so beware... def get_leaf(vcl_t): return args[0] elif len(args) == 2: if isinstance(args[0], tuple) or isinstance(args[0], list): if self.dtype is None: self.dtype = np_result_type(args[1]) def get_leaf(vcl_t): return vcl_t(args[0][0], args[0][1], args[1]) else: def get_leaf(vcl_t): return vcl_t(args[0], args[1]) elif len(args) == 3: if self.dtype is None: self.dtype = np_result_type(args[2]) def get_leaf(vcl_t): return vcl_t(args[0], args[1], args[2]) else: raise TypeError("Matrix cannot be constructed in this way") if self.dtype is None: # ie, still None, even after checks -- so guess self.dtype = dtype(float64) self.statement_node_numeric_type = HostScalarTypes[self.dtype.name] try: vcl_type = getattr(_v, "matrix_" + vcl_layout_strings[self.layout] + "_" + vcl_statement_node_numeric_type_strings[ self.statement_node_numeric_type]) except (KeyError, AttributeError): raise TypeError("dtype %s not supported" % self.statement_node_numeric_type) self.vcl_leaf = get_leaf(vcl_type) self.size1 = self.vcl_leaf.size1 self.size2 = self.vcl_leaf.size2 self.size = self.size1 * self.size2 # Flat size self.shape = (self.size1, self.size2) self.internal_size1 = self.vcl_leaf.internal_size1 self.internal_size2 = self.vcl_leaf.internal_size2 def __getitem__(self, key): project = getattr(_v, "project_matrix_" + vcl_statement_node_numeric_type_strings[ self.statement_node_numeric_type]) if isinstance(key, tuple) or isinstance(key, list): if len(key) == 0: return self elif len(key) == 1: return self[key[0]] elif len(key) == 2: if isinstance(key[0], int): # Choose from row if isinstance(key[1], int): # (int, int) -> scalar return HostScalar(self.vcl_leaf.get_entry(key[0], key[1]), dtype=self.dtype) elif isinstance(key[1], slice): # (int, slice) - range/slice from row -> row vector view1 = View(slice(0, key[0]+1), self.size1) view2 = View(key[1], self.size2) return Matrix(project(self.vcl_leaf, view1.vcl_view, view2.vcl_view), dtype=self.dtype, layout=self.layout, view_of=self, view=(view1, view2)) else: raise TypeError("Did not understand key[1]") elif isinstance(key[0], slice): # slice of rows if isinstance(key[1], int): # (slice, int) - range/slice from col -> col vector view1 = View(key[0], self.size1) view2 = View(slice(0, key[1]+1), self.size2) return Matrix(project(self.vcl_leaf, view1.vcl_view, view2.vcl_view), dtype=self.dtype, layout=self.layout, view_of=self, view=(view1, view2)) elif isinstance(key[1], slice): # (slice, slice) - sub-matrix view1 = View(key[0], self.size1) view2 = View(key[1], self.size2) return Matrix(project(self.vcl_leaf, view1.vcl_view, view2.vcl_view), dtype=self.dtype, layout=self.layout, view_of=self, view=(view1, view2)) else: raise TypeError("Did not understand key[1]") else: raise TypeError("Did not understand key[0]") elif isinstance(key, slice): view1 = View(key, self.size1) view2 = View(slice(0, 1, self.size2), self.size2) return Matrix(project(self.vcl_leaf, view1.vcl_view, view2.vcl_view), dtype=self.dtype, layout=self.layout, view_of=self, view=(view1, view2)) elif isinstance(key, int): return self[slice(key)] else: raise IndexError("Did not understand key") #def clear(self): # """ # Set every element of the matrix to 0. # """ # return self.vcl_leaf.clear() @property def T(self): """ Return the matrix transpose. """ return Trans(self) trans = T class Node(MagicMethods): """ This is the base class for all nodes in the ViennaCL expression tree. A node is any binary or unary operation, such as addition. This class provides logic for expression tree construction and result type deduction, in order that expression statements can be executed correctly. If you're extending ViennaCL by adding an operation and want support for it in Python, then you should derive from this class. """ statement_node_type_family = _v.statement_node_type_family.COMPOSITE_OPERATION_FAMILY statement_node_subtype = _v.statement_node_subtype.INVALID_SUBTYPE statement_node_numeric_type = _v.statement_node_numeric_type.INVALID_NUMERIC_TYPE def __init__(self, *args): """ Take the given operand(s) to an appropriate representation for this operation, and deduce the result_type. Construct a ViennaCL statement_node object representing this information, ready to be inserted into an expression statement. """ if len(args) == 1: self.operation_node_type_family = _v.operation_node_type_family.OPERATION_UNARY_TYPE_FAMILY elif len(args) == 2: self.operation_node_type_family = _v.operation_node_type_family.OPERATION_BINARY_TYPE_FAMILY else: raise TypeError("Only unary or binary nodes supported currently") def fix_operand(opand): """ If opand is a scalar type, wrap it in a PyViennaCL scalar class. """ if isinstance(opand, list): opand = array(opand) if (np_result_type(opand).name in HostScalarTypes and not (isinstance(opand, MagicMethods) or isinstance(opand, ndarray))): return HostScalar(opand) else: return opand self.operands = list(map(fix_operand, args)) if self.result_container_type is None: # Try swapping the operands, in case the operation supports # these operand types in one order but not the other; in this case # the mathematical intention is not ambiguous. self.operands.reverse() if self.result_container_type is None: # No use, so revert self.operands.reverse() self._node_init() if self.operation_node_type is None: raise TypeError("Unsupported expression: %s" % (self.express())) self._vcl_node_init() self._test_init() # Make sure we can execute def _node_init(self): pass def _vcl_node_init(self): # At the moment, ViennaCL does not do dtype promotion, so check that # the operands all have the same dtype. if len(self.operands) > 1: if dtype(self.operands[0]) != dtype(self.operands[1]): raise TypeError("dtypes on operands do not match: %s with %s and %s" % (self.express(), dtype(self.operands[0]), dtype(self.operands[1]))) # Set up the ViennaCL statement_node with two operands self.vcl_node = _v.statement_node( self.operands[0].statement_node_type_family, # lhs self.operands[0].statement_node_subtype, # lhs self.operands[0].statement_node_numeric_type, # lhs self.operation_node_type_family, # op self.operation_node_type, # op self.operands[1].statement_node_type_family, # rhs self.operands[1].statement_node_subtype, # rhs self.operands[1].statement_node_numeric_type) # rhs else: # Set up the ViennaCL statement_node with one operand, twice.. self.vcl_node = _v.statement_node( self.operands[0].statement_node_type_family, # lhs self.operands[0].statement_node_subtype, # lhs self.operands[0].statement_node_numeric_type, # lhs self.operation_node_type_family, # op self.operation_node_type, # op self.operands[0].statement_node_type_family, # rhs self.operands[0].statement_node_subtype, # rhs self.operands[0].statement_node_numeric_type) # rhs def _test_init(self): layout_test = self.layout # NB QUIRK def __getitem__(self, key): return self.result[key] def __setitem__(self, key, value): self.result[key] = value def get_vcl_operand_setter(self, operand): """ This function returns the correct function for setting the underlying ViennaCL statement_node object's operand(s) in the correct way: each different container type and dtype are mapped onto a different set_operand_to function in the underlying object, in order to avoid type ambiguity at the Python/C++ interface. """ vcl_operand_setter = [ "set_operand_to_", vcl_statement_node_subtype_strings[ operand.statement_node_subtype], "_", vcl_statement_node_numeric_type_strings[ operand.statement_node_numeric_type] ] return getattr(self.vcl_node, "".join(vcl_operand_setter)) @property def complexity(self): """ The complexity of the ViennaCL expression, given as the number of Node instances in the expression tree. """ complexity = 1 for op in self.operands: complexity += op.complexity return complexity @property def result_container_type(self): """ Determine the container type (ie, Scalar, Vector, etc) needed to store the result of the operation encoded by this Node. If the operation has some effect (eg, in-place), but does not produce a distinct result, then return NoResult. If the operation is not supported for the given operand types, then return None. """ if len(self.result_types) < 1: return NoResult if len(self.operands) > 0: try: op0_t = self.operands[0].result_container_type.__name__ except AttributeError: # Not a PyViennaCL type, so we have a number of options. # Suppose an ndarray... if isinstance(self.operands[0], ndarray): self.operands[0] = from_ndarray(self.operands[0]) op0_t = self.operands[0].result_container_type.__name__ else: # Otherwise, assume some scalar and hope for the best op0_t = 'HostScalar' else: raise RuntimeError("What is a 0-ary operation?") if len(self.operands) > 1: try: op1_t = self.operands[1].result_container_type.__name__ except AttributeError: if isinstance(self.operands[1], ndarray): if self.operands[1].ndim == 1: self.operands[1] = Vector(self.operands[1]) elif self.operands[1].ndim == 2: self.operands[1] = Matrix(self.operands[1]) else: raise AttributeError("Cannot cope with %d dimensions!" % self.operands[1].ndim) op1_t = self.operands[1].result_container_type.__name__ else: # Again, hope for the best.. op1_t = 'HostScalar' try: return self.result_types[(op0_t, op1_t)] except KeyError: # Operation not supported for given operand types return None else: # No more operands, so test for 1-ary result_type try: return self.result_types[(op0_t, )] except KeyError: return None @property def dtype(self): """ Determine the dtype of the scalar element(s) of the result of the operation encoded by this Node, according to the NumPy type promotion rules. """ dtypes = tuple(map(lambda x: x.dtype, self.operands)) if len(dtypes) == 1: return np_result_type(dtypes[0]) if len(dtypes) == 2: return np_result_type(dtypes[0], dtypes[1]) @property def layout(self): """ Recursively determine the storage layout for the result type, if the result is a Matrix. Notably, this ensures that any Matrix operands have the same layout, since this is a condition of all ViennaCL operations, except for the matrix-matrix product. """ layout = None if self.result_container_type == Matrix: for opand in self.operands: try: next_layout = opand.layout except: continue if layout is None: layout = next_layout if (next_layout != layout) and (self.operation_node_type != _v.operation_node_type.OPERATION_BINARY_MAT_MAT_PROD_TYPE): raise TypeError("Matrices do not have the same layout") if layout is None: # May as well now choose a default layout ... layout = p.ROW_MAJOR return layout @property def result_ndim(self): """ Determine the maximum number of dimensions required to store the result of any operation on the given operands. This can be overridden by the particular Node subclass, in order to compute the correct size for the result container. """ ndim = 0 for op in self.operands: if isinstance(op, Node): nd = op.result_ndim if (nd > ndim): ndim = nd elif (op.ndim > ndim): ndim = op.ndim return ndim @property def result_max_axis_size(self): """ Determine the maximum size of any axis required to store the result of any operation on the given operands. This can be overridden by the particular Node subclass, in order to compute the correct size for the result container. """ max_size = 1 for op in self.operands: if isinstance(op, Node): s = op.result_max_axis_size if (s > max_size): max_size = s else: try: op.shape except: continue for s in op.shape: if (s > max_size): max_size = s return max_size @property def shape(self): """ Determine the upper-bound shape of the object needed to store the result of any operation on the given operands. The len of this tuple is the number of dimensions, with each element of the tuple determining the upper-bound size of the corresponding dimension. If the shape is set manually, then this routine is overridden, and the manually set value is returned. """ try: if isinstance(self._shape, tuple): return self._shape except: pass ndim = self.result_ndim max_size = self.result_max_axis_size shape = [] for n in range(ndim): shape.append(max_size) shape = tuple(shape) self._shape = shape return shape @shape.setter def shape(self, value): self._shape = value def express(self, statement=""): """ Produce a human readable representation of the expression graph including all nodes and leaves connected to this one, which constitutes the root node. """ statement += type(self).__name__ + "(" for op in self.operands: statement = op.express(statement) + ", " if self.result_container_type is None: result_expression = "None" else: result_expression = self.result_container_type.__name__ statement = statement[:-2] + ")=>" + result_expression return statement @property def result(self): """ The result of computing the operation represented by this Node instance. Returns the cached result if there is one, otherwise executes the corresponding expression, caches the result, and returns that. """ if not self.flushed: self.execute() return self._result else: return self._result @property def vcl_leaf(self): return self.result.vcl_leaf def execute(self): """ Execute the expression tree taking this instance as the root, and then cache and return the result. """ s = Statement(self) self._result = s.execute() self.flushed = True return self._result @property def value(self): """ The value of the result of computing the operation represented by this Node; if the result is array-like, then the type is a NumPy ``ndarray``, otherwise, a scalar is returned. """ return self.result.value def as_ndarray(self): """ Return the value of computing the operation represented by this Node as a NumPy ``ndarray``. """ return array(self.value, dtype=self.dtype) class Norm_1(Node): """ Represent the computation of the L^1-norm of a Vector. """ result_types = { ('Vector',): HostScalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_NORM_1_TYPE class Norm_2(Node): """ Represent the computation of the L^2-norm of a Vector. """ result_types = { ('Vector',): HostScalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_NORM_2_TYPE class Norm_Inf(Node): """ Represent the computation of the L^inf-norm of a Vector. """ result_types = { ('Vector',): HostScalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_NORM_INF_TYPE class ElementAbs(Node): """ Represent the elementwise computation of ``abs`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_ABS_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementAcos(Node): """ Represent the elementwise computation of ``acos`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_ACOS_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementAsin(Node): """ Represent the elementwise computation of ``asin`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_ASIN_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementAtan(Node): """ Represent the elementwise computation of ``atan`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_ATAN_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementCeil(Node): """ Represent the elementwise computation of ``ceil`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_CEIL_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementCos(Node): """ Represent the elementwise computation of ``cos`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_COS_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementCosh(Node): """ Represent the elementwise computation of ``cosh`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_COSH_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementExp(Node): """ Represent the elementwise computation of ``exp`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_EXP_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementFabs(Node): """ Represent the elementwise computation of ``fabs`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_FABS_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementFloor(Node): """ Represent the elementwise computation of ``floor`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_FLOOR_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementLog(Node): """ Represent the elementwise computation of ``log`` (base e) on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_LOG_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementLog10(Node): """ Represent the elementwise computation of ``log`` (base 10) on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_LOG10_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementSin(Node): """ Represent the elementwise computation of ``sin`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_SIN_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementSinh(Node): """ Represent the elementwise computation of ``sinh`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_SINH_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementSqrt(Node): """ Represent the elementwise computation of ``sqrt`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_SQRT_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementTan(Node): """ Represent the elementwise computation of ``tan`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_TAN_TYPE def _node_init(self): self.shape = self.operands[0].shape class ElementTanh(Node): """ Represent the elementwise computation of ``tanh`` on an object. """ result_types = { ('Matrix',): Matrix, ('Vector',): Vector, ('Scalar',): Scalar } operation_node_type = _v.operation_node_type.OPERATION_UNARY_TANH_TYPE def _node_init(self): self.shape = self.operands[0].shape class Trans(Node): """ Represent the computation of the matrix transpose. """ result_types = { ('Matrix',): Matrix, } operation_node_type = _v.operation_node_type.OPERATION_UNARY_TRANS_TYPE def _node_init(self): self.shape = (self.operands[0].shape[1], self.operands[0].shape[0]) class Assign(Node): """ Represent the assignment (copy) of one object's content to another. For example: `x = y` is represented by `Assign(x, y)`. """ result_types = {} operation_node_type = _v.operation_node_type.OPERATION_BINARY_ASSIGN_TYPE class InplaceAdd(Assign): """ Represent the computation of the in-place addition of one object to another. Derives from Assign rather than directly from Node because in-place operations are mathematically similar to assignation. """ result_types = { #('Scalar', 'Scalar'): Scalar, #('HostScalar', 'HostScalar'): HostScalar, ('Vector', 'Vector'): Vector, ('Matrix', 'Matrix'): Matrix } operation_node_type = _v.operation_node_type.OPERATION_BINARY_INPLACE_ADD_TYPE def _node_init(self): if self.operands[0].shape != self.operands[1].shape: raise TypeError("Cannot add two differently shaped objects! %s" % self.express()) self.shape = self.operands[0].shape #if self.operands[0].result_container_type == Scalar and self.operands[1].result_container_type == HostScalar: # self.operands[1] = Scalar(self.operands[1]) #if self.operands[1].result_container_type == Scalar and self.operands[0].result_container_type == HostScalar: # self.operands[0] = Scalar(self.operands[0]) class InplaceSub(Assign): """ Represent the computation of the in-place subtraction of one object to another. Derives from Assign rather than directly from Node because in-place operations are mathematically similar to assignation. """ result_types = { #('Scalar', 'Scalar'): Scalar, #('HostScalar', 'HostScalar'): HostScalar, ('Vector', 'Vector'): Vector, ('Matrix', 'Matrix'): Matrix } operation_node_type = _v.operation_node_type.OPERATION_BINARY_INPLACE_SUB_TYPE def _node_init(self): if self.operands[0].shape != self.operands[1].shape: raise TypeError("Cannot subtract two differently shaped objects! %s" % self.express()) self.shape = self.operands[0].shape class Add(Node): """ Represent the addition of one object to another. """ result_types = { #('Scalar', 'Scalar'): Scalar, #('HostScalar', 'HostScalar'): HostScalar, ('Vector', 'Vector'): Vector, ('Matrix', 'Matrix'): Matrix } operation_node_type = _v.operation_node_type.OPERATION_BINARY_ADD_TYPE def _node_init(self): if self.operands[0].shape != self.operands[1].shape: raise TypeError("Cannot Add two differently shaped objects! %s" % self.express()) self.shape = self.operands[0].shape class Sub(Node): """ Represent the subtraction of one object from another. """ result_types = { #('Scalar', 'Scalar'): Scalar, #('HostScalar', 'HostScalar'): HostScalar, ('Vector', 'Vector'): Vector, ('Matrix', 'Matrix'): Matrix } operation_node_type = _v.operation_node_type.OPERATION_BINARY_SUB_TYPE def _node_init(self): if self.operands[0].shape != self.operands[1].shape: raise TypeError("Cannot Sub two differently shaped objects! %s" % self.express()) self.shape = self.operands[0].shape if self.operands[0].result_container_type == Scalar and self.operands[1].result_container_type == HostScalar: temp = self.operands[1].result self.operands[1] = Scalar(temp) if self.operands[1].result_container_type == Scalar and self.operands[0].result_container_type == HostScalar: self.operands[0] = Scalar(self.operands[0].result) class Mul(Node): """ Represents the multiplication of one object by another. The semantics are as follows: * Scalar by scalar -> scalar; * scalar by vector -> scaled vector; * scalar by matrix -> scaled matrix; * vector by vector -> undefined; * vector by matrix -> undefined; * matrix by vector -> matrix-vector product; * matrix by matrix -> matrix-matrix product. The concern in defining these semantics has been to preserve the dimensionality of the operands in the result. The Mul class does not map directly onto the * operator for every class. """ result_types = { # OPERATION_BINARY_MAT_MAT_PROD_TYPE ('Matrix', 'Matrix'): Matrix, # TODO: Sparse matrix support here # OPERATION_BINARY_MAT_VEC_PROD_TYPE ('Matrix', 'Vector'): Vector, ('CompressedMatrix', 'Vector'): Vector, ('CoordinateMatrix', 'Vector'): Vector, ('ELLMatrix', 'Vector'): Vector, ('HybridMatrix', 'Vector'): Vector, # "OPERATION_BINARY_VEC_VEC_PROD_TYPE" -- VEC as 1-D MAT? #('Vector', 'Vector'): Matrix, # TODO NOT IMPLEMENTED IN SCHEDULER # OPERATION_BINARY_MULT_TYPE ('Matrix', 'HostScalar'): Matrix, ('Matrix', 'Scalar'): Matrix, ('Vector', 'HostScalar'): Vector, ('Vector', 'Scalar'): Vector, ('Scalar', 'Scalar'): Scalar, ('Scalar', 'HostScalar'): HostScalar, ('HostScalar', 'HostScalar'): HostScalar # TODO: Sparse matrix support here } def _node_init(self): if (self.operands[0].result_container_type == Matrix or issubclass(self.operands[0].result_container_type, SparseMatrixBase)): # Matrix * ... if (self.operands[1].result_container_type == Matrix or issubclass(self.operands[1].result_container_type, SparseMatrixBase)): self.operation_node_type = _v.operation_node_type.OPERATION_BINARY_MAT_MAT_PROD_TYPE self.shape = (self.operands[0].shape[0], self.operands[1].shape[1]) elif self.operands[1].result_container_type == Vector: # Need to make sure that matrix and vector shapes are aligned if self.operands[0].shape[1] != self.operands[1].shape[0]: raise ValueError("Operand shapes not correctly aligned") self.operation_node_type = _v.operation_node_type.OPERATION_BINARY_MAT_VEC_PROD_TYPE self.shape = (self.operands[0].shape[0],) elif self.operands[1].result_container_type == Scalar: self.operation_node_type = _v.operation_node_type.OPERATION_BINARY_MULT_TYPE self.shape = self.operands[0].shape elif self.operands[1].result_container_type == HostScalar: self.operation_node_type = _v.operation_node_type.OPERATION_BINARY_MULT_TYPE self.shape = self.operands[0].shape else: self.operation_node_type = None elif self.operands[0].result_container_type == Vector: # Vector * ... if self.operands[1].result_container_type == Scalar: self.operation_node_type = _v.operation_node_type.OPERATION_BINARY_MULT_TYPE self.shape = self.operands[0].shape elif self.operands[1].result_container_type == HostScalar: self.operation_node_type = _v.operation_node_type.OPERATION_BINARY_MULT_TYPE self.shape = self.operands[0].shape else: self.operation_node_type = None elif self.operands[0].result_container_type == Scalar: # # TODO -- but why?.. # if self.operands[1].result_container_type == Matrix: self.operation_node_type = _v.operation_node_type.OPERATION_BINARY_MULT_TYPE self.shape = self.operands[1].shape else: self.operation_node_type = None elif self.operands[0].result_container_type == HostScalar: # # TODO -- but why?.. # if self.operands[1].result_container_type == Matrix: self.operation_node_type = _v.operation_node_type.OPERATION_BINARY_MULT_TYPE self.shape = self.operands[1].shape else: self.operation_node_type = None else: self.operation_node_type = None class Div(Node): """ Represents the division of a Matrix or Vector by a scalar. """ result_types = { ('Vector', 'Scalar'): Vector, ('Vector', 'HostScalar'): Vector, ('Matrix', 'Scalar'): Matrix, ('Matrix', 'HostScalar'): Matrix } operation_node_type = _v.operation_node_type.OPERATION_BINARY_DIV_TYPE class ElementProd(Node): """ Represents the elementwise multiplication of one object by another of the same type. """ result_types = { ('Vector', 'Vector'): Vector, ('Matrix', 'Matrix'): Matrix } operation_node_type = _v.operation_node_type.OPERATION_BINARY_ELEMENT_PROD_TYPE class ElementDiv(Node): """ Represents the elementwise multiplication of one object by another of the same type. """ result_types = { ('Vector', 'Vector'): Vector, ('Matrix', 'Matrix'): Matrix } operation_node_type = _v.operation_node_type.OPERATION_BINARY_ELEMENT_DIV_TYPE class Dot(Node): """ Represents the computation of the inner (dot) product of two vectors. """ result_types = { ('Vector', 'Vector'): Scalar } operation_node_type = _v.operation_node_type.OPERATION_BINARY_INNER_PROD_TYPE shape = () class Statement: """ This class represents the ViennaCL `statement` corresponding to an expression graph. It employs type deduction information to calculate the resultant types, and generates the appropriate underlying ViennaCL C++ object. """ def __init__(self, root): """ Given a Node instance, return an object representing the ViennaCL statement of the corresponding expression graph, as connected to the given root node. If the given root node is not an instance of Assign type, then a temporary object is constructed to store the result of executing the expression, and then a new Assign instance is created, representing the assignation of the result of the expression to the new temporary. The new Assign node is then taken to be the root node of the graph, having transposed the rest. """ if not isinstance(root, Node): raise RuntimeError("Statement must be initialised on a Node") self.statement = [] # A list to hold the flattened expression tree next_node = [] # Holds nodes as we travel down the tree # Test to see that we can actually do the operation if not root.result_container_type: raise TypeError("Unsupported expression: %s" %(root.express())) # If the root node is not an Assign instance, then construct a # temporary to hold the result. if isinstance(root, Assign): self.result = root.operands[0] else: self.result = root.result_container_type( shape = root.shape, dtype = root.dtype, layout = root.layout) top = Assign(self.result, root) next_node.append(top) next_node.append(root) # Flatten the tree for n in next_node: op_num = 0 for operand in n.operands: if isinstance(operand, Node): #if op_num == 0 and len(n.operands) > 1: # # ViennaCL cannot cope with complex LHS # operand = operand.result # n.operands[0] = operand # n._vcl_node_init() #else: next_node.append(operand) op_num += 1 append_node = True for N in self.statement: if id(N) == id(n): append_node = False break if append_node: self.statement.append(n) # Contruct a ViennaCL statement object self.vcl_statement = _v.statement() # Append the nodes in the flattened statement to the ViennaCL # statement, doing various type checks as we go. for n in self.statement: op_num = 0 for operand in n.operands: if isinstance(operand, Leaf): n.get_vcl_operand_setter(operand)(op_num, operand.vcl_leaf) elif isinstance(operand, Node): op_idx = 0 for next_op in self.statement: if hash(operand) == hash(next_op): break op_idx += 1 n.get_vcl_operand_setter(operand)(op_num, op_idx) elif np_result_type(operand).name in HostScalarTypes.keys(): n.get_vcl_operand_setter(HostScalar(operand))( op_num, operand) op_num += 1 self.vcl_statement.insert_at_end(n.vcl_node) def execute(self): """ Execute the statement -- don't do anything else -- then return the result (if any). """ try: self.vcl_statement.execute() except RuntimeError: log.error("EXCEPTION EXECUTING: %s" %(self.statement[0].express())) raise return self.result # TODO: __all__ pyviennacl-1.0.2+dfsg.orig/pyviennacl/__init__.py0000644000000000000000000000364012307335633020527 0ustar rootroot""" PyViennaCL ========== This extension provides the Python bindings for the ViennaCL linear algebra and numerical computation library for GPGPU and heterogeneous systems. ViennaCL itself is a header-only C++ library, so these bindings make available to Python programmers ViennaCL's fast OpenCL and CUDA algorithms, in a way that is idiomatic and compatible with the Python community's most popular scientific packages, NumPy and SciPy. PyViennaCL is divided into five submodules, of which four are designed for direct use by users: * :doc:`pycore`: user-friendly classes for representing the main ViennaCL objects, such as Matrix or Vector; * :doc:`linalg`: an explicit interface to a number of ViennaCL's linear algebra routines, such as matrix solvers and eigenvalue computation; * :doc:`vclmath`: convenience functions akin to the standard math module (you can also access it as ``pyviennacl.math``); * :doc:`util`: utility functions, such as to construct an appropriate ViennaCL object from an ndarray (Matrix or Vector), or to provide basic debug logging; * _viennacl: a raw C++ interface to ViennaCL, with no stable API. Nonetheless, all of PyViennaCL's functionality is available from the top-level pyviennacl namespace. So, if you want help on the Matrix class, you can just run:: >>> import pyviennacl as p >>> help(p.Matrix) # doctest: +SKIP For help on PyViennaCL's core functionality in general, or PyViennaCL's high-level linear algebra functions, run:: >>> help(p.pycore) # doctest: +SKIP or:: >>> help(p.linalg) # doctest: +SKIP """ from .version import VERSION_TEXT as __version__ from ._viennacl import __version__ as __viennacl_version__ from .pycore import * from .linalg import * from .util import * from .vclmath import * from . import vclmath as math # TODO: __all__ pyviennacl-1.0.2+dfsg.orig/setup.py0000644000000000000000000001642512324474376015774 0ustar rootroot#!/usr/bin/env python import sys from distutils.command.build_ext import build_ext platform_cflags = {} platform_ldflags = {} platform_libs = {} class build_ext_subclass(build_ext): """Shamelessly stolen from https://stackoverflow.com/questions/724664 """ def build_extensions(self): c = self.compiler.compiler_type if c in platform_cflags.keys(): for e in self.extensions: e.extra_compile_args = platform_cflags[c] if c in platform_ldflags.keys(): for e in self.extensions: e.extra_link_args = platform_ldflags[c] if c in platform_libs.keys(): for e in self.extensions: try: e.libraries += platform_libs[c] except: e.libraries = platform_libs[c] build_ext.build_extensions(self) def get_config_schema(): from aksetup_helper import ConfigSchema, \ IncludeDir, LibraryDir, Libraries, BoostLibraries, \ Switch, StringListOption, make_boost_base_options if sys.platform.startswith('darwin'): import platform osx_ver, _, _ = platform.mac_ver() osx_ver = '.'.join(osx_ver.split('.')[:2]) sysroot_paths = [ "/Applications/Xcode.app/Contents/Developer/Platforms/" "MacOSX.platform/Developer/SDKs/MacOSX%s.sdk" % osx_ver, "/Developer/SDKs/MacOSX%s.sdk" % osx_ver ] default_libs = [] default_cxxflags = ['-arch', 'i386', '-arch', 'x86_64'] from os.path import isdir for srp in sysroot_paths: if isdir(srp): default_cxxflags.extend(['-isysroot', srp]) break default_ldflags = default_cxxflags[:] + ["-Wl,-framework,OpenCL"] else: default_libs = ["OpenCL"] default_cxxflags = [] default_ldflags = [] try: import os conf_file = os.environ["SITECONF"] except: conf_file = "siteconf.py" return ConfigSchema( make_boost_base_options() + [ BoostLibraries("python"), Switch("USE_SHIPPED_BOOST", True, "Use included Boost library"), Switch("USE_SHIPPED_VIENNACL", True, "Use included ViennaCL library"), Switch("USE_OPENCL", True, "Use OpenCL"), IncludeDir("CL", []), LibraryDir("CL", []), Libraries("CL", default_libs), IncludeDir("VIENNACL", []), StringListOption("CXXFLAGS", default_cxxflags, help="Any extra C++ compiler options to include"), StringListOption("LDFLAGS", default_ldflags, help="Any extra linker options to include"), ], conf_file=conf_file) def main(): import os from aksetup_helper import (hack_distutils, get_config, setup, NumpyExtension, set_up_shipped_boost_if_requested, check_git_submodules) check_git_submodules() hack_distutils() conf = get_config(get_config_schema(), warn_about_no_config=False) EXTRA_OBJECTS, EXTRA_DEFINES = \ set_up_shipped_boost_if_requested( "pyviennacl", conf, source_path="external/boost-python-ublas-subset/boost_subset", boost_chrono="header_only") INCLUDE_DIRS = conf["BOOST_INC_DIR"] + [ "external/boost_numpy/" ] if conf["USE_SHIPPED_VIENNACL"]: INCLUDE_DIRS += ["external/viennacl-dev/"] LIBRARY_DIRS = conf["BOOST_LIB_DIR"] LIBRARIES = conf["BOOST_PYTHON_LIBNAME"] # {{{ get version number ver_dic = {} version_file = open("pyviennacl/version.py") try: version_file_contents = version_file.read() finally: version_file.close() exec(compile(version_file_contents, "pyviennacl/version.py", 'exec'), ver_dic) # }}} if conf["USE_OPENCL"]: EXTRA_DEFINES["VIENNACL_WITH_OPENCL"] = None EXTRA_DEFINES["VIENNACL_WITH_UBLAS"] = None platform_cflags["msvc"] = ["/EHsc"] platform_cflags["mingw32"] = ["-Wno-unused-function"] platform_cflags["unix"] = ["-Wno-unused-function"] if not sys.platform.startswith("darwin"): platform_libs['unix'] = ['rt'] if EXTRA_OBJECTS: platform_cflags['mingw32'] += ["-Wno-unused-local-typedefs"] if not sys.platform.startswith("darwin"): platform_cflags['unix'] += ["-Wno-unused-local-typedefs"] source_files = [ "core", "vector_float", "vector_double", "vector_int", "vector_long", "vector_uint", "vector_ulong", "dense_matrix_float", "dense_matrix_double", "dense_matrix_int", "dense_matrix_long", "dense_matrix_uint", "dense_matrix_ulong", "compressed_matrix", "coordinate_matrix", "ell_matrix", "hyb_matrix", "direct_solvers", "iterative_solvers", "eig", "extra_functions", "scheduler", "opencl_support"] from glob import glob try: long_description = open("README.rst", "rt", encoding='utf8').read() except: long_description = open("README.rst", "rt").read() setup( name="pyviennacl", version=ver_dic["VERSION_TEXT"], description="Sparse/dense linear algebra on GPUs and CPUs using OpenCL", long_description=long_description, author='Toby St Clere Smithe', author_email='pyviennacl@tsmithe.net', url="http://viennacl.sourceforge.net/pyviennacl.html", classifiers=[ 'Environment :: Console', 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'Intended Audience :: Other Audience', 'Intended Audience :: Science/Research', 'License :: OSI Approved :: MIT License', 'Natural Language :: English', 'Programming Language :: C++', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.6', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.2', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Topic :: Scientific/Engineering', 'Topic :: Scientific/Engineering :: Mathematics', 'Topic :: Scientific/Engineering :: Physics', ], packages=["pyviennacl"], ext_package="pyviennacl", ext_modules=[NumpyExtension( "_viennacl", [os.path.join("src", "_viennacl", sf + ".cpp") for sf in source_files] + glob("external/boost_numpy/libs/numpy/src/*.cpp") + EXTRA_OBJECTS, depends=[os.path.join("src", "_viennacl", "viennacl.h")], extra_compile_args=conf["CXXFLAGS"], extra_link_args=conf["LDFLAGS"], define_macros=list(EXTRA_DEFINES.items()), include_dirs=INCLUDE_DIRS, library_dirs=LIBRARY_DIRS + conf["CL_LIB_DIR"], libraries=LIBRARIES + conf["CL_LIBNAME"], )], cmdclass={'build_ext': build_ext_subclass} ) if __name__ == "__main__": main() pyviennacl-1.0.2+dfsg.orig/src/0000755000000000000000000000000012332260014015016 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/src/_viennacl/0000755000000000000000000000000012332260016016756 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/src/_viennacl/opencl_support.cpp0000644000000000000000000000715512307335633022560 0ustar rootroot#include "viennacl.h" #include "vector.h" #include #include #include std::vector get_platform_devices(vcl::ocl::platform& p) { return p.devices(); } std::string get_device_info(vcl::ocl::device& d) { return d.info(); } std::string get_device_full_info(vcl::ocl::device& d) { return d.full_info(); } PYVCL_SUBMODULE(opencl_support) { bp::object opencl_support_submodule(bp::handle<>(bp::borrowed(PyImport_AddModule("_viennacl.opencl_support")))); bp::scope().attr("opencl_support") = opencl_support_submodule; bp::scope opencl_support_scope = opencl_support_submodule; bp::class_("platform", bp::no_init) .add_property("info", &vcl::ocl::platform::info) .add_property("devices", get_platform_devices) ; bp::to_python_converter, vector_to_list_converter >(); bp::def("get_platforms", vcl::ocl::get_platforms); bp::class_("device") .add_property("name", &vcl::ocl::device::name) .add_property("vendor", &vcl::ocl::device::vendor) .add_property("version", &vcl::ocl::device::version) .add_property("driver_version", &vcl::ocl::device::driver_version) .add_property("info", get_device_info) .add_property("full_info", get_device_full_info) .add_property("extensions", &vcl::ocl::device::extensions) .add_property("double_support", &vcl::ocl::device::double_support) ; bp::to_python_converter, vector_to_list_converter >(); DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::ocl::context, void, init, init_new_context, ()); DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::ocl::context, void, add_device, context_add_device, (viennacl::ocl::device const&)); DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::ocl::context, void, switch_device, context_switch_device, (viennacl::ocl::device const&)); DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::ocl::context, void, platform_index, context_set_platform_index, (vcl::vcl_size_t)); DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::ocl::context, vcl::vcl_size_t, platform_index, context_get_platform_index, () const); bp::class_("context") .def("init_new_context", init_new_context) .def("current_device", &vcl::ocl::context::current_device, bp::return_value_policy()) .def("devices", &vcl::ocl::context::devices, bp::return_value_policy()) .def("add_device", context_add_device) .def("switch_active_device", context_switch_device) .add_property("platform_index", context_get_platform_index, context_set_platform_index) ; bp::def("get_current_context", vcl::ocl::current_context, bp::return_value_policy()); bp::def("get_current_device", vcl::ocl::current_device, bp::return_value_policy()); DISAMBIGUATE_FUNCTION_PTR(void, vcl::ocl::setup_context, setup_context_single, (long, vcl::ocl::device const&)); bp::def("setup_context", setup_context_single); bp::def("switch_context", vcl::ocl::switch_context); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/dense_matrix_int.cpp0000644000000000000000000000033012307335633023024 0ustar rootroot#include "dense_matrix.h" PYVCL_SUBMODULE(dense_matrix_int) { EXPORT_DENSE_MATRIX_CLASS(int, row, vcl::row_major, ublas::row_major) EXPORT_DENSE_MATRIX_CLASS(int, col, vcl::column_major, ublas::column_major) } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/vector_uint.cpp0000644000000000000000000000012412307335633022032 0ustar rootroot#include "vector.h" PYVCL_SUBMODULE(vector_uint) { EXPORT_VECTOR_CLASS(uint); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/dense_matrix_long.cpp0000644000000000000000000000033312307335633023174 0ustar rootroot#include "dense_matrix.h" PYVCL_SUBMODULE(dense_matrix_long) { EXPORT_DENSE_MATRIX_CLASS(long, row, vcl::row_major, ublas::row_major) EXPORT_DENSE_MATRIX_CLASS(long, col, vcl::column_major, ublas::column_major) } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/iterative_solvers.hpp0000644000000000000000000001200712307335633023252 0ustar rootroot#ifndef _PYVIENNACL_ITERATIVE_SOLVERS_H #define _PYVIENNACL_ITERATIVE_SOLVERS_H #include #include #include #include #include #include #include #include #include "viennacl.h" #include "solve_op_func.hpp" #define EXPORT_DENSE_ITERATIVE_SOLVERS_F(TYPE, F) \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, vcl::vector&, \ vcl::linalg::cg_tag&, \ op_solve, 0>); \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, vcl::vector&, \ vcl::linalg::bicgstab_tag&, \ op_solve, 0>); \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, vcl::vector&, \ vcl::linalg::gmres_tag&, \ op_solve, 0>); #define EXPORT_DENSE_ITERATIVE_SOLVERS(TYPE) \ EXPORT_DENSE_ITERATIVE_SOLVERS_F(TYPE, vcl::row_major); \ EXPORT_DENSE_ITERATIVE_SOLVERS_F(TYPE, vcl::column_major); #define EXPORT_SPARSE_ITERATIVE_SOLVERS(TYPE) \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::compressed_matrix&, vcl::vector&, \ vcl::linalg::cg_tag&, \ op_solve, 0>); \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::compressed_matrix&, vcl::vector&, \ vcl::linalg::bicgstab_tag&, \ op_solve, 0>); \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::compressed_matrix&, vcl::vector&, \ vcl::linalg::gmres_tag&, \ op_solve, 0>); \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::coordinate_matrix&, vcl::vector&, \ vcl::linalg::cg_tag&, \ op_solve, 0>); \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::coordinate_matrix&, vcl::vector&, \ vcl::linalg::bicgstab_tag&, \ op_solve, 0>); \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::coordinate_matrix&, vcl::vector&, \ vcl::linalg::gmres_tag&, \ op_solve, 0>); \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::ell_matrix&, vcl::vector&, \ vcl::linalg::cg_tag&, \ op_solve, 0>); \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::ell_matrix&, vcl::vector&, \ vcl::linalg::bicgstab_tag&, \ op_solve, 0>); \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::ell_matrix&, vcl::vector&, \ vcl::linalg::gmres_tag&, \ op_solve, 0>); \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::hyb_matrix&, vcl::vector&, \ vcl::linalg::cg_tag&, \ op_solve, 0>); \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::hyb_matrix&, vcl::vector&, \ vcl::linalg::bicgstab_tag&, \ op_solve, 0>); \ bp::def("iterative_solve", pyvcl_do_3ary_op, \ vcl::hyb_matrix&, vcl::vector&, \ vcl::linalg::gmres_tag&, \ op_solve, 0>); #endif pyviennacl-1.0.2+dfsg.orig/src/_viennacl/compressed_matrix.hpp0000644000000000000000000001047112307335633023234 0ustar rootroot#ifndef _PYVIENNACL_COMPRESSED_MATRIX_H #define _PYVIENNACL_COMPRESSED_MATRIX_H #include "sparse_matrix.h" #define EXPORT_COMPRESSED_MATRIX(TYPE) \ bp::class_ > \ ("cpu_compressed_matrix_" #TYPE) \ .def(bp::init<>()) \ .def(bp::init()) \ .def(bp::init()) \ .def(bp::init >()) \ .def(bp::init >()) \ /*.def(bp::init >()) */ \ .def(bp::init >()) \ .def(bp::init >()) \ .def(bp::init()) \ .add_property("nonzeros", &cpu_compressed_matrix_wrapper::places) \ .add_property("nnz", &cpu_compressed_matrix_wrapper::nnz) \ .add_property("size1", &cpu_compressed_matrix_wrapper::size1) \ .add_property("size2", &cpu_compressed_matrix_wrapper::size2) \ .def("resize", &cpu_compressed_matrix_wrapper::resize) \ .def("set_entry", &cpu_compressed_matrix_wrapper::set_entry) \ .def("get_entry", &cpu_compressed_matrix_wrapper::get_entry) \ .def("as_ndarray", &cpu_compressed_matrix_wrapper::as_ndarray) \ .def("as_compressed_matrix", \ &cpu_compressed_matrix_wrapper \ ::as_vcl_sparse_matrix_with_size >) \ .def("as_coordinate_matrix", \ &cpu_compressed_matrix_wrapper \ ::as_vcl_sparse_matrix_with_size >) \ .def("as_ell_matrix", \ &cpu_compressed_matrix_wrapper \ ::as_vcl_sparse_matrix >) \ .def("as_hyb_matrix", \ &cpu_compressed_matrix_wrapper \ ::as_vcl_sparse_matrix >) \ ; \ bp::class_, \ vcl::tools::shared_ptr > > \ ("compressed_matrix_" #TYPE, bp::no_init) \ .add_property("size1", \ make_function(&vcl::compressed_matrix::size1, \ bp::return_value_policy())) \ .add_property("size2", \ make_function(&vcl::compressed_matrix::size2, \ bp::return_value_policy())) \ .add_property("nnz", \ make_function(&vcl::compressed_matrix::nnz, \ bp::return_value_policy())) \ .def("prod", pyvcl_do_2ary_op, \ vcl::compressed_matrix&, vcl::vector&, \ op_prod, 0>) \ ; /* .def("inplace_solve", pyvcl_do_3ary_op, vcl::compressed_matrix&, vcl::vector&, vcl::linalg::lower_tag, op_inplace_solve, 0>) .def("inplace_solve", pyvcl_do_3ary_op, vcl::compressed_matrix&, vcl::vector&, vcl::linalg::unit_lower_tag, op_inplace_solve, 0>) .def("inplace_solve", pyvcl_do_3ary_op, vcl::compressed_matrix&, vcl::vector&, vcl::linalg::unit_upper_tag, op_inplace_solve, 0>) .def("inplace_solve", pyvcl_do_3ary_op, vcl::compressed_matrix&, vcl::vector&, vcl::linalg::upper_tag, op_inplace_solve, 0>) */ #endif pyviennacl-1.0.2+dfsg.orig/src/_viennacl/vector_ulong.cpp0000644000000000000000000000012612307335633022201 0ustar rootroot#include "vector.h" PYVCL_SUBMODULE(vector_ulong) { EXPORT_VECTOR_CLASS(ulong); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/sparse_matrix.h0000644000000000000000000001362312307335633022027 0ustar rootroot#ifndef _PYVIENNACL_VECTOR_H #define _PYVIENNACL_VECTOR_H #include "viennacl.h" #include #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; template class cpu_compressed_matrix_wrapper { typedef ublas::compressed_matrix ublas_sparse_t; ublas_sparse_t cpu_compressed_matrix; bool _dirty; bp::list* _places; public: void update_places() { if (!_dirty) return; typedef typename ublas_sparse_t::iterator1 it1; typedef typename ublas_sparse_t::iterator2 it2; if (_places) delete _places; _places = new bp::list; for (it1 i = cpu_compressed_matrix.begin1(); i != cpu_compressed_matrix.end1(); ++i) { for (it2 j = i.begin(); j != i.end(); ++j) { if (cpu_compressed_matrix(j.index1(), j.index2())) { _places->append(bp::make_tuple(j.index1(), j.index2())); } } } _dirty = false; } bp::list places() { if (_dirty) update_places(); return *_places; } vcl::vcl_size_t nnz() { if (_dirty) update_places(); return bp::len(*_places); } cpu_compressed_matrix_wrapper() { _places = NULL; cpu_compressed_matrix = ublas_sparse_t(0,0,0); } cpu_compressed_matrix_wrapper(vcl::vcl_size_t _size1, vcl::vcl_size_t _size2) { _places = NULL; cpu_compressed_matrix = ublas_sparse_t(_size1, _size2); } cpu_compressed_matrix_wrapper(vcl::vcl_size_t _size1, vcl::vcl_size_t _size2, vcl::vcl_size_t _nnz) { _places = NULL; cpu_compressed_matrix = ublas_sparse_t(_size1, _size2, _nnz); } cpu_compressed_matrix_wrapper(const cpu_compressed_matrix_wrapper& w) : cpu_compressed_matrix(w.cpu_compressed_matrix) { _places = NULL; _dirty = true; } template cpu_compressed_matrix_wrapper(const SparseT& vcl_sparse_matrix) { cpu_compressed_matrix = ublas_sparse_t(vcl_sparse_matrix.size1(), vcl_sparse_matrix.size2()); vcl::copy(vcl_sparse_matrix, cpu_compressed_matrix); _places = NULL; _dirty = true; } cpu_compressed_matrix_wrapper(const np::ndarray& array) { _places = NULL; int d = array.get_nd(); if (d != 2) { PyErr_SetString(PyExc_TypeError, "Can only create a matrix from a 2-D array!"); bp::throw_error_already_set(); } vcl::vcl_size_t n = array.shape(0); vcl::vcl_size_t m = array.shape(1); cpu_compressed_matrix = ublas_sparse_t(n, m); for (vcl::vcl_size_t i = 0; i < n; ++i) { for (vcl::vcl_size_t j = 0; j < m; ++j) { ScalarType val = bp::extract(array[i][j]); if (val != 0) set_entry(i, j, val); } } } np::ndarray as_ndarray() { np::dtype dt = np::dtype::get_builtin(); bp::tuple shape = bp::make_tuple(size1(), size2()); np::ndarray array = np::zeros(shape, dt); typedef typename ublas_sparse_t::iterator1 it1; typedef typename ublas_sparse_t::iterator2 it2; for (it1 i = cpu_compressed_matrix.begin1(); i != cpu_compressed_matrix.end1(); ++i) { for (it2 j = i.begin(); j != i.end(); ++j) { if (cpu_compressed_matrix(j.index1(), j.index2()) != 0) { array[j.index1()][j.index2()] = get_entry(j.index1(), j.index2()); } } } return array; } template vcl::tools::shared_ptr as_vcl_sparse_matrix() { SparseT* vcl_sparse_matrix = new SparseT(); vcl::copy(cpu_compressed_matrix, *vcl_sparse_matrix); return vcl::tools::shared_ptr(vcl_sparse_matrix); } template vcl::tools::shared_ptr as_vcl_sparse_matrix_with_size() { SparseT* vcl_sparse_matrix = new SparseT(size1(), size2(), nnz()); vcl::copy(cpu_compressed_matrix, *vcl_sparse_matrix); return vcl::tools::shared_ptr(vcl_sparse_matrix); } vcl::vcl_size_t size1() const { return cpu_compressed_matrix.size1(); } vcl::vcl_size_t size2() const { return cpu_compressed_matrix.size2(); } void resize(vcl::vcl_size_t _size1, vcl::vcl_size_t _size2) { if ((_size1 == size1()) && (_size2 == size2())) return; // TODO NB: ublas compressed matrix does not support preserve on resize // so this below is annoyingly hacky... ublas_sparse_t temp(cpu_compressed_matrix); // Incurs a copy of all the data!! cpu_compressed_matrix.resize(_size1, _size2, false); // preserve == false! /* if (_places) delete _places; _places = new bp::list; */ typedef typename ublas_sparse_t::iterator1 it1; typedef typename ublas_sparse_t::iterator2 it2; for (it1 i = temp.begin1(); i != temp.end1(); ++i) { for (it2 j = i.begin(); j != i.end(); ++j) { if ((temp(j.index1(), j.index2()) != 0) && (j.index1() < _size1) && (j.index2() < _size2)) { cpu_compressed_matrix(j.index1(), j.index2()) = temp(j.index1(), j.index2()); //_places->append(bp::make_tuple(j.index1(), j.index2())); } } } _dirty = true; //false; } void set_entry(vcl::vcl_size_t n, vcl::vcl_size_t m, ScalarType val) { if (n >= size1()) { if (m >= size2()) resize(n+1, m+1); else resize(n+1, size2()); } else { if (m >= size2()) resize(size1(), m+1); } ScalarType old = cpu_compressed_matrix(n, m); if (val != old) { cpu_compressed_matrix(n, m) = val; _dirty = true; } } // Need this because bp cannot deal with operator() ScalarType get_entry(vcl::vcl_size_t n, vcl::vcl_size_t m) const { return cpu_compressed_matrix(n, m); } }; #endif pyviennacl-1.0.2+dfsg.orig/src/_viennacl/scheduler.h0000644000000000000000000001265112307335633021124 0ustar rootroot#ifndef _PYVIENNACL_VECTOR_H #define _PYVIENNACL_VECTOR_H #include "viennacl.h" #include class statement_node_wrapper { vcl::scheduler::statement::value_type vcl_node; public: statement_node_wrapper(const statement_node_wrapper& node) : vcl_node(node.vcl_node) { } statement_node_wrapper(vcl::scheduler::statement_node node) : vcl_node(node) { } statement_node_wrapper(vcl::scheduler::statement_node_type_family lhs_family, vcl::scheduler::statement_node_subtype lhs_subtype, vcl::scheduler::statement_node_numeric_type lhs_numeric_type, vcl::scheduler::operation_node_type_family op_family, vcl::scheduler::operation_node_type op_type, vcl::scheduler::statement_node_type_family rhs_family, vcl::scheduler::statement_node_subtype rhs_subtype, vcl::scheduler::statement_node_numeric_type rhs_numeric_type) { vcl_node.op.type_family = op_family; vcl_node.op.type = op_type; vcl_node.lhs.type_family = lhs_family; vcl_node.lhs.subtype = lhs_subtype; vcl_node.lhs.numeric_type = lhs_numeric_type; vcl_node.rhs.type_family = rhs_family; vcl_node.rhs.subtype = rhs_subtype; vcl_node.rhs.numeric_type = rhs_numeric_type; } vcl::scheduler::statement_node& get_vcl_statement_node() { return vcl_node; } vcl::scheduler::statement_node get_vcl_statement_node() const { return vcl_node; } #define SET_OPERAND(T, I) \ void set_operand_to_ ## I (int o, T I) { \ switch (o) { \ case 0: \ vcl_node.lhs.I = I; \ break; \ case 1: \ vcl_node.rhs.I = I; \ break; \ default: \ throw vcl::scheduler::statement_not_supported_exception \ ("Only support operands 0 or 1"); \ } \ } SET_OPERAND(std::size_t, node_index) SET_OPERAND(char, host_char) SET_OPERAND(unsigned char, host_uchar) SET_OPERAND(short, host_short) SET_OPERAND(unsigned short, host_ushort) SET_OPERAND(int, host_int) SET_OPERAND(unsigned int, host_uint) SET_OPERAND(long, host_long) SET_OPERAND(unsigned long, host_ulong) SET_OPERAND(float, host_float) SET_OPERAND(double, host_double) // NB: need to add remaining scalar types as they become available SET_OPERAND(vcl::scalar*, scalar_float) SET_OPERAND(vcl::scalar*, scalar_double) // NB: need to add remaining vector types as they become available SET_OPERAND(vcl::vector_base*, vector_float) SET_OPERAND(vcl::vector_base*, vector_double) SET_OPERAND(vcl::implicit_vector_base*, implicit_vector_float) SET_OPERAND(vcl::implicit_vector_base*, implicit_vector_double) // NB: need to add remaining matrix_row types as they become available SET_OPERAND(CONCAT(vcl::matrix_base*), matrix_row_float) SET_OPERAND(CONCAT(vcl::matrix_base*), matrix_row_double) // NB: need to add remaining matrix_col types as they become available SET_OPERAND(CONCAT(vcl::matrix_base*), matrix_col_float) SET_OPERAND(CONCAT(vcl::matrix_base*), matrix_col_double) SET_OPERAND(vcl::implicit_matrix_base*, implicit_matrix_float) SET_OPERAND(vcl::implicit_matrix_base*, implicit_matrix_double) SET_OPERAND(vcl::compressed_matrix*, compressed_matrix_float) SET_OPERAND(vcl::compressed_matrix*, compressed_matrix_double) SET_OPERAND(vcl::coordinate_matrix*, coordinate_matrix_float) SET_OPERAND(vcl::coordinate_matrix*, coordinate_matrix_double) SET_OPERAND(vcl::ell_matrix*, ell_matrix_float) SET_OPERAND(vcl::ell_matrix*, ell_matrix_double) SET_OPERAND(vcl::hyb_matrix*, hyb_matrix_float) SET_OPERAND(vcl::hyb_matrix*, hyb_matrix_double) }; #undef SET_OPERAND class statement_wrapper { typedef vcl::scheduler::statement::container_type nodes_container_t; typedef nodes_container_t::iterator nodes_iterator; typedef nodes_container_t::const_iterator nodes_const_iterator; nodes_container_t vcl_expression_nodes; public: statement_wrapper() { vcl_expression_nodes = nodes_container_t(0); } void execute() { vcl::scheduler::statement tmp_statement(vcl_expression_nodes); vcl::scheduler::execute(tmp_statement); } std::size_t size() const { return vcl_expression_nodes.size(); } void clear() { vcl_expression_nodes.clear(); } statement_node_wrapper get_node(std::size_t offset) const { return statement_node_wrapper(vcl_expression_nodes[offset]); } void erase_node(std::size_t offset) { nodes_iterator it = vcl_expression_nodes.begin(); vcl_expression_nodes.erase(it+offset); } void insert_at_index(std::size_t offset, const statement_node_wrapper& node) { nodes_iterator it = vcl_expression_nodes.begin(); vcl_expression_nodes.insert(it+offset, node.get_vcl_statement_node()); } void insert_at_begin(const statement_node_wrapper& node) { nodes_iterator it = vcl_expression_nodes.begin(); vcl_expression_nodes.insert(it, node.get_vcl_statement_node()); } void insert_at_end(const statement_node_wrapper& node) { vcl_expression_nodes.push_back(node.get_vcl_statement_node()); } }; #endif pyviennacl-1.0.2+dfsg.orig/src/_viennacl/hyb_matrix.cpp0000644000000000000000000000035012307335633021640 0ustar rootroot#include "hyb_matrix.hpp" PYVCL_SUBMODULE(hyb_matrix) { EXPORT_HYB_MATRIX(float); EXPORT_HYB_MATRIX(double); //EXPORT_HYB_MATRIX(int); //EXPORT_HYB_MATRIX(long); //EXPORT_HYB_MATRIX(uint); //EXPORT_HYB_MATRIX(long); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/vector.h0000644000000000000000000002404612307335633020451 0ustar rootroot#ifndef _PYVIENNACL_VECTOR_H #define _PYVIENNACL_VECTOR_H #include "viennacl.h" #include "entry_proxy.hpp" #include #include #include namespace ublas = boost::numeric::ublas; template struct vector_to_list_converter { static PyObject* convert(std::vector const& v) { bp::list l; for (std::size_t i = 0; i < v.size(); ++i) l.append((T)v[i]); return bp::incref(l.ptr()); } }; // TODO: Obliterate below with the above converter template bp::list std_vector_to_list(const std::vector& v) { bp::list l; for (unsigned int i = 0; i < v.size(); ++i) l.append((SCALARTYPE)v[i]); return l; } template np::ndarray std_vector_to_ndarray(const std::vector& v) { return np::from_object(std_vector_to_list(v), np::dtype::get_builtin()); } template vcl::tools::shared_ptr > std_vector_init_ndarray(const np::ndarray& array) { int d = array.get_nd(); if (d != 1) { PyErr_SetString(PyExc_TypeError, "Can only create a vector from a 1-D array!"); bp::throw_error_already_set(); } vcl::vcl_size_t s = (vcl::vcl_size_t) array.shape(0); std::vector *v = new std::vector(s); for (vcl::vcl_size_t i=0; i < s; ++i) (*v)[i] = bp::extract(array[i]); return vcl::tools::shared_ptr >(v); } template vcl::tools::shared_ptr > std_vector_init_list(const bp::list& l) { return std_vector_init_ndarray (np::from_object(l, np::dtype::get_builtin())); } template vcl::tools::shared_ptr > std_vector_init_scalar(vcl::vcl_size_t length, SCALARTYPE value) { std::vector *v = new std::vector(length); for (vcl::vcl_size_t i=0; i < length; ++i) (*v)[i] = value; return vcl::tools::shared_ptr >(v); } // Vector -- vcl::vector template bp::list vcl_vector_to_list(const vcl::vector_base& v) { std::vector c(v.size()); vcl::fast_copy(v.begin(), v.end(), c.begin()); return std_vector_to_list(c); } template np::ndarray vcl_vector_to_ndarray(const vcl::vector_base& v) { return np::from_object(vcl_vector_to_list(v), np::dtype::get_builtin()); } template vcl::tools::shared_ptr > vcl_vector_init_ndarray(const np::ndarray& array) { int d = array.get_nd(); if (d != 1) { PyErr_SetString(PyExc_TypeError, "Can only create a vector from a 1-D array!"); bp::throw_error_already_set(); } vcl::vcl_size_t s = (vcl::vcl_size_t) array.shape(0); vcl::vector *v = new vcl::vector(s); std::vector cpu_vector(s); for (vcl::vcl_size_t i=0; i < s; ++i) cpu_vector[i] = bp::extract(array[i]); vcl::fast_copy(cpu_vector.begin(), cpu_vector.end(), v->begin()); return vcl::tools::shared_ptr >(v); } template vcl::tools::shared_ptr > vcl_vector_init_list(const bp::list& l) { return vcl_vector_init_ndarray (np::from_object(l, np::dtype::get_builtin())); } template vcl::tools::shared_ptr > vcl_vector_init_scalar(vcl::vcl_size_t length, SCALARTYPE value) { ublas::scalar_vector s_v(length, value); vcl::vector *v = new vcl::vector(length); vcl::copy(s_v.begin(), s_v.end(), v->begin()); return vcl::tools::shared_ptr >(v); } template vcl::tools::shared_ptr > vcl_range(vcl::vector_base& vec, std::size_t start, std::size_t end) { vcl::range r(start, end); vcl::vector_range > *v_r = new vcl::vector_range >(vec, r); return vcl::tools::shared_ptr >(v_r); } template vcl::tools::shared_ptr > vcl_slice(vcl::vector_base& vec, std::size_t start, std::size_t stride, std::size_t size) { vcl::slice slice(start, stride, size); vcl::vector_slice > *v_s = new vcl::vector_slice >(vec, slice); return vcl::tools::shared_ptr >(v_s); } template std::vector vector_from_list(bp::list l) { std::vector v(bp::len(l)); for (std::size_t n = 0; n < bp::len(l); n++) v.push_back(bp::extract(l[n])); return v; } template bp::list list_from_vector(std::vector v) { bp::list l; for (typename std::vector::iterator it = v.begin(); it != v.end(); it++) l.append(*it); return l; } #define EXPORT_VECTOR_CLASS(TYPE) \ bp::class_, \ vcl::tools::shared_ptr > > \ ("vector_base", bp::no_init) \ .def("get_entry", &get_vcl_vector_entry >) \ .def("set_entry", &set_vcl_vector_entry >) \ .def("as_ndarray", &vcl_vector_to_ndarray) \ .def("as_list", &vcl_vector_to_list) \ .add_property("size", &vcl::vector_base::size) \ .add_property("internal_size", &vcl::vector_base::internal_size) \ .add_property("index_norm_inf", pyvcl_do_1ary_op, \ vcl::vector_base&, \ op_index_norm_inf, 0>) \ ; \ bp::class_ >, \ vcl::tools::shared_ptr > >, \ bp::bases > > \ ("vector_range", bp::no_init); \ bp::class_ >, \ vcl::tools::shared_ptr > >, \ bp::bases > > \ ("vector_slice", bp::no_init); \ bp::class_, \ vcl::tools::shared_ptr >, \ bp::bases > > \ ( "vector_" #TYPE ) \ .def(bp::init()) \ .def(bp::init >()) \ .def("__init__", bp::make_constructor(vcl_vector_init_ndarray)) \ .def("__init__", bp::make_constructor(vcl_vector_init_list)) \ .def("__init__", bp::make_constructor(vcl_vector_init_scalar))\ ; \ bp::class_, \ vcl::tools::shared_ptr > > \ ( "std_vector_" #TYPE ) \ .def(bp::init()) \ .def(bp::init >()) \ .def("__init__", bp::make_constructor(std_vector_init_ndarray)) \ .def("__init__", bp::make_constructor(std_vector_init_list)) \ .def("__init__", bp::make_constructor(std_vector_init_scalar))\ .def("as_ndarray", &std_vector_to_ndarray) \ .def("as_list", &std_vector_to_list) \ .add_property("size", &std::vector::size) \ ; \ DISAMBIGUATE_FUNCTION_PTR(CONCAT(vcl::vector_range< \ vcl::vector_base >), \ vcl::project, \ project_vector_##TYPE##_range, \ (CONCAT(vcl::vector_base&, \ const vcl::range&))) \ DISAMBIGUATE_FUNCTION_PTR(CONCAT(vcl::vector_range< \ vcl::vector_base >), \ vcl::project, \ project_vector_range_##TYPE##_range, \ (CONCAT(vcl::vector_range< \ vcl::vector_base >&, \ const vcl::range&))) \ DISAMBIGUATE_FUNCTION_PTR(CONCAT(vcl::vector_slice< \ vcl::vector_base >), \ vcl::project, \ project_vector_##TYPE##_slice, \ (CONCAT(vcl::vector_base&, \ const vcl::slice&))) \ DISAMBIGUATE_FUNCTION_PTR(CONCAT(vcl::vector_slice< \ vcl::vector_base >), \ vcl::project, \ project_vector_slice_##TYPE##_slice, \ (CONCAT(vcl::vector_slice< \ vcl::vector_base >&, \ const vcl::slice&))) \ bp::def("project_vector_" #TYPE, project_vector_##TYPE##_range); \ bp::def("project_vector_" #TYPE, project_vector_range_##TYPE##_range); \ bp::def("project_vector_" #TYPE, project_vector_##TYPE##_slice); \ bp::def("project_vector_" #TYPE, project_vector_slice_##TYPE##_slice); #endif pyviennacl-1.0.2+dfsg.orig/src/_viennacl/dense_matrix_double.cpp0000644000000000000000000000034112307335633023506 0ustar rootroot#include "dense_matrix.h" PYVCL_SUBMODULE(dense_matrix_double) { EXPORT_DENSE_MATRIX_CLASS(double, row, vcl::row_major, ublas::row_major) EXPORT_DENSE_MATRIX_CLASS(double, col, vcl::column_major, ublas::column_major) } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/scheduler.cpp0000644000000000000000000001656512307335633021467 0ustar rootroot#include "scheduler.h" PYVCL_SUBMODULE(scheduler) { #define VALUE(NS, V) .value( #V, NS :: V ) bp::enum_ ("operation_node_type_family") VALUE(vcl::scheduler, OPERATION_UNARY_TYPE_FAMILY) VALUE(vcl::scheduler, OPERATION_BINARY_TYPE_FAMILY) ; bp::enum_("operation_node_type") // unary expression VALUE(vcl::scheduler, OPERATION_UNARY_ABS_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_ACOS_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_ASIN_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_ATAN_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_CEIL_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_COS_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_COSH_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_EXP_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_FABS_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_FLOOR_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_LOG_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_LOG10_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_SIN_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_SINH_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_SQRT_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_TAN_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_TANH_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_TRANS_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_NORM_1_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_NORM_2_TYPE) VALUE(vcl::scheduler, OPERATION_UNARY_NORM_INF_TYPE) // binary expression VALUE(vcl::scheduler, OPERATION_BINARY_ACCESS_TYPE) VALUE(vcl::scheduler, OPERATION_BINARY_ASSIGN_TYPE) VALUE(vcl::scheduler, OPERATION_BINARY_INPLACE_ADD_TYPE) VALUE(vcl::scheduler, OPERATION_BINARY_INPLACE_SUB_TYPE) VALUE(vcl::scheduler, OPERATION_BINARY_ADD_TYPE) VALUE(vcl::scheduler, OPERATION_BINARY_SUB_TYPE) VALUE(vcl::scheduler, OPERATION_BINARY_MAT_VEC_PROD_TYPE) VALUE(vcl::scheduler, OPERATION_BINARY_MAT_MAT_PROD_TYPE) VALUE(vcl::scheduler, OPERATION_BINARY_MULT_TYPE)// scalar * vector/matrix VALUE(vcl::scheduler, OPERATION_BINARY_DIV_TYPE) // vector/matrix / scalar VALUE(vcl::scheduler, OPERATION_BINARY_ELEMENT_PROD_TYPE) VALUE(vcl::scheduler, OPERATION_BINARY_ELEMENT_DIV_TYPE) VALUE(vcl::scheduler, OPERATION_BINARY_INNER_PROD_TYPE) ; bp::enum_ ("statement_node_type_family") VALUE(vcl::scheduler, COMPOSITE_OPERATION_FAMILY) VALUE(vcl::scheduler, SCALAR_TYPE_FAMILY) VALUE(vcl::scheduler, VECTOR_TYPE_FAMILY) VALUE(vcl::scheduler, MATRIX_TYPE_FAMILY) ; bp::enum_ ("statement_node_subtype") VALUE(vcl::scheduler, INVALID_SUBTYPE) VALUE(vcl::scheduler, HOST_SCALAR_TYPE) VALUE(vcl::scheduler, DEVICE_SCALAR_TYPE) VALUE(vcl::scheduler, DENSE_VECTOR_TYPE) VALUE(vcl::scheduler, IMPLICIT_VECTOR_TYPE) VALUE(vcl::scheduler, DENSE_ROW_MATRIX_TYPE) VALUE(vcl::scheduler, DENSE_COL_MATRIX_TYPE) VALUE(vcl::scheduler, IMPLICIT_MATRIX_TYPE) VALUE(vcl::scheduler, COMPRESSED_MATRIX_TYPE) VALUE(vcl::scheduler, COORDINATE_MATRIX_TYPE) VALUE(vcl::scheduler, ELL_MATRIX_TYPE) VALUE(vcl::scheduler, HYB_MATRIX_TYPE) ; bp::enum_ ("statement_node_numeric_type") VALUE(vcl::scheduler, INVALID_NUMERIC_TYPE) VALUE(vcl::scheduler, CHAR_TYPE) VALUE(vcl::scheduler, UCHAR_TYPE) VALUE(vcl::scheduler, SHORT_TYPE) VALUE(vcl::scheduler, USHORT_TYPE) VALUE(vcl::scheduler, INT_TYPE) VALUE(vcl::scheduler, UINT_TYPE) VALUE(vcl::scheduler, LONG_TYPE) VALUE(vcl::scheduler, ULONG_TYPE) VALUE(vcl::scheduler, HALF_TYPE) VALUE(vcl::scheduler, FLOAT_TYPE) VALUE(vcl::scheduler, DOUBLE_TYPE) ; bp::class_("lhs_rhs_element") .def_readonly("type_family", &vcl::scheduler::lhs_rhs_element::type_family) .def_readonly("subtype", &vcl::scheduler::lhs_rhs_element::subtype) .def_readonly("numeric_type", &vcl::scheduler::lhs_rhs_element::numeric_type) ; bp::class_("op_element") .def_readonly("type_family", &vcl::scheduler::op_element::type_family) .def_readonly("type", &vcl::scheduler::op_element::type) ; bp::class_("vcl_statement_node") .def_readonly("lhs", &vcl::scheduler::statement_node::lhs) .def_readonly("rhs", &vcl::scheduler::statement_node::rhs) .def_readonly("op", &vcl::scheduler::statement_node::op) ; #define STRINGIFY(S) #S #define SET_OPERAND(I) \ .def(STRINGIFY(set_operand_to_ ## I), \ &statement_node_wrapper::set_operand_to_ ## I) DISAMBIGUATE_CLASS_FUNCTION_PTR(statement_node_wrapper, // class vcl::scheduler::statement_node, // ret. type get_vcl_statement_node, // old_name get_vcl_statement_node, // new_name () const) // args bp::class_("statement_node", bp::init()) .def(bp::init()) // rhs SET_OPERAND(node_index) SET_OPERAND(host_char) SET_OPERAND(host_uchar) SET_OPERAND(host_short) SET_OPERAND(host_ushort) SET_OPERAND(host_int) SET_OPERAND(host_uint) SET_OPERAND(host_long) SET_OPERAND(host_ulong) SET_OPERAND(host_float) SET_OPERAND(host_double) SET_OPERAND(scalar_float) SET_OPERAND(scalar_double) SET_OPERAND(vector_float) SET_OPERAND(vector_double) SET_OPERAND(implicit_vector_float) SET_OPERAND(implicit_vector_double) SET_OPERAND(matrix_row_float) SET_OPERAND(matrix_row_double) SET_OPERAND(matrix_col_float) SET_OPERAND(matrix_col_double) SET_OPERAND(implicit_matrix_float) SET_OPERAND(implicit_matrix_double) SET_OPERAND(implicit_vector_float) SET_OPERAND(implicit_vector_double) SET_OPERAND(compressed_matrix_float) SET_OPERAND(compressed_matrix_double) SET_OPERAND(coordinate_matrix_float) SET_OPERAND(coordinate_matrix_double) SET_OPERAND(ell_matrix_float) SET_OPERAND(ell_matrix_double) SET_OPERAND(hyb_matrix_float) SET_OPERAND(hyb_matrix_double) .add_property("vcl_statement_node", bp::make_function(get_vcl_statement_node, bp::return_value_policy())) ; #undef SET_OPERAND bp::class_("statement") .add_property("size", &statement_wrapper::size) .def("execute", &statement_wrapper::execute) .def("clear", &statement_wrapper::clear) .def("erase_node", &statement_wrapper::erase_node) .def("get_node", &statement_wrapper::get_node) .def("insert_at_index", &statement_wrapper::insert_at_index) .def("insert_at_begin", &statement_wrapper::insert_at_begin) .def("insert_at_end", &statement_wrapper::insert_at_end) ; } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/entry_proxy.hpp0000644000000000000000000000140512307335633022103 0ustar rootroot#ifndef _PYVIENNACL_ENTRY_PROXY_H #define _PYVIENNACL_ENTRY_PROXY_H #include "viennacl.h" #include // THIS IS NOT VERY C++ !! template SCALARTYPE get_vcl_vector_entry(VCLTYPE o, vcl::vcl_size_t x) { return o(x); } template SCALARTYPE get_vcl_matrix_entry(VCLTYPE o, vcl::vcl_size_t x, vcl::vcl_size_t y) { return o(x, y); } template bp::object set_vcl_vector_entry(VCLTYPE o, vcl::vcl_size_t x, SCALARTYPE v) { o(x) = v; return bp::object(); } template bp::object set_vcl_matrix_entry(VCLTYPE o, vcl::vcl_size_t x, vcl::vcl_size_t y, SCALARTYPE v) { o(x, y) = v; return bp::object(); } #endif pyviennacl-1.0.2+dfsg.orig/src/_viennacl/direct_solvers.hpp0000644000000000000000000001672212307335633022540 0ustar rootroot#ifndef _PYVIENNACL_DIRECT_SOLVERS_H #define _PYVIENNACL_DIRECT_SOLVERS_H #include #include #include "viennacl.h" #include "solve_op_func.hpp" #define EXPORT_MATRIX_VECTOR_SOLVERS(TYPE, F) \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, vcl::vector_base&, \ vcl::linalg::lower_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, vcl::vector_base&, \ vcl::linalg::unit_lower_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, vcl::vector_base&, \ vcl::linalg::upper_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, vcl::vector_base&, \ vcl::linalg::unit_upper_tag&, \ op_solve, 0>); #define EXPORT_DIRECT_SOLVERS(TYPE) \ EXPORT_MATRIX_VECTOR_SOLVERS(TYPE, vcl::row_major) \ EXPORT_MATRIX_VECTOR_SOLVERS(TYPE, vcl::column_major) \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::lower_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::unit_lower_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::upper_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::unit_upper_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::lower_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::unit_lower_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::upper_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::unit_upper_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::lower_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::unit_lower_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::upper_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::unit_upper_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::lower_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::unit_lower_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::upper_tag&, \ op_solve, 0>); \ bp::def("direct_solve", pyvcl_do_3ary_op, \ vcl::matrix_base&, \ vcl::matrix_base&, \ vcl::linalg::unit_upper_tag&, \ op_solve, 0>); #endif pyviennacl-1.0.2+dfsg.orig/src/_viennacl/viennacl.h0000644000000000000000000002176112307335633020747 0ustar rootroot#ifndef _PYVIENNACL_H #define _PYVIENNACL_H #include #include #include #include #include #include #include #include #include #include #define CONCAT(...) __VA_ARGS__ namespace vcl = viennacl; namespace bp = boost::python; namespace np = boost::numpy; typedef void* NoneT; typedef unsigned char uchar; typedef unsigned short ushort; typedef unsigned int uint; typedef unsigned long ulong; namespace viennacl { namespace tools { template T* get_pointer(vcl::tools::shared_ptr const& p) { return p.get(); } } } namespace boost { namespace python { template struct pointee > { typedef T type; }; } } // TODO: Use ViennaCL operation tags? enum op_t { op_add, op_sub, op_mul, op_div, op_iadd, op_isub, op_imul, op_idiv, op_inner_prod, op_outer_prod, op_element_prod, op_element_pow, op_element_div, op_norm_1, op_norm_2, op_norm_inf, op_norm_frobenius, op_index_norm_inf, op_plane_rotation, op_trans, op_prod, op_solve, op_solve_precond, op_inplace_solve }; // Generic operation dispatch class -- see specialisations below template struct pyvcl_worker { static ReturnT do_op(void* o) {} }; // This class wraps operations in a type-independent way up to 4 operands. // It's mainly used to simplify and consolidate calling conventions in the // main module code far below, but it also includes a small amount of logic // for the extraction of C++ types from Python objects where necessary. // // Ultimately, I may well do away with this, and interface with the kernel // scheduler directly. But this is a useful start to have, in order to get // a working prototype. // template struct pyvcl_op { Operand1T operand1; Operand2T operand2; Operand3T operand3; Operand4T operand4; friend struct pyvcl_worker; pyvcl_op(Operand1T opand1, Operand2T opand2, Operand3T opand3, Operand4T opand4) : operand1(opand1), operand2(opand2), operand3(opand3), operand4(opand4) { /* The value of the template variable PyObjs determines which operands need to be extracted from Python objects, by coding the operand "position" in binary. This is the object-extraction logic alluded to in the comments above. So, given (as an example) PyObjs == 7 == 0111b, and given that we number operands from left to right, the following operands need extraction: operand2, operand3, and operand4. */ /* if (PyObjs & 8) { operand1 = static_cast (bp::extract((bp::api::object)opand1)); } if (PyObjs & 4) { operand2 = static_cast (bp::extract((bp::api::object)opand2)); } if (PyObjs & 2) { operand3 = static_cast (bp::extract((bp::api::object)opand3)); } if (PyObjs & 1) { operand4 = static_cast (bp::extract((bp::api::object)opand4)); } //*/ } // Should I just use operator(), I wonder.. ReturnT do_op() { return pyvcl_worker::do_op(*this); } }; // Convenient operation dispatch functions. // These functions make setting up and calling the pyvcl_op class much // simpler for the specific 1-, 2-, 3- and 4-operand cases. template ReturnT pyvcl_do_1ary_op(Operand1T a) { pyvcl_op o (a, NULL, NULL, NULL); return o.do_op(); } template ReturnT pyvcl_do_2ary_op(Operand1T a, Operand2T b) { pyvcl_op o (a, b, NULL, NULL); return o.do_op(); } template ReturnT pyvcl_do_3ary_op(Operand1T a, Operand2T b, Operand3T c) { pyvcl_op o (a, b, c, NULL); return o.do_op(); } template ReturnT pyvcl_do_4ary_op(Operand1T a, Operand2T b, Operand3T c, Operand4T d) { pyvcl_op o (a, b, c, d); return o.do_op(); } /***************************** Operation wrapper functions *****************************/ // These macros define specialisations of the pyvcl_worker class // which is used to dispatch viennacl operations. #define OP_TEMPLATE template #define PYVCL_WORKER_STRUCT(OP) OP_TEMPLATE \ struct pyvcl_worker #define DO_OP_FUNC(OP) PYVCL_WORKER_STRUCT(OP) { \ static ReturnT do_op(pyvcl_op& o) // And the actual operations follow below. DO_OP_FUNC(op_add) { return o.operand1 + o.operand2; } }; DO_OP_FUNC(op_sub) { return o.operand1 - o.operand2; } }; DO_OP_FUNC(op_mul) { return o.operand1 * o.operand2; } }; DO_OP_FUNC(op_div) { return o.operand1 / o.operand2; } }; DO_OP_FUNC(op_inner_prod) { return vcl::linalg::inner_prod(o.operand1, o.operand2); } }; DO_OP_FUNC(op_outer_prod) { return vcl::linalg::outer_prod(o.operand1, o.operand2); } }; DO_OP_FUNC(op_element_prod) { return vcl::linalg::element_prod(o.operand1, o.operand2); } }; DO_OP_FUNC(op_element_pow) { return vcl::linalg::element_pow(o.operand1, o.operand2); } }; DO_OP_FUNC(op_element_div) { return vcl::linalg::element_div(o.operand1, o.operand2); } }; DO_OP_FUNC(op_iadd) { o.operand1 += o.operand2; return o.operand1; } }; DO_OP_FUNC(op_isub) { o.operand1 -= o.operand2; return o.operand1; } }; DO_OP_FUNC(op_imul) { o.operand1 *= o.operand2; return o.operand1; } }; DO_OP_FUNC(op_idiv) { o.operand1 /= o.operand2; return o.operand1; } }; DO_OP_FUNC(op_norm_1) { return vcl::linalg::norm_1(o.operand1); } }; DO_OP_FUNC(op_norm_2) { return vcl::linalg::norm_2(o.operand1); } }; DO_OP_FUNC(op_norm_inf) { return vcl::linalg::norm_inf(o.operand1); } }; DO_OP_FUNC(op_norm_frobenius) { return vcl::linalg::norm_frobenius(o.operand1); } }; DO_OP_FUNC(op_index_norm_inf) { return vcl::linalg::index_norm_inf(o.operand1); } }; DO_OP_FUNC(op_plane_rotation) { vcl::linalg::plane_rotation(o.operand1, o.operand2, o.operand3, o.operand4); return bp::object(); } }; DO_OP_FUNC(op_trans) { return vcl::trans(o.operand1); } }; DO_OP_FUNC(op_prod) { return vcl::linalg::prod(o.operand1, o.operand2); } }; /** @brief Returns a double describing the VCL_T */ template HostT vcl_scalar_to_host(const vcl::scalar& vcl_s) { HostT cpu_s = vcl_s; return cpu_s; } #define DISAMBIGUATE_FUNCTION_PTR(RET, OLD_NAME, NEW_NAME, ARGS) \ RET (*NEW_NAME) ARGS = &OLD_NAME; #define DISAMBIGUATE_CLASS_FUNCTION_PTR(CLASS, RET, OLD_NAME, NEW_NAME, ARGS)\ RET (CLASS::*NEW_NAME) ARGS = &CLASS::OLD_NAME; /************** Submodules **************/ #define PYVCL_SUBMODULE(NAME) void export_ ## NAME () PYVCL_SUBMODULE(vector_int); PYVCL_SUBMODULE(vector_long); PYVCL_SUBMODULE(vector_uint); PYVCL_SUBMODULE(vector_ulong); PYVCL_SUBMODULE(vector_float); PYVCL_SUBMODULE(vector_double); PYVCL_SUBMODULE(dense_matrix_int); PYVCL_SUBMODULE(dense_matrix_long); PYVCL_SUBMODULE(dense_matrix_uint); PYVCL_SUBMODULE(dense_matrix_ulong); PYVCL_SUBMODULE(dense_matrix_float); PYVCL_SUBMODULE(dense_matrix_double); PYVCL_SUBMODULE(compressed_matrix); PYVCL_SUBMODULE(coordinate_matrix); PYVCL_SUBMODULE(ell_matrix); PYVCL_SUBMODULE(hyb_matrix); PYVCL_SUBMODULE(direct_solvers); PYVCL_SUBMODULE(iterative_solvers); PYVCL_SUBMODULE(eig); PYVCL_SUBMODULE(extra_functions); PYVCL_SUBMODULE(scheduler); PYVCL_SUBMODULE(opencl_support); #endif pyviennacl-1.0.2+dfsg.orig/src/_viennacl/extra_functions.cpp0000644000000000000000000000524012307335633022710 0ustar rootroot#include "viennacl.h" #define EXPORT_FUNCTIONS_F(TYPE, F) \ bp::def("outer", pyvcl_do_2ary_op, \ vcl::vector_base&, vcl::vector_base&, \ op_outer_prod, 0>); \ bp::def("element_pow", pyvcl_do_2ary_op, \ vcl::matrix_base&, vcl::matrix_base&, \ op_element_pow, 0>); \ bp::def("norm_frobenius", pyvcl_do_1ary_op, \ vcl::matrix&, \ op_norm_frobenius, 0>); #define EXPORT_FUNCTIONS(TYPE) \ EXPORT_FUNCTIONS_F(TYPE, vcl::row_major); \ EXPORT_FUNCTIONS_F(TYPE, vcl::column_major); \ bp::def("inner_prod", pyvcl_do_2ary_op, \ vcl::vector_base&, vcl::vector_base&, \ op_inner_prod, 0>); \ bp::def("element_pow", pyvcl_do_2ary_op, \ vcl::vector_base&, vcl::vector_base&, \ op_element_pow, 0>); \ bp::def("plane_rotation", pyvcl_do_4ary_op&, vcl::vector_base&, \ TYPE, TYPE, \ op_plane_rotation, 0>); \ bp::def("norm_1", pyvcl_do_1ary_op, \ vcl::vector_base&, \ op_norm_1, 0>); \ bp::def("norm_2", pyvcl_do_1ary_op, \ vcl::vector_base&, \ op_norm_2, 0>); \ bp::def("norm_inf", pyvcl_do_1ary_op, \ vcl::vector_base&, \ op_norm_inf, 0>); PYVCL_SUBMODULE(extra_functions) { /* TODO missing: char, short, uchar, ushort Some of these only make compile on Windows for float types -- eg norm_2, which tries to do a sqrt on a long without converting it to some float type. EXPORT_FUNCTIONS(int); EXPORT_FUNCTIONS(long); EXPORT_FUNCTIONS(uint); EXPORT_FUNCTIONS(ulong); */ EXPORT_FUNCTIONS(double); EXPORT_FUNCTIONS(float); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/direct_solvers.cpp0000644000000000000000000000040112307335633022516 0ustar rootroot#include "direct_solvers.hpp" PYVCL_SUBMODULE(direct_solvers) { EXPORT_DIRECT_SOLVERS(float); EXPORT_DIRECT_SOLVERS(double); EXPORT_DIRECT_SOLVERS(int); EXPORT_DIRECT_SOLVERS(uint); EXPORT_DIRECT_SOLVERS(long); EXPORT_DIRECT_SOLVERS(ulong); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/ell_matrix.hpp0000644000000000000000000000245612307335633021650 0ustar rootroot#ifndef _PYVIENNACL_ELL_MATRIX_H #define _PYVIENNACL_ELL_MATRIX_H #include "sparse_matrix.h" #define EXPORT_ELL_MATRIX(TYPE) \ bp::class_, \ vcl::tools::shared_ptr >, \ boost::noncopyable > \ ("ell_matrix", bp::no_init) \ .add_property("size1", \ make_function(&vcl::ell_matrix::size1, \ bp::return_value_policy())) \ .add_property("size2", \ make_function(&vcl::ell_matrix::size2, \ bp::return_value_policy())) \ .add_property("nnz", \ make_function(&vcl::ell_matrix::nnz, \ bp::return_value_policy())) \ .def("prod", pyvcl_do_2ary_op, \ vcl::ell_matrix&, vcl::vector&, \ op_prod, 0>) \ ; #endif pyviennacl-1.0.2+dfsg.orig/src/_viennacl/dense_matrix.h0000644000000000000000000002110712307335633021624 0ustar rootroot#ifndef _PYVIENNACL_DENSE_MATRIX_H #define _PYVIENNACL_DENSE_MATRIX_H #include "viennacl.h" #include "entry_proxy.hpp" #include #include #include namespace ublas = boost::numeric::ublas; template class ndarray_wrapper { const np::ndarray array; // TODO: Perhaps reference to the wrapped ndarray public: ndarray_wrapper(const np::ndarray& a) : array(a) { } vcl::vcl_size_t size1() const { return array.shape(0); } vcl::vcl_size_t size2() const { return array.shape(1); } ScalarT operator()(vcl::vcl_size_t row, vcl::vcl_size_t col) const { return bp::extract(array[row][col]); } }; template vcl::tools::shared_ptr > matrix_init_scalar(vcl::vcl_size_t n, vcl::vcl_size_t m, SCALARTYPE value) { ublas::scalar_matrix s_m(n, m, value); ublas::matrix cpu_m(s_m); vcl::matrix* mat = new vcl::matrix(n, m); vcl::copy(cpu_m, (*mat)); return vcl::tools::shared_ptr >(mat); } /** @brief Creates the matrix from the supplied ndarray */ template vcl::tools::shared_ptr > matrix_init_ndarray(const np::ndarray& array) { int d = array.get_nd(); if (d != 2) { PyErr_SetString(PyExc_TypeError, "Can only create a matrix from a 2-D array!"); bp::throw_error_already_set(); } ndarray_wrapper wrapper(array); vcl::matrix* mat = new vcl::matrix(wrapper.size1(), wrapper.size2()); vcl::copy(wrapper, (*mat)); return vcl::tools::shared_ptr >(mat); } template bp::tuple get_strides(const vcl::matrix_base& m) { return bp::make_tuple((m.stride1()*m.internal_size2())*sizeof(SCALARTYPE), m.stride2()*sizeof(SCALARTYPE)); } template bp::tuple get_strides(const vcl::matrix_base& m) { return bp::make_tuple(m.stride1()*sizeof(SCALARTYPE), m.stride2()*m.internal_size1()*sizeof(SCALARTYPE)); } template std::size_t get_offset(const vcl::matrix_base& m) { return m.start1()*m.internal_size2() + m.start2(); } template std::size_t get_offset(const vcl::matrix_base& m) { return m.start1() + m.start2()*m.internal_size1(); } template np::ndarray vcl_matrix_to_ndarray(const vcl::matrix_base& m) { std::size_t size = m.internal_size1() * m.internal_size2() * sizeof(SCALARTYPE); SCALARTYPE* data = (SCALARTYPE*)malloc(size); vcl::backend::finish(); // Read the whole matrix vcl::backend::memory_read(m.handle(), 0, size, data); np::dtype dt = np::dtype::get_builtin(); bp::tuple shape = bp::make_tuple(m.size1(), m.size2()); // Delegate determination of strides and start offset to function templates bp::tuple strides = get_strides(m); np::ndarray array = np::from_data(data + get_offset(m), dt, shape, strides, bp::object(m)); //std::cout << "NDARRAY_TEST:\n" // << bp::extract(bp::str(array)) // << std::endl; return array; } #define EXPORT_DENSE_MATRIX_CLASS(TYPE, LAYOUT, F, CPU_F) \ bp::class_, \ vcl::tools::shared_ptr > > \ ("matrix_base", bp::no_init) \ .def("get_entry", &get_vcl_matrix_entry >) \ .def("set_entry", &set_vcl_matrix_entry >) \ .def("as_ndarray", &vcl_matrix_to_ndarray) \ .add_property("size1", &vcl::matrix_base::size1) \ .add_property("internal_size1", \ &vcl::matrix_base::internal_size1) \ .add_property("size2", &vcl::matrix_base::size2) \ .add_property("internal_size2", \ &vcl::matrix_base::internal_size2) \ .add_property("trans", pyvcl_do_1ary_op, \ vcl::matrix_base&, \ op_trans, 0>) \ ; \ bp::class_ >, \ vcl::tools::shared_ptr > >, \ bp::bases > > \ ("matrix_range", bp::no_init); \ bp::class_ >, \ vcl::tools::shared_ptr > >, \ bp::bases > > \ ("matrix_slice", bp::no_init); \ bp::class_, \ vcl::tools::shared_ptr >, \ bp::bases > > \ ( "matrix_" #LAYOUT "_" #TYPE ) \ .def(bp::init >()) \ .def(bp::init()) \ .def("__init__", bp::make_constructor(matrix_init_ndarray))\ .def("__init__", bp::make_constructor(matrix_init_scalar)) \ ; \ DISAMBIGUATE_FUNCTION_PTR(CONCAT(vcl::matrix_range< \ vcl::matrix_base >), \ vcl::project, \ project_matrix_##TYPE##_##LAYOUT##_range_range, \ (CONCAT(vcl::matrix_base&, \ const vcl::range&, \ const vcl::range&))) \ DISAMBIGUATE_FUNCTION_PTR(CONCAT(vcl::matrix_range< \ vcl::matrix_base >), \ vcl::project, \ project_matrix_range_##TYPE##_##LAYOUT##_range_range, \ (CONCAT(vcl::matrix_range< \ vcl::matrix_base >&, \ const vcl::range&, \ const vcl::range&))) \ DISAMBIGUATE_FUNCTION_PTR(CONCAT(vcl::matrix_slice< \ vcl::matrix_base >), \ vcl::project, \ project_matrix_##TYPE##_##LAYOUT##_slice_slice, \ (CONCAT(vcl::matrix_base&, \ const vcl::slice&, \ const vcl::slice&))) \ DISAMBIGUATE_FUNCTION_PTR(CONCAT(vcl::matrix_slice< \ vcl::matrix_base >), \ vcl::project, \ project_matrix_slice_##TYPE##_##LAYOUT##_slice_slice, \ (CONCAT(vcl::matrix_slice< \ vcl::matrix_base >&, \ const vcl::slice&, \ const vcl::slice&))) \ bp::def("project_matrix_" #TYPE, project_matrix_##TYPE##_##LAYOUT##_range_range); \ bp::def("project_matrix_" #TYPE, project_matrix_range_##TYPE##_##LAYOUT##_range_range); \ bp::def("project_matrix_" #TYPE, project_matrix_##TYPE##_##LAYOUT##_slice_slice); \ bp::def("project_matrix_" #TYPE, project_matrix_slice_##TYPE##_##LAYOUT##_slice_slice); #endif pyviennacl-1.0.2+dfsg.orig/src/_viennacl/coordinate_matrix.hpp0000644000000000000000000000411412307335633023214 0ustar rootroot#ifndef _PYVIENNACL_COORDINATE_MATRIX_H #define _PYVIENNACL_COORDINATE_MATRIX_H #include "sparse_matrix.h" #define EXPORT_COORDINATE_MATRIX(TYPE) \ bp::class_, \ vcl::tools::shared_ptr >, \ boost::noncopyable > \ ("coordinate_matrix_" #TYPE, bp::no_init) \ .add_property("size1", \ make_function(&vcl::coordinate_matrix::size1, \ bp::return_value_policy())) \ .add_property("size2", \ make_function(&vcl::coordinate_matrix::size2, \ bp::return_value_policy())) \ .add_property("nnz", \ make_function(&vcl::coordinate_matrix::nnz, \ bp::return_value_policy())) \ .def("prod", pyvcl_do_2ary_op, \ vcl::coordinate_matrix&, vcl::vector&, \ op_prod, 0>) \ ; /* .def("inplace_solve", pyvcl_do_3ary_op, vcl::coordinate_matrix&, vcl::vector&, vcl::linalg::lower_tag, op_inplace_solve, 0>) .def("inplace_solve", pyvcl_do_3ary_op, vcl::coordinate_matrix&, vcl::vector&, vcl::linalg::unit_lower_tag, op_inplace_solve, 0>) .def("inplace_solve", pyvcl_do_3ary_op, vcl::coordinate_matrix&, vcl::vector&, vcl::linalg::unit_upper_tag, op_inplace_solve, 0>) .def("inplace_solve", pyvcl_do_3ary_op, vcl::coordinate_matrix&, vcl::vector&, vcl::linalg::upper_tag, op_inplace_solve, 0>)*/ #endif pyviennacl-1.0.2+dfsg.orig/src/_viennacl/iterative_solvers.cpp0000644000000000000000000000070412307335633023246 0ustar rootroot#include "iterative_solvers.hpp" PYVCL_SUBMODULE(iterative_solvers) { /* EXPORT_DENSE_ITERATIVE_SOLVERS(float); EXPORT_DENSE_ITERATIVE_SOLVERS(double); /...* These don't really make sense: EXPORT_DENSE_ITERATIVE_SOLVERS(int); EXPORT_DENSE_ITERATIVE_SOLVERS(uint); EXPORT_DENSE_ITERATIVE_SOLVERS(long); EXPORT_DENSE_ITERATIVE_SOLVERS(ulong); */ EXPORT_SPARSE_ITERATIVE_SOLVERS(float); EXPORT_SPARSE_ITERATIVE_SOLVERS(double); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/dense_matrix_ulong.cpp0000644000000000000000000000033612307335633023364 0ustar rootroot#include "dense_matrix.h" PYVCL_SUBMODULE(dense_matrix_ulong) { EXPORT_DENSE_MATRIX_CLASS(ulong, row, vcl::row_major, ublas::row_major) EXPORT_DENSE_MATRIX_CLASS(ulong, col, vcl::column_major, ublas::column_major) } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/dense_matrix_uint.cpp0000644000000000000000000000033312307335633023214 0ustar rootroot#include "dense_matrix.h" PYVCL_SUBMODULE(dense_matrix_uint) { EXPORT_DENSE_MATRIX_CLASS(uint, row, vcl::row_major, ublas::row_major) EXPORT_DENSE_MATRIX_CLASS(uint, col, vcl::column_major, ublas::column_major) } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/vector_int.cpp0000644000000000000000000000012212307335633021643 0ustar rootroot#include "vector.h" PYVCL_SUBMODULE(vector_int) { EXPORT_VECTOR_CLASS(int); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/solve_op_func.hpp0000644000000000000000000000134112307335633022341 0ustar rootroot#ifndef _PYVIENNACL_SOLVE_OP_FUNC_H #define _PYVIENNACL_SOLVE_OP_FUNC_H #include "viennacl.h" DO_OP_FUNC(op_solve) { ReturnT r = vcl::linalg::solve(o.operand1, o.operand2, o.operand3); //std::cout << "???????????????????????????? 1: " << o.operand1 << std::endl << std::endl; //std::cout << "???????????????????????????? 2: " << o.operand2 << std::endl << std::endl; //printf("??? %f\n", r(0)); return r; } }; DO_OP_FUNC(op_solve_precond) { return vcl::linalg::solve(o.operand1, o.operand2, o.operand3, o.operand4); } }; DO_OP_FUNC(op_inplace_solve) { vcl::linalg::inplace_solve(o.operand1, o.operand2, o.operand3); return o.operand1; } }; #endif pyviennacl-1.0.2+dfsg.orig/src/_viennacl/ell_matrix.cpp0000644000000000000000000000035012307335633021632 0ustar rootroot#include "ell_matrix.hpp" PYVCL_SUBMODULE(ell_matrix) { EXPORT_ELL_MATRIX(float); EXPORT_ELL_MATRIX(double); //EXPORT_ELL_MATRIX(int); //EXPORT_ELL_MATRIX(long); //EXPORT_ELL_MATRIX(uint); //EXPORT_ELL_MATRIX(long); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/hyb_matrix.hpp0000644000000000000000000000213512307335633021650 0ustar rootroot#ifndef _PYVIENNACL_HYB_MATRIX_H #define _PYVIENNACL_HYB_MATRIX_H #include "sparse_matrix.h" #define EXPORT_HYB_MATRIX(TYPE) \ bp::class_, \ vcl::tools::shared_ptr >, \ boost::noncopyable > \ ("hyb_matrix", bp::no_init) \ .add_property("size1", \ make_function(&vcl::hyb_matrix::size1, \ bp::return_value_policy())) \ .add_property("size2", \ make_function(&vcl::hyb_matrix::size2, \ bp::return_value_policy())) \ .def("prod", pyvcl_do_2ary_op, \ vcl::hyb_matrix&, vcl::vector&, \ op_prod, 0>) \ ; #endif pyviennacl-1.0.2+dfsg.orig/src/_viennacl/vector_double.cpp0000644000000000000000000000013012307335633022322 0ustar rootroot#include "vector.h" PYVCL_SUBMODULE(vector_double) { EXPORT_VECTOR_CLASS(double); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/dense_matrix_float.cpp0000644000000000000000000000033612307335633023345 0ustar rootroot#include "dense_matrix.h" PYVCL_SUBMODULE(dense_matrix_float) { EXPORT_DENSE_MATRIX_CLASS(float, row, vcl::row_major, ublas::row_major) EXPORT_DENSE_MATRIX_CLASS(float, col, vcl::column_major, ublas::column_major) } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/vector_float.cpp0000644000000000000000000000012612307335633022162 0ustar rootroot#include "vector.h" PYVCL_SUBMODULE(vector_float) { EXPORT_VECTOR_CLASS(float); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/coordinate_matrix.cpp0000644000000000000000000000044012307335633023205 0ustar rootroot#include "coordinate_matrix.hpp" PYVCL_SUBMODULE(coordinate_matrix) { EXPORT_COORDINATE_MATRIX(float); EXPORT_COORDINATE_MATRIX(double); //EXPORT_COORDINATE_MATRIX(int); //EXPORT_COORDINATE_MATRIX(long); //EXPORT_COORDINATE_MATRIX(uint); //EXPORT_COORDINATE_MATRIX(long); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/eig.cpp0000644000000000000000000002163012317236144020240 0ustar rootroot#include "viennacl.h" #include "sparse_matrix.h" #include #include PYVCL_SUBMODULE(eig) { // Tag class definitions DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::linalg::power_iter_tag, double, factor, get_power_iter_factor, () const) DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::linalg::power_iter_tag, std::size_t, max_iterations, get_power_iter_max_iterations, () const) bp::class_("power_iter_tag") .def(bp::init()) .add_property("factor", get_power_iter_factor) .add_property("max_iterations", get_power_iter_max_iterations) ; DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::linalg::lanczos_tag, std::size_t, num_eigenvalues, get_lanczos_num_eigenvalues, () const) DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::linalg::lanczos_tag, double, factor, get_lanczos_factor, () const) DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::linalg::lanczos_tag, std::size_t, krylov_size, get_lanczos_krylov_size, () const) DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::linalg::lanczos_tag, int, method, get_lanczos_method, () const) bp::class_("lanczos_tag") .def(bp::init()) .add_property("num_eigenvalues", get_lanczos_num_eigenvalues) .add_property("factor", get_lanczos_factor) .add_property("krylov_size", get_lanczos_krylov_size) .add_property("method", get_lanczos_method) ; // Dense matrices DISAMBIGUATE_FUNCTION_PTR(double, vcl::linalg::eig,eig_power_iter_double_row, (const vcl::matrix&, const vcl::linalg::power_iter_tag&)) bp::def("eig", eig_power_iter_double_row); DISAMBIGUATE_FUNCTION_PTR(float, vcl::linalg::eig,eig_power_iter_float_row, (const vcl::matrix&, const vcl::linalg::power_iter_tag&)) bp::def("eig", eig_power_iter_float_row); DISAMBIGUATE_FUNCTION_PTR(double, vcl::linalg::eig,eig_power_iter_double_col, (const vcl::matrix&, const vcl::linalg::power_iter_tag&)) bp::def("eig", eig_power_iter_double_col); DISAMBIGUATE_FUNCTION_PTR(float, vcl::linalg::eig,eig_power_iter_float_col, (const vcl::matrix&, const vcl::linalg::power_iter_tag&)) bp::def("eig", eig_power_iter_float_col); DISAMBIGUATE_FUNCTION_PTR(std::vector, vcl::linalg::eig, eig_lanczos_vector_double_row, (const vcl::matrix&, const vcl::linalg::lanczos_tag&)) bp::def("eig", eig_lanczos_vector_double_row); DISAMBIGUATE_FUNCTION_PTR(std::vector, vcl::linalg::eig, eig_lanczos_vector_float_row, (const vcl::matrix&, const vcl::linalg::lanczos_tag&)) bp::def("eig", eig_lanczos_vector_float_row); DISAMBIGUATE_FUNCTION_PTR(std::vector, vcl::linalg::eig, eig_lanczos_vector_double_col, (const vcl::matrix&, const vcl::linalg::lanczos_tag&)) bp::def("eig", eig_lanczos_vector_double_col); DISAMBIGUATE_FUNCTION_PTR(std::vector, vcl::linalg::eig, eig_lanczos_vector_float_col, (const vcl::matrix&, const vcl::linalg::lanczos_tag&)) bp::def("eig", eig_lanczos_vector_float_col); // Sparse matrices -- Lanczos DISAMBIGUATE_FUNCTION_PTR(std::vector, vcl::linalg::eig, eig_lanczos_vector_double_compressed, (const vcl::compressed_matrix&, const vcl::linalg::lanczos_tag&)) bp::def("eig", eig_lanczos_vector_double_compressed); DISAMBIGUATE_FUNCTION_PTR(std::vector, vcl::linalg::eig, eig_lanczos_vector_float_compressed, (const vcl::compressed_matrix&, const vcl::linalg::lanczos_tag&)) bp::def("eig", eig_lanczos_vector_float_compressed); DISAMBIGUATE_FUNCTION_PTR(std::vector, vcl::linalg::eig, eig_lanczos_vector_double_coordinate, (const vcl::coordinate_matrix&, const vcl::linalg::lanczos_tag&)) bp::def("eig", eig_lanczos_vector_double_coordinate); DISAMBIGUATE_FUNCTION_PTR(std::vector, vcl::linalg::eig, eig_lanczos_vector_float_coordinate, (const vcl::coordinate_matrix&, const vcl::linalg::lanczos_tag&)) bp::def("eig", eig_lanczos_vector_float_coordinate); /* DISAMBIGUATE_FUNCTION_PTR(std::vector, vcl::linalg::eig, eig_lanczos_vector_double_ell, (const vcl::ell_matrix&, const vcl::linalg::lanczos_tag&)) bp::def("eig", eig_lanczos_vector_double_ell); DISAMBIGUATE_FUNCTION_PTR(std::vector, vcl::linalg::eig, eig_lanczos_vector_float_ell, (const vcl::ell_matrix&, const vcl::linalg::lanczos_tag&)) bp::def("eig", eig_lanczos_vector_float_ell); DISAMBIGUATE_FUNCTION_PTR(std::vector, vcl::linalg::eig, eig_lanczos_vector_double_hyb, (const vcl::hyb_matrix&, const vcl::linalg::lanczos_tag&)) bp::def("eig", eig_lanczos_vector_double_hyb); DISAMBIGUATE_FUNCTION_PTR(std::vector, vcl::linalg::eig, eig_lanczos_vector_float_hyb, (const vcl::hyb_matrix&, const vcl::linalg::lanczos_tag&)) bp::def("eig", eig_lanczos_vector_float_hyb); */ // Sparse matrices -- power_iter DISAMBIGUATE_FUNCTION_PTR(double, vcl::linalg::eig, eig_power_iter_double_compressed, (const vcl::compressed_matrix&, const vcl::linalg::power_iter_tag&)) bp::def("eig", eig_power_iter_double_compressed); DISAMBIGUATE_FUNCTION_PTR(float, vcl::linalg::eig, eig_power_iter_float_compressed, (const vcl::compressed_matrix&, const vcl::linalg::power_iter_tag&)) bp::def("eig", eig_power_iter_float_compressed); DISAMBIGUATE_FUNCTION_PTR(double, vcl::linalg::eig, eig_power_iter_double_coordinate, (const vcl::coordinate_matrix&, const vcl::linalg::power_iter_tag&)) bp::def("eig", eig_power_iter_double_coordinate); DISAMBIGUATE_FUNCTION_PTR(float, vcl::linalg::eig, eig_power_iter_float_coordinate, (const vcl::coordinate_matrix&, const vcl::linalg::power_iter_tag&)) bp::def("eig", eig_power_iter_float_coordinate); /* DISAMBIGUATE_FUNCTION_PTR(double, vcl::linalg::eig, eig_power_iter_double_ell, (const vcl::ell_matrix&, const vcl::linalg::power_iter_tag&)) bp::def("eig", eig_power_iter_double_ell); DISAMBIGUATE_FUNCTION_PTR(float, vcl::linalg::eig, eig_power_iter_float_ell, (const vcl::ell_matrix&, const vcl::linalg::power_iter_tag&)) bp::def("eig", eig_power_iter_float_ell); DISAMBIGUATE_FUNCTION_PTR(double, vcl::linalg::eig, eig_power_iter_double_hyb, (const vcl::hyb_matrix&, const vcl::linalg::power_iter_tag&)) bp::def("eig", eig_power_iter_double_hyb); DISAMBIGUATE_FUNCTION_PTR(float, vcl::linalg::eig, eig_power_iter_float_hyb, (const vcl::hyb_matrix&, const vcl::linalg::power_iter_tag&)) bp::def("eig", eig_power_iter_float_hyb); */ } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/vector_long.cpp0000644000000000000000000000012412307335633022012 0ustar rootroot#include "vector.h" PYVCL_SUBMODULE(vector_long) { EXPORT_VECTOR_CLASS(long); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/compressed_matrix.cpp0000644000000000000000000000044012307335633023222 0ustar rootroot#include "compressed_matrix.hpp" PYVCL_SUBMODULE(compressed_matrix) { EXPORT_COMPRESSED_MATRIX(float); EXPORT_COMPRESSED_MATRIX(double); //EXPORT_COMPRESSED_MATRIX(int); //EXPORT_COMPRESSED_MATRIX(long); //EXPORT_COMPRESSED_MATRIX(uint); //EXPORT_COMPRESSED_MATRIX(long); } pyviennacl-1.0.2+dfsg.orig/src/_viennacl/core.cpp0000644000000000000000000001110212307335633020417 0ustar rootroot#include #include #include "viennacl.h" #include #include #include #include /******************************* Python module initialisation *******************************/ void translate_string_exception(const char* e) { // Use the Python 'C' API to set up an exception object PyErr_SetString(PyExc_RuntimeError, e); } BOOST_PYTHON_MODULE(_viennacl) { // specify that this module is actually a package bp::object package = bp::scope(); package.attr("__path__") = "_viennacl"; bp::register_exception_translator (&translate_string_exception); np::initialize(); // TODO: integrate version into build process bp::scope().attr("__version__") = bp::object("1.5.1"); bp::def("backend_finish", vcl::backend::finish); #define EXPORT_SCALAR_CLASS(TYPE) \ bp::class_ >("scalar_" #TYPE) \ .def(bp::init()) \ .def(bp::init >()) \ .def("to_host", &vcl_scalar_to_host) EXPORT_SCALAR_CLASS(int); EXPORT_SCALAR_CLASS(uint); EXPORT_SCALAR_CLASS(long); EXPORT_SCALAR_CLASS(ulong); EXPORT_SCALAR_CLASS(float); EXPORT_SCALAR_CLASS(double); bp::class_("range", bp::init()); bp::class_("slice", bp::init()); bp::class_("lower_tag"); bp::class_("unit_lower_tag"); bp::class_("upper_tag"); bp::class_("unit_upper_tag"); DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::linalg::cg_tag, unsigned int, iters, get_cg_iters, () const) DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::linalg::cg_tag, double, error, get_cg_error, () const) bp::class_("cg_tag") .def(bp::init()) .add_property("tolerance", &vcl::linalg::cg_tag::tolerance) .add_property("max_iterations", &vcl::linalg::cg_tag::max_iterations) .add_property("iters", get_cg_iters) .add_property("error", get_cg_error) ; DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::linalg::bicgstab_tag, vcl::vcl_size_t, iters, get_bicgstab_iters, () const) DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::linalg::bicgstab_tag, double, error, get_bicgstab_error, () const) bp::class_("bicgstab_tag") .def(bp::init()) .add_property("tolerance", &vcl::linalg::bicgstab_tag::tolerance) .add_property("max_iterations", &vcl::linalg::bicgstab_tag::max_iterations) .add_property("max_iterations_before_restart", &vcl::linalg::bicgstab_tag::max_iterations_before_restart) .add_property("iters", get_bicgstab_iters) .add_property("error", get_bicgstab_error) ; DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::linalg::gmres_tag, unsigned int, iters, get_gmres_iters, () const) DISAMBIGUATE_CLASS_FUNCTION_PTR(vcl::linalg::gmres_tag, double, error, get_gmres_error, () const) bp::class_("gmres_tag") .def(bp::init()) .add_property("tolerance", &vcl::linalg::gmres_tag::tolerance) .add_property("max_iterations", &vcl::linalg::gmres_tag::max_iterations) .add_property("iters", get_gmres_iters) .add_property("error", get_gmres_error) .add_property("krylov_dim", &vcl::linalg::gmres_tag::krylov_dim) .add_property("max_restarts", &vcl::linalg::gmres_tag::max_restarts) ; bp::class_("no_precond"); export_vector_int(); export_vector_long(); export_vector_uint(); export_vector_ulong(); export_vector_float(); export_vector_double(); export_dense_matrix_int(); export_dense_matrix_long(); export_dense_matrix_uint(); export_dense_matrix_ulong(); export_dense_matrix_float(); export_dense_matrix_double(); export_compressed_matrix(); export_coordinate_matrix(); export_ell_matrix(); export_hyb_matrix(); export_direct_solvers(); export_iterative_solvers(); export_eig(); export_extra_functions(); export_scheduler(); export_opencl_support(); } pyviennacl-1.0.2+dfsg.orig/doc/0000755000000000000000000000000012332260014014774 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/doc/linalg.rst0000644000000000000000000000013512307335633017007 0ustar rootrootlinalg ------ .. toctree:: :maxdepth: 2 .. automodule:: pyviennacl.linalg :members: pyviennacl-1.0.2+dfsg.orig/doc/build-doc.py0000644000000000000000000000014512307335633017224 0ustar rootrootimport sys from sphinx import main sys.exit(main(['sphinx-build_pyviennacl', 'doc', 'build/doc'])) pyviennacl-1.0.2+dfsg.orig/doc/make.bat0000644000000000000000000001176012307335633016422 0ustar rootroot@ECHO OFF REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set BUILDDIR=_build set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% . set I18NSPHINXOPTS=%SPHINXOPTS% . if NOT "%PAPER%" == "" ( set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS% ) if "%1" == "" goto help if "%1" == "help" ( :help echo.Please use `make ^` where ^ is one of echo. html to make standalone HTML files echo. dirhtml to make HTML files named index.html in directories echo. singlehtml to make a single large HTML file echo. pickle to make pickle files echo. json to make JSON files echo. htmlhelp to make HTML files and a HTML help project echo. qthelp to make HTML files and a qthelp project echo. devhelp to make HTML files and a Devhelp project echo. epub to make an epub echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter echo. text to make text files echo. man to make manual pages echo. texinfo to make Texinfo files echo. gettext to make PO message catalogs echo. changes to make an overview over all changed/added/deprecated items echo. linkcheck to check all external links for integrity echo. doctest to run all doctests embedded in the documentation if enabled goto end ) if "%1" == "clean" ( for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i del /q /s %BUILDDIR%\* goto end ) if "%1" == "html" ( %SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/html. goto end ) if "%1" == "dirhtml" ( %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml. goto end ) if "%1" == "singlehtml" ( %SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml. goto end ) if "%1" == "pickle" ( %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the pickle files. goto end ) if "%1" == "json" ( %SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the JSON files. goto end ) if "%1" == "htmlhelp" ( %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run HTML Help Workshop with the ^ .hhp project file in %BUILDDIR%/htmlhelp. goto end ) if "%1" == "qthelp" ( %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run "qcollectiongenerator" with the ^ .qhcp project file in %BUILDDIR%/qthelp, like this: echo.^> qcollectiongenerator %BUILDDIR%\qthelp\PyViennaCL.qhcp echo.To view the help file: echo.^> assistant -collectionFile %BUILDDIR%\qthelp\PyViennaCL.ghc goto end ) if "%1" == "devhelp" ( %SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp if errorlevel 1 exit /b 1 echo. echo.Build finished. goto end ) if "%1" == "epub" ( %SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub if errorlevel 1 exit /b 1 echo. echo.Build finished. The epub file is in %BUILDDIR%/epub. goto end ) if "%1" == "latex" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex if errorlevel 1 exit /b 1 echo. echo.Build finished; the LaTeX files are in %BUILDDIR%/latex. goto end ) if "%1" == "text" ( %SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text if errorlevel 1 exit /b 1 echo. echo.Build finished. The text files are in %BUILDDIR%/text. goto end ) if "%1" == "man" ( %SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man if errorlevel 1 exit /b 1 echo. echo.Build finished. The manual pages are in %BUILDDIR%/man. goto end ) if "%1" == "texinfo" ( %SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo if errorlevel 1 exit /b 1 echo. echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo. goto end ) if "%1" == "gettext" ( %SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale if errorlevel 1 exit /b 1 echo. echo.Build finished. The message catalogs are in %BUILDDIR%/locale. goto end ) if "%1" == "changes" ( %SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes if errorlevel 1 exit /b 1 echo. echo.The overview file is in %BUILDDIR%/changes. goto end ) if "%1" == "linkcheck" ( %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck if errorlevel 1 exit /b 1 echo. echo.Link check complete; look for any errors in the above output ^ or in %BUILDDIR%/linkcheck/output.txt. goto end ) if "%1" == "doctest" ( %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest if errorlevel 1 exit /b 1 echo. echo.Testing of doctests in the sources finished, look at the ^ results in %BUILDDIR%/doctest/output.txt. goto end ) :end pyviennacl-1.0.2+dfsg.orig/doc/Makefile0000644000000000000000000001271412307335633016455 0ustar rootroot# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: -rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/PyViennaCL.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/PyViennaCL.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/PyViennaCL" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/PyViennaCL" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." pyviennacl-1.0.2+dfsg.orig/doc/pycore.rst0000644000000000000000000000026512307335633017046 0ustar rootroot.. py:currentmodule:: pycore pycore ------ .. comment .. .autosummary:: .:toctree: generated/ . .pyviennacl.pycore.Matrix .. automodule:: pyviennacl.pycore :members: pyviennacl-1.0.2+dfsg.orig/doc/examples/0000755000000000000000000000000012332260014016612 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/doc/examples/basics.rst0000644000000000000000000000014512307335633020624 0ustar rootrootPyViennaCL Basics ================= .. literalinclude:: /../examples/basics.py :language: python pyviennacl-1.0.2+dfsg.orig/doc/examples/sparse-matrices.rst0000644000000000000000000000015212307335633022460 0ustar rootrootSparse matrices =============== .. literalinclude:: /../examples/sparse-matrices.py :language: python pyviennacl-1.0.2+dfsg.orig/doc/examples/products.rst0000644000000000000000000000015112307335633021220 0ustar rootrootComputing products ================== .. literalinclude:: /../examples/products.py :language: python pyviennacl-1.0.2+dfsg.orig/doc/examples/index.rst0000644000000000000000000000031612307335633020467 0ustar rootrootPyViennaCL Example Code ======================= .. toctree:: :maxdepth: 1 basics.rst products.rst slices-and-proxies.rst sparse-matrices.rst iterative-solvers.rst direct-solvers.rst pyviennacl-1.0.2+dfsg.orig/doc/examples/slices-and-proxies.rst0000644000000000000000000000021512307335633023067 0ustar rootrootSubmatrices: slices and proxies =============================== .. literalinclude:: /../examples/slices-and-proxies.py :language: python pyviennacl-1.0.2+dfsg.orig/doc/examples/direct-solvers.rst0000644000000000000000000000014712307335633022327 0ustar rootrootDirect solvers ============== .. literalinclude:: /../examples/direct-solvers.py :language: python pyviennacl-1.0.2+dfsg.orig/doc/examples/iterative-solvers.rst0000644000000000000000000000016012307335633023044 0ustar rootrootIterative solvers ================= .. literalinclude:: /../examples/iterative-solvers.py :language: python pyviennacl-1.0.2+dfsg.orig/doc/vclmath.rst0000644000000000000000000000014012307335633017173 0ustar rootrootvclmath ------- .. toctree:: :maxdepth: 2 .. automodule:: pyviennacl.vclmath :members: pyviennacl-1.0.2+dfsg.orig/doc/util.rst0000644000000000000000000000012712307335633016517 0ustar rootrootutil ---- .. toctree:: :maxdepth: 2 .. automodule:: pyviennacl.util :members: pyviennacl-1.0.2+dfsg.orig/doc/index.rst0000644000000000000000000000072612307335633016656 0ustar rootroot.. PyViennaCL documentation master file, created by sphinx-quickstart on Tue Sep 17 16:16:55 2013. You can adapt this file completely to your liking, but it should at least contain the root `toctree` directive. .. .. py:module:: pyviennacl .. automodule:: pyviennacl :members: Usage examples ============== .. toctree:: :maxdepth: 2 examples/index.rst Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` pyviennacl-1.0.2+dfsg.orig/doc/conf.py0000644000000000000000000002102612307373177016315 0ustar rootroot# -*- coding: utf-8 -*- # # PyViennaCL documentation build configuration file, created by # sphinx-quickstart on Tue Sep 17 16:16:55 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 sys, os # 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. import distutils.command.build from distutils.dist import Distribution b = distutils.command.build.build(Distribution()) b.initialize_options() b.finalize_options() # TODO: Python 3 support (for Debian's pybuild) try: pyvcl_path = os.path.abspath(os.path.join("..", b.build_platlib)) sys.path.insert(0, pyvcl_path) import pyviennacl except: sys.path.pop(0) try: pyvcl_path = os.path.abspath("..") sys.path.insert(0, pyvcl_path) import pyviennacl except: sys.path.pop(0) # -- 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.doctest', #'sphinx.ext.intersphinx', #'sphinx.ext.coverage', #'sphinx.ext.pngmath', #'sphinx.ext.mathjax', #'sphinx.ext.viewcode'] # 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-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = u'PyViennaCL' copyright = u'2013-2014, Toby St Clere Smithe' # 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 = from pyviennacl import __version__ as version # The full version, including alpha/beta/rc tags. release = version # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # 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 patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_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 = [] # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'default' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #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 = '' # 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 = 'PyViennaCLdoc' # -- 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': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [ ('index', 'PyViennaCL.tex', u'PyViennaCL Documentation', u'Toby St Clere Smithe', '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 = False # 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', 'pyviennacl', u'PyViennaCL Documentation', [u'Toby St Clere Smithe'], 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', 'PyViennaCL', u'PyViennaCL Documentation', u'Toby St Clere Smithe', 'PyViennaCL', 'One line description of project.', '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' # Example configuration for intersphinx: refer to the Python standard library. intersphinx_mapping = {'http://docs.python.org/': None} pyviennacl-1.0.2+dfsg.orig/configure.py0000755000000000000000000000013312307335633016576 0ustar rootroot#! /usr/bin/env python from aksetup_helper import configure_frontend configure_frontend() pyviennacl-1.0.2+dfsg.orig/examples/0000755000000000000000000000000012332260014016045 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/examples/slices-and-proxies.py0000644000000000000000000000225112307335633022144 0ustar rootroot#!python """ PyViennaCL allows you to access and manipulate submatrices and subvectors using the usual Pythonic apparatus of slices and ranges of objects. ViennaCL provides object proxies to allow us to do these sub-manipulations in place. Here, we give some basic examples. """ import pyviennacl as p import numpy as np # Create some small, simple Vector and Matrix instances x = p.Vector(6, 1.0) a = p.Matrix(6, 6, 1.0) print("x is %s" % x) print("a is\n%s" % a) # Scale the first half of the Vector x x[0:3] *= 2.0 # Show the new x print("x is now %s" % x) # Create a smaller matrix from a submatrix of a b = a[3:6, 3:6] * 4.0 # Set the upper-left corner of the matrix to 4.0s a[0:3, 0:3] = b # Show the new a print("a is now\n%s" % a) # Represent an operation on a b = p.sqrt(a) # Manipulate submatrices of b b[0:3, 3:6] += b[0:3, 0:3] b[3:6, 3:6] += b[0:3, 3:6] # Show b print("b is\n%s" % b) # We can also manipulate slices of matrices and of submatrices c = b[0:6, 2:6] c[0:6:2, 0:4:2] = c[0:6:2, 0:4:2] * 10.0 # Show b after the proxy update via c print("b is now\n%s" % b) # We can do similarly for vectors x[0:6:2] = x[3:6] * 10.0 # Show x print("x is now %s" % x) pyviennacl-1.0.2+dfsg.orig/examples/util.py0000644000000000000000000000222312307335633017407 0ustar rootrootimport pyviennacl as p def read_mtx(fname, dtype): """ Read a MatrixMarket file. Assume coordinate format, and double precision. Very crude! """ fd = open(fname) lines = map(lambda x: x.strip().split(" "), fd.readlines()) ln = -1 for line in lines: ln += 1 if line[ln][0] == "%": continue else: break n = int(lines[ln][0]) m = int(lines[ln][1]) nnz = int(lines[ln][2]) mat = p.CompressedMatrix(n, m, nnz, dtype=dtype) mat_type = p.np_result_type(mat).type def assign(l): try: i, j, v = int(l[0]), int(l[1]), mat_type(l[2]) mat[i-1, j-1] = v except ValueError: pass map(assign, lines[ln+1:]) return mat def read_vector(fname, dtype): fd = open(fname) lines = map(lambda x: x.strip().split(" "), fd.readlines()) count = int(lines[0][0]) vector = list(map(lambda x: p.np_result_type(dtype).type(x), lines[1])) vector = p.Vector(vector, dtype = dtype) if vector.size != count: raise Exception("Sizes %d and %d do not match!" % (vector.size, count)) return vector pyviennacl-1.0.2+dfsg.orig/examples/products.py0000644000000000000000000000475712307335633020313 0ustar rootroot#!python """ The overloading of the * operator in PyViennaCL is not directly compatible with the usage in NumPy. In PyViennaCL, given the emphasis on linear algebra, we have attempted to make the usage of * as natural as possible. The semantics are as follows: * Scalar * scalar -> scalar; * scalar * vector -> scaled vector; * scalar * matrix -> scaled matrix; * vector * vector -> undefined; * vector * matrix -> undefined; * matrix * vector -> matrix-vector product; * matrix * matrix -> matrix-matrix product. Of course, there exist other products in some cases, which is why the * operator is sometimes undefined. For instance, in the case of `vector * vector`, we could have either a dot product, an outer product, a cross product, or an elementwise product. The cross product is not currently implemented in PyViennaCL, but this still leaves three cases from which to choose. Here, we demonstrate the different notation for these products. """ import pyviennacl as p import numpy as np # Let's construct some random 1-D and 2-D arrays v = np.random.rand(5) w = np.random.rand(5) f = np.random.rand(5, 5) g = np.random.rand(5, 5) # Now transfer them to the compute device x, y = p.Vector(v), p.Vector(w) a, b = p.Matrix(f), p.Matrix(g) print("a is\n%s" % a) print("b is\n%s" % b) print("x is %s" % x) print("y is %s" % y) # # Scaling # # Represent the scaling of x by 2.0 z = x * 2.0 # Compute and print the result print("x * 2.0 = %s" % z) # Represent the scaling of a by 2.0 c = a * 2.0 # Compute and print the result print("a * 2.0 =\n%s" % c) # # Vector products # # Represent the dot product of x and y d = x.dot(y) # or p.dot(x, y) # Compute the dot product and print it print("Dot product of x and y is %s" % d) # Represent the elementwise product of x and y z = x.element_prod(y) # or x.element_mul(y) # Compute and print the result print("Elementwise product of x and y is %s" % z) # Represent the outer product of x and y c = x.outer(y) # Compute and print the result print("Outer product of x and y:\n%s" % c) # # Matrix and matrix-vector products # # Represent the elementwise product of a and b c = a.element_prod(b) # or a.elementwise_mul(b) # Compute and print the result print("Elementwise product of a and b:\n%s" % c) # Represent the matrix product of a and b c = a * b # Compute and print the result print("Matrix product of a and b:\n%s" % c) # Represent the matrix-vector product of a and x c = a * x # Compute and print the result print("Matrix-vector product of a and x:\n%s" % c) pyviennacl-1.0.2+dfsg.orig/examples/direct-solvers.py0000644000000000000000000000256412307335633021407 0ustar rootroot#!python """ PyViennaCL provides direct solvers for dense triangular linear systems. The API is documented in ``help(pyviennacl.linalg.solve)``. In particular, the solver to use is determined by the tag instance supplied to the ``solve`` function. LU factorisation is planned for a later release. Here, we demonstrate the use of the direct triangular solver for an upper triangular system; other forms and solvers are supported by the choice of a different solver tag class. """ import pyviennacl as p import numpy as np import random # We want a square N x N system. N = 5 # Create a NumPy matrix with float32 precision to hold the data on the host. # Firstly, we create an empty matrix, then fill the upper triangle with values. A = np.zeros((N, N), dtype = np.float32) for i in range(N): for j in range(N): if j >= i: A[i, j] = np.float32(random.randint(0,1000) / 100.0) # Transfer the system matrix to the compute device A = p.Matrix(A) print("A is\n%s" % A) # Create a right-hand-side vector on the host with random elements # and transfer it to the compute device b = p.Vector(np.random.rand(N).astype(np.float32)) print("b is %s" % b) # Solve the system; note the choice of tag to denote an upper triangular system x = p.solve(A, b, p.upper_tag()) # Copy the solution from the device to host and display it print("Solution of Ax = b for x:\n%s" % x) pyviennacl-1.0.2+dfsg.orig/examples/basics.py0000644000000000000000000000610712307335633017703 0ustar rootroot#!python """ In this example, we investigate the construction and basic usage of PyViennaCL's dense matrix (Matrix) and Vector types, and discuss some important issues about integration with Python and NumPy data types, and PyViennaCL's computational architecture. If you are familiar with NumPy, you might need about 5 minutes to grasp the content here. If you are not so familiar, you might need 10 minutes. """ # Import PyViennaCL and NumPy import pyviennacl as p import numpy as np # Create our datastructures on the host x = [1.0, 2.0, 3.0, 4.0, 5.0] # We can create PyViennaCL Vectors from lists a = np.array([[1.0, 2.0, 3.0], [0.0, 3.0, 4.0], [0.0, 0.0, 5.0]]) # We can create PyViennaCL Matrices from arrays # Create corresponding ViennaCL datastructures on the compute device y = p.Vector(x) b = p.Matrix(a) # This is a dense matrix # Copy the data back to the host and check that it's equal z = y.value # z is now a 1-D numpy array with dtype float64 c = b.value # c is now a 2-D numpy array with dtype float64 if (z == x).all() and (c == a).all(): print("Successfully transferred data to and from the compute device!") # We can modify elements of the ViennaCL device structures, but since this # incurs a compute kernel initialisation and buffer transfer, it is very slow! y[0] = 0.0 b[2, 2] = -1.0 x[0] = 0.0 # We should also modify our original data to keep track.. a[2, 2] = -1.0 # And we can do comparisons seamlessly between NumPy and PyViennaCL types! if (a == b).all() and (x == y).all(): print("Successfully modified data structures on host and device!") # We also need to be sure that we are consistent with respect to the data-types # we use. For instance, we should not mix integer and floating point types. # # By default, PyViennaCL objects inherit the dtype of the objects from which # they are created, or (if that is ambiguous), float64. print("a and b have dtypes of %s and %s" % (np.result_type(a), np.result_type(b))) # PyViennaCL makes an effort to convert objects to the appropriate dtype where # dtypes have been mixed, but this is often ambiguous and unpredictable, and # so it is recommended that users make efforts to keep they dtypes consistent. i = 1L # Create a long integer print("i has dtype of %s" % (np.result_type(i))) y[0] = i # Remember, this sort of elementwise assignation is *very slow*! print("y has values %s and dtype %s" % (y, np.result_type(y))) # And, of course, we can perform basic arithemetic operations with PyViennaCL, # mixing native Python types with NumPy and PyViennaCL types: z = (x + y + z) / 2.0 print("z is now of type %s, dtype %s, and with values %s" % (type(z), np.result_type(z), z)) # Notice that z has `Div' type. This is because the z object represents the # arithmetic expression `(x + y + z) / 2.0', and this is only computed when # the result is needed, in order to maximise performance. # And we can do less basic arithmetic! print("The sine of the values of z is %s" % p.sin(z)) # PyViennaCL exposes many elementwise mathematical functions. # See help(p.math) for more information. pyviennacl-1.0.2+dfsg.orig/examples/sparse-matrices.py0000644000000000000000000000272412307335633021542 0ustar rootroot#!python """ Sparse matrix support is still limited in PyViennaCL. The construction of spare matrices from host data is supported, as is sparse matrix-vector multiplication and the use of iterative solvers (see iterative-solvers.py in this directory). However, no other operations have yet been implemented, and SciPy support is rudimentary. Here, we demonstrate the construction of a CompressedMatrix instance, and the calculation of a matrix-vector product. Other sparse matrix formats are available, such as the CoordinateMatrix, ELLMatrix and HybridMatrix. They are constructed and used identically to the CompressedMatrix type. """ import pyviennacl as p import random # First, we create an empty 5 x 5 CompressedMatrix: A = p.CompressedMatrix(5, 5) # Let's set some random values of A. # # Importantly, setting individual elements of a PyViennaCL sparse matrix is # not nearly as expensive as setting individual elements of a dense matrix or # vector, since in the sparse matrix case, the elements are cached on the host # and only transferred to the device when they are needed for some computation. for i in range(6): x = random.randrange(0, 4, 1) y = random.randrange(0, 4, 1) A[x, y] = random.random() print("A is:\n%s" % A.value) # Now, let's construct a simple vector of 5 elements. b = p.Vector(5, 3.142) print("b is %s" % b) # Now, represent the product: c = A * b # And the result is only computed when we need to print it: print("A * b = c is %s" % c) pyviennacl-1.0.2+dfsg.orig/examples/README0000644000000000000000000000127212307335633016743 0ustar rootrootThis directory contains examples for how to use PyViennaCL. Read them! The comments are very explanatory :-) If you need more example code, the tests (under ../tests) cover the full PyViennaCL API, and so provide examples of that usage, even if the tests are somewhat contrived. Otherwise, the next best thing is the in-built documentation >>> import pyviennacl >>> help(pyviennacl) which is also built into HTML documentation using the Sphinx system, and should be located in build/doc (if you built the sources yourself); otherwise, if you are on a Debian or Ubuntu system, look in /usr/share/doc/pyviennacl-doc. Finally, if you are still struggling, then play around or read the source! pyviennacl-1.0.2+dfsg.orig/examples/iterative-solvers.py0000644000000000000000000000231112307335633022117 0ustar rootroot#!python """ PyViennaCL provides iterative solvers for sparse and dense linear systems. The API is documented in ``help(pyviennacl.linalg.solve)``. In particular, the solver to use is determined by the tag instance supplied to the ``solve`` function. The iterative solvers have various parameters for tuning the error tolerance, and various requirements for the form of the system matrix, as described in the documentation for the corresponding tag classes. For this reason, we only demonstrate here the use of the GMRES solver for a general system. """ import pyviennacl as p import numpy as np import os, random from util import read_mtx, read_vector A = read_mtx(os.path.join(os.path.dirname(os.path.realpath(__file__)), "mat65k.mtx"), dtype=np.float32) print("Loaded system matrix") b = read_vector(os.path.join(os.path.dirname(os.path.realpath(__file__)), "rhs65025.txt"), dtype=np.float32) print("Loaded RHS vector") # Construct the tag to denote the GMRES solver tag = p.gmres_tag(tolerance = 1e-5, max_iterations = 150, krylov_dim = 50) # Solve the system x = p.solve(A, b, tag) # Show some info print("Num. iterations: %s" % tag.iters) print("Estimated error: %s" % tag.error) pyviennacl-1.0.2+dfsg.orig/tests/0000755000000000000000000000000012332260016015373 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/tests/matrix_operations.py0000644000000000000000000002742612307335633021541 0ustar rootroot#!/usr/bin/env python import math import numpy as np import os import pyviennacl as p import sys from test_common import diff, test_matrix_layout, test_matrix_slice #TODO: Change print statements to log statements def run_test(*args, **kwargs): """ A, A_trans, B, B_trans must be numpy array or matrix instances """ epsilon = args[0] A = args[1] A_trans = args[2] B = args[3] B_trans = args[4] C = args[5] vcl_A = args[6] vcl_A_trans = args[7] vcl_B = args[8] vcl_B_trans = args[9] vcl_C = args[10] dtype = kwargs['dtype'] alpha = p.Scalar(dtype(3.1415)) beta = p.HostScalar(dtype(2.718)) # Test initialisers # + GPU scalar TODO #X = p.Matrix(A.shape, alpha) #if not (X == (np.ones(A.shape, dtype = dtype) * alpha.value)).all(): # raise RuntimeError("Failed: GPU scalar matrix init") #print("Test: initialisation of matrix with GPU scalar passed") # + CPU scalar TODO Y = p.Matrix(A.shape, beta.value) # TODO if not (Y == (np.ones(A.shape, dtype = dtype) * beta.value)).all(): raise RuntimeError("Failed: CPU scalar matrix init") print("Test: initialisation of matrix with CPU scalar passed") # + ndarray X = p.Matrix(np.ones(A.shape, dtype = dtype) * beta.value) if not (X == (np.ones(A.shape, dtype = dtype) * beta.value)).all(): raise RuntimeError("Failed: ndarray matrix init") print("Test: initialisation of matrix with ndarray passed") # + Matrix X = p.Matrix(Y) if not (X == Y).all(): raise RuntimeError("Failed: Matrix Matrix init") print("Test: initialisation of matrix with Matrix passed") # + CompressedMatrix -- TODO: sparse matrices + dtypes #Y = p.CompressedMatrix(X) #X = p.Matrix(Y) #if not (X == Y).all(): # raise RuntimeError("Failed: Matrix CompressedMatrix init") #print("Test: initialisation of matrix with CompressedMatrix passed") # In-place add X = vcl_A.value X += vcl_B.value vcl_A += vcl_B if not (vcl_A == X).all(): raise RuntimeError("Failed: in-place add") print("Test: in-place add passed") # Scaled in-place add X += alpha.value * vcl_B.value vcl_A += alpha * vcl_B if not (vcl_A == X).all(): raise RuntimeError("Failed: scaled in-place add") print("Test: scaled in-place add passed") # Add Y = vcl_A.value + vcl_B.value Z = vcl_A + vcl_B if not (Y == Z).all(): raise RuntimeError("Failed: add") print("Test: add passed") # Scaled add (left) Y = dtype(alpha.value) * vcl_B.value + vcl_C.value Z = alpha * vcl_B + vcl_C act_diff = math.fabs(diff(Y, Z)) if act_diff > epsilon: raise RuntimeError("Failed: scaled add (left)") print("Test: scaled add (left) passed") # Scaled add (right) Y = vcl_B.value + dtype(alpha.value) * vcl_C.value Z = vcl_B + alpha * vcl_C act_diff = math.fabs(diff(Y, Z)) if act_diff > epsilon: # (Z == Y).all(): raise RuntimeError("Failed: scaled add (left)") print("Test: scaled add (right) passed") # Scaled add (both) Y = alpha.value * vcl_B.value + alpha.value * vcl_C.value Z = alpha * vcl_B + alpha * vcl_C act_diff = math.fabs(diff(Y, Z)) if act_diff > epsilon: raise RuntimeError("Failed: scaled add (both)") print("Test: scaled add (both) passed") # In-place sub X = vcl_A.value X -= vcl_B.value vcl_A -= vcl_B if not (vcl_A == X).all(): raise RuntimeError("Failed: in-place sub") print("Test: in-place sub passed") # Scaled in-place sub X -= alpha.value * vcl_B.value vcl_A -= alpha * vcl_B if not (vcl_A == X).all(): raise RuntimeError("Failed: scaled in-place sub") print("Test: scaled in-place sub passed") # Sub Y = vcl_A.value - vcl_B.value Z = vcl_A - vcl_B if not (Y == Z).all(): raise RuntimeError("Failed: sub") print("Test: sub passed") # Scaled sub (left) Y = alpha.value * vcl_B.value - vcl_C.value Z = alpha * vcl_B - vcl_C act_diff = math.fabs(diff(Y, Z)) if act_diff > epsilon: raise RuntimeError("Failed: scaled sub (left)") print("Test: scaled sub (left) passed") # Scaled sub (right) Y = vcl_B.value - alpha.value * vcl_C.value Z = vcl_B - alpha * vcl_C act_diff = math.fabs(diff(Y, Z)) if act_diff > epsilon: raise RuntimeError("Failed: scaled sub (right)") print("Test: scaled sub (right) passed") # Scaled sub (both) Y = alpha.value * vcl_B.value - alpha.value * vcl_C.value Z = alpha * vcl_B - alpha * vcl_C act_diff = math.fabs(diff(Y, Z)) if act_diff > epsilon: raise RuntimeError("Failed: scaled sub (both)") print("Test: scaled sub (both) passed") # Scalar multiplication (CPU scalar) -- not supported yet #gamma_py = beta.value * beta.value #gamma_vcl = beta * beta # ... # Scalar multiplication (GPU scalar) # Matrix-vector multiplication vec = p.Vector(vcl_A.shape[0], 3.1415, dtype = dtype) X = vcl_A * vec Y = vcl_A.value.dot(vec.value) act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: matrix-vector multiplication") print("Test: matrix-vector multiplication passed") # Matrix divided by scalar X = vcl_A.value / alpha.value Y = vcl_A / alpha act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: matrix-scalar division") print("Test: matrix-scalar division passed") # Binary elementwise operations -- prod and div X = vcl_A.value * vcl_B.value Y = p.ElementProd(vcl_A, vcl_B) act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise matrix-matrix multiplication") print("Test: elementwise matrix-matrix multiplication passed") X = vcl_A.value ** vcl_B.value Y = vcl_A ** vcl_B act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise matrix-matrix exponentiation") print("Test: elementwise matrix-matrix exponentiation passed") X = vcl_A.value / vcl_B.value Y = p.ElementDiv(vcl_A, vcl_B) act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise matrix-matrix division") print("Test: elementwise matrix-matrix division passed") # Unary elementwise operations # - abs TODO #X = abs(vcl_A.value) #Y = p.ElementAbs(vcl_A) #act_diff = math.fabs(diff(X, Y)) #if act_diff > epsilon: # raise RuntimeError("Failed: elementwise abs") #print("Test: elementwise abs passed") # - acos X = np.arccos(vcl_A.value) Y = p.ElementAcos(vcl_A).result # TODO THIS SHOULDN'T BE REQUIRED act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise acos") print("Test: elementwise acos passed") # - asin X = np.arcsin(vcl_A.value) Y = p.ElementAsin(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise asin") print("Test: elementwise asin passed") # - atan X = np.arctan(vcl_A.value) Y = p.ElementAtan(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise atan") print("Test: elementwise atan passed") # - ceil X = np.ceil(vcl_A.value) Y = p.ElementCeil(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise ceil") print("Test: elementwise ceil passed") # - cos X = np.cos(vcl_A.value) Y = p.ElementCos(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise cos") print("Test: elementwise cos passed") # - cosh X = np.cosh(vcl_A.value) Y = p.ElementCosh(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise cosh") print("Test: elementwise cosh passed") # - exp X = np.exp(vcl_A.value) Y = p.ElementExp(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise exp") print("Test: elementwise exp passed") # - fabs X = np.fabs(vcl_A.value) Y = p.ElementFabs(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise fabs") print("Test: elementwise fabs passed") # - floor X = np.floor(vcl_A.value) Y = p.ElementFloor(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise floor") print("Test: elementwise floor passed") # - log X = np.log(vcl_A.value) Y = p.ElementLog(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise log") print("Test: elementwise log passed") # - log10 X = np.log10(vcl_A.value) Y = p.ElementLog10(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise log10") print("Test: elementwise log10 passed") # - sin X = np.sin(vcl_A.value) Y = p.ElementSin(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise sin") print("Test: elementwise sin passed") # - sinh X = np.sinh(vcl_A.value) Y = p.ElementSinh(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise sinh") print("Test: elementwise sinh passed") # - sqrt X = np.sqrt(vcl_A.value) Y = p.ElementSqrt(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise sqrt") print("Test: elementwise sqrt passed") # - tan X = np.tan(vcl_A.value) Y = p.ElementTan(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise tan") print("Test: elementwise tan passed") # - tanh X = np.tanh(vcl_A.value) Y = p.ElementTanh(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise tanh") print("Test: elementwise tanh passed") # - trans TODO ?!!! #X = vcl_A.value.T #Y = vcl_A.T.result #p.Trans(vcl_A).result #act_diff = math.fabs(diff(X, Y)) #if act_diff > epsilon: # raise RuntimeError("Failed: elementwise trans") #print("Test: elementwise trans passed") # - norm1 -- TODO ONLY FOR VECTORS # - norm2 -- TODO ONLY FOR VECTORS # - norm_inf -- TODO ONLY FOR VECTORS return os.EX_OK def test(): print("----------------------------------------------") print("----------------------------------------------") print("## Test :: BLAS 3 routines") print("----------------------------------------------") print("----------------------------------------------") print() print("----------------------------------------------") print("--- Part 1: Testing matrix-matrix products ---") print("*** Using float numeric type ***") print("# Testing setup:") epsilon = 1.0E-3 print(" eps: %s" % epsilon) test_matrix_layout(test_matrix_slice, run_test, epsilon, p.float32, 11, 11, 11) print("*** Using double numeric type ***") print("# Testing setup:") epsilon = 1.0E-11 print(" eps: %s" % epsilon) test_matrix_layout(test_matrix_slice, run_test, epsilon, p.float64, 11, 11, 11) print("# Test passed") return os.EX_OK if __name__ == "__main__": sys.exit(test()) pyviennacl-1.0.2+dfsg.orig/tests/vector_operations.py0000644000000000000000000003404012307335633021525 0ustar rootroot#!/usr/bin/env python import math import numpy as np import os import pyviennacl as p import sys from test_common import diff, test_vector_slice #TODO: Change print statements to log statements def run_test(*args, **kwargs): """ A and B must be numpy array or matrix instances with one dimension """ epsilon = args[0] A = args[1] B = args[2] C = args[3] vcl_A = args[4] vcl_B = args[5] vcl_C = args[6] dtype = np.result_type(kwargs['dtype']).type alpha = p.Scalar(dtype(3.1415)) ## TODO SHOULD BE GPU SCALAR beta = p.HostScalar(dtype(2.718)) ### ### TODO MISSING: ### + cpu / gpu combos ### + elementwise power function? ### # Test initialisers # + GPU scalar TODO #X = p.Vector(A.shape, alpha) #if not (X == (np.ones(A.shape, dtype = dtype) * alpha.value)).all(): # raise RuntimeError("Failed: GPU scalar vector init") #print("Test: initialisation of vector with GPU scalar passed") # + CPU scalar TODO Y = p.Vector(A.shape[0], beta.value) # TODO if not (Y == (np.ones(A.shape, dtype = dtype) * beta.value)).all(): raise RuntimeError("Failed: CPU scalar vector init") print("Test: initialisation of vector with CPU scalar passed") # + ndarray X = p.Vector(np.ones(A.shape, dtype = dtype) * beta.value) if not (X == (np.ones(A.shape, dtype = dtype) * beta.value)).all(): raise RuntimeError("Failed: ndarray vector init") print("Test: initialisation of vector with ndarray passed") # + Vector X = p.Vector(Y) if not (X == Y).all(): raise RuntimeError("Failed: Vector Vector init") print("Test: initialisation of vector with Vector passed") # Negation X = -vcl_A Y = -vcl_A.value act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: negation") print("Test: negation passed") # Inner product X = vcl_A.dot(vcl_B) Y = vcl_A.value.dot(vcl_B.value) act_diff = math.fabs(X - Y) if act_diff > 0.01: # NB: numpy seems to be imprecise here raise RuntimeError("Failed: inner product of vectors") print("Test: inner product of vectors passed") # In-place scaling (multiplication by scalar) X = vcl_A.value X *= beta.value vcl_A *= beta act_diff = math.fabs(diff(X, vcl_A)) if act_diff > epsilon: raise RuntimeError("Failed: in-place scale (multiplication)") print("Test: in-place scale (multiplication) passed") # In-place scaling (division by scalar) X = vcl_A.value X /= alpha.value vcl_A /= alpha act_diff = math.fabs(diff(X, vcl_A)) if act_diff > epsilon: raise RuntimeError("Failed: in-place scale (division)") print("Test: in-place scale (division) passed") # In-place add X = vcl_A.value X += vcl_B.value vcl_A += vcl_B act_diff = math.fabs(diff(X, vcl_A)) if act_diff > epsilon: raise RuntimeError("Failed: in-place add") print("Test: in-place add passed") # Scaled in-place add X += alpha.value * vcl_B.value vcl_A += alpha * vcl_B act_diff = math.fabs(diff(X, vcl_A)) if act_diff > epsilon: raise RuntimeError("Failed: scaled in-place add") print("Test: scaled in-place add passed") # Add Y = vcl_A.value + vcl_B.value Z = vcl_A + vcl_B act_diff = math.fabs(diff(Y, Z)) if act_diff > epsilon: raise RuntimeError("Failed: add") print("Test: add passed") # Scaled add (left) Y = dtype(alpha.value) * vcl_B.value + vcl_C.value Z = alpha * vcl_B + vcl_C act_diff = math.fabs(diff(Y, Z)) if act_diff > epsilon: print(act_diff) print(Y, type(Y)) print(Z, type(Z)) print(Z - Y) raise RuntimeError("Failed: scaled add (left)") print("Test: scaled add (left) passed") # Scaled add (right) Y = vcl_B.value + dtype(alpha.value) * vcl_C.value Z = vcl_B + alpha * vcl_C act_diff = math.fabs(diff(Y, Z)) if act_diff > epsilon: # (Z == Y).all(): pass raise RuntimeError("Failed: scaled add (left)") print("Test: scaled add (right) passed") # Scaled add (both) Y = alpha.value * vcl_B.value + alpha.value * vcl_C.value Z = alpha * vcl_B + alpha * vcl_C act_diff = math.fabs(diff(Y, Z)) if act_diff > epsilon: pass raise RuntimeError("Failed: scaled add (both)") print("Test: scaled add (both) passed") # In-place sub X = vcl_A.value X -= vcl_B.value vcl_A -= vcl_B if not (vcl_A == X).all(): raise RuntimeError("Failed: in-place sub") print("Test: in-place sub passed") # Scaled in-place sub X -= alpha.value * vcl_B.value vcl_A -= alpha * vcl_B if not (vcl_A == X).all(): raise RuntimeError("Failed: scaled in-place sub") print("Test: scaled in-place sub passed") # Sub Y = vcl_A.value - vcl_B.value Z = vcl_A - vcl_B if not (Y == Z).all(): raise RuntimeError("Failed: sub") print("Test: sub passed") # Scaled sub (left) Y = alpha.value * vcl_B.value - vcl_C.value Z = alpha * vcl_B - vcl_C act_diff = math.fabs(diff(Y, Z)) if act_diff > epsilon: raise RuntimeError("Failed: scaled sub (left)") print("Test: scaled sub (left) passed") # Scaled sub (right) Y = vcl_B.value - alpha.value * vcl_C.value Z = vcl_B - alpha * vcl_C act_diff = math.fabs(diff(Y, Z)) if act_diff > epsilon: raise RuntimeError("Failed: scaled sub (right)") print("Test: scaled sub (right) passed") # Scaled sub (both) Y = alpha.value * vcl_B.value - alpha.value * vcl_C.value Z = alpha * vcl_B - alpha * vcl_C act_diff = math.fabs(diff(Y, Z)) if act_diff > epsilon: raise RuntimeError("Failed: scaled sub (both)") print("Test: scaled sub (both) passed") # Scalar multiplication (CPU scalar) -- not supported yet #gamma_py = beta.value * beta.value #gamma_vcl = beta * beta # ... # Scalar multiplication (GPU scalar) # Matrix divided by scalar X = vcl_A.value / alpha.value Y = vcl_A / alpha act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: matrix-scalar division") print("Test: matrix-scalar division passed") # Binary elementwise operations -- prod and div X = vcl_A.value * vcl_B.value Y = p.ElementProd(vcl_A, vcl_B) act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise matrix-matrix multiplication") print("Test: elementwise matrix-matrix multiplication passed") X = vcl_A.value / vcl_B.value Y = p.ElementDiv(vcl_A, vcl_B) act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise matrix-matrix division") print("Test: elementwise matrix-matrix division passed") # Unary elementwise operations # - abs TODO #X = abs(vcl_A.value) #Y = p.ElementAbs(vcl_A) #act_diff = math.fabs(diff(X, Y)) #if act_diff > epsilon: # raise RuntimeError("Failed: elementwise abs") #print("Test: elementwise abs passed") # - acos X = np.arccos(vcl_A.value) Y = p.ElementAcos(vcl_A).result # TODO THIS SHOULDN'T BE REQUIRED act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise acos") print("Test: elementwise acos passed") # - asin X = np.arcsin(vcl_A.value) Y = p.ElementAsin(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise asin") print("Test: elementwise asin passed") # - atan X = np.arctan(vcl_A.value) Y = p.ElementAtan(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise atan") print("Test: elementwise atan passed") # - ceil X = np.ceil(vcl_A.value) Y = p.ElementCeil(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise ceil") print("Test: elementwise ceil passed") # - cos X = np.cos(vcl_A.value) Y = p.ElementCos(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise cos") print("Test: elementwise cos passed") # - cosh X = np.cosh(vcl_A.value) Y = p.ElementCosh(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise cosh") print("Test: elementwise cosh passed") # - exp X = np.exp(vcl_A.value) Y = p.ElementExp(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise exp") print("Test: elementwise exp passed") # - fabs X = np.fabs(vcl_A.value) Y = p.ElementFabs(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise fabs") print("Test: elementwise fabs passed") # - floor X = np.floor(vcl_A.value) Y = p.ElementFloor(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise floor") print("Test: elementwise floor passed") # - log X = np.log(vcl_A.value) Y = p.ElementLog(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise log") print("Test: elementwise log passed") # - log10 X = np.log10(vcl_A.value) Y = p.ElementLog10(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise log10") print("Test: elementwise log10 passed") # - sin X = np.sin(vcl_A.value) Y = p.ElementSin(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise sin") print("Test: elementwise sin passed") # - sinh X = np.sinh(vcl_A.value) Y = p.ElementSinh(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise sinh") print("Test: elementwise sinh passed") # - sqrt X = np.sqrt(vcl_A.value) Y = p.ElementSqrt(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise sqrt") print("Test: elementwise sqrt passed") # - tan X = np.tan(vcl_A.value) Y = p.ElementTan(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise tan") print("Test: elementwise tan passed") # - tanh X = np.tanh(vcl_A.value) Y = p.ElementTanh(vcl_A).result act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: elementwise tanh") print("Test: elementwise tanh passed") # - norm1 X = np.linalg.norm(vcl_A.value, 1) Y = p.norm(vcl_A, 1) # or vcl_A.norm(1) act_diff = math.fabs(X - Y) if act_diff > epsilon: print(vcl_A) #raise RuntimeError("Failed: norm(1)") print("Test: norm(1) passed") # - norm2 X = np.linalg.norm(vcl_A.value, 2) Y = vcl_A.norm(2) # or vcl_A.norm(1) act_diff = math.fabs(X - Y) if act_diff > epsilon: raise RuntimeError("Failed: norm(2)") print("Test: norm(2) passed") # - norm_inf X = np.linalg.norm(vcl_A.value, np.inf) Y = vcl_A.norm(np.inf) act_diff = math.fabs(X - Y) if act_diff > epsilon: raise RuntimeError("Failed: norm(inf)") print("Test: norm(inf) passed") # in-place multiply-division-add X = vcl_C.value X += alpha.value * vcl_A.value + vcl_B.value / beta.value vcl_C += alpha * vcl_A + vcl_B / beta act_diff = math.fabs(diff(X, vcl_C)) if act_diff > epsilon: raise RuntimeError("Failed: in-place multiply-division-add") print("Test: in-place multiply-division-add passed") # lengthy sum of scaled vectors X = alpha.value * vcl_A.value - vcl_B.value / beta.value + vcl_A.value * beta.value - vcl_B.value / alpha.value + vcl_C.value Y = alpha * vcl_A - vcl_B / beta + vcl_A * beta - vcl_B / alpha + vcl_C act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: lengthy sum of scaled vectors") print("Test: lengthy sum of scaled vectors passed") # sub-expression X = vcl_A.value + (((vcl_C.value + vcl_B.value) * alpha.value) - vcl_B.value) / beta.value Y = vcl_A + (((vcl_C + vcl_B) * alpha) - vcl_B) / beta act_diff = math.fabs(diff(X, Y)) if act_diff > epsilon: raise RuntimeError("Failed: vector sub-expression test %s") print("Test: vector sub-expression passed") # plane rotation V = (alpha * vcl_A + beta * vcl_B).result W = (alpha * vcl_B - beta * vcl_A).result p.plane_rotation(vcl_A, vcl_B, alpha, beta) act_diffB = math.fabs(diff(W, vcl_B)) act_diffA = math.fabs(diff(V, vcl_A)) act_diffA = math.fabs(diff(V.value, vcl_A.value)) if act_diffA > epsilon or act_diffB > epsilon: print(act_diffA, act_diffB) print(vcl_A) print(V) print(p.ElementFabs(V - vcl_A)) #print(W, vcl_B) raise RuntimeError("Failed: plane rotation") print("Test: plane rotation passed") return os.EX_OK def test(): print("----------------------------------------------") print("----------------------------------------------") print("## Test :: vector operations") #TODO print("----------------------------------------------") print("----------------------------------------------") print("*** Using float numeric type ***") print("# Testing setup:") epsilon = 1.0E-3 print(" eps: %s" % epsilon) test_vector_slice(run_test, epsilon, p.float32, 11) print("*** Using double numeric type ***") print("# Testing setup:") epsilon = 1.0E-11 print(" eps: %s" % epsilon) test_vector_slice(run_test, epsilon, p.float64, 11) print("# Test passed") return os.EX_OK if __name__ == "__main__": sys.exit(test()) pyviennacl-1.0.2+dfsg.orig/tests/blas3_prod.py0000644000000000000000000001404612307335633020014 0ustar rootroot#!/usr/bin/env python import math import os import pyviennacl as p import sys from test_common import diff, test_matrix_layout, test_matrix_slice def run_test(*args, **kwargs): """ A, A_trans, B, B_trans must be numpy array or matrix instances """ epsilon = args[0] A = args[1] A_trans = args[2] B = args[3] B_trans = args[4] C = args[5] vcl_A = args[6] vcl_A_trans = args[7] vcl_B = args[8] vcl_B_trans = args[9] vcl_C = args[10] act_diff = math.fabs(diff(A, vcl_A)) if act_diff > epsilon: raise Exception("Error copying A") act_diff = math.fabs(diff(B, vcl_B)) if act_diff > epsilon: x = p.Matrix(vcl_B.shape, dtype = vcl_B.dtype, layout = p.ROW_MAJOR) p.Assign(x, vcl_B).execute() print(x.value) print(B) print(x == B) print(act_diff) raise Exception("Error copying B") #act_diff = math.fabs(diff(C, vcl_C)) #if act_diff > epsilon: # raise Exception("Error copying C") act_diff = math.fabs(diff(A_trans, vcl_A_trans)) if act_diff > epsilon: raise Exception("Error copying A_trans") act_diff = math.fabs(diff(B_trans, vcl_B_trans)) if act_diff > epsilon: raise Exception("Error copying B_trans") #act_diff = math.fabs(diff(C_trans, vcl_C_trans)) #if act_diff > epsilon: # raise Exception("Error copying C_trans") #A = vcl_A.value #A_trans = vcl_A_trans.value #B = vcl_B.value #B_trans = vcl_B_trans.value #C = vcl_C.value #C_trans = C.T # C +-= A * B C = A.dot(B) vcl_C = vcl_A * vcl_B act_diff = math.fabs(diff(C, vcl_C)) if (act_diff > epsilon): raise Exception("Error at operation: matrix-matrix product; diff = %s" % act_diff) print("Test C = A * B passed!") C += A.dot(B) vcl_C += vcl_A * vcl_B act_diff = math.fabs(diff(C, vcl_C)) if (act_diff > epsilon): raise Exception("Error at operation: matrix-matrix product; diff = %s" % act_diff) print("Test C += A * B passed!") C -= A.dot(B) vcl_C -= vcl_A * vcl_B act_diff = math.fabs(diff(C, vcl_C)) if (act_diff > epsilon): raise Exception("Error at operation: matrix-matrix product; diff = %s" % act_diff) print("Test C -= A * B passed!") # C +-= A * trans(B) C = A.dot(B_trans.T) vcl_C = vcl_A * vcl_B_trans.T act_diff = math.fabs(diff(C, vcl_C)) if (act_diff > epsilon): raise Exception("Error at operation: matrix-matrix product; diff = %s" % act_diff) print("Test C = A * trans(B) passed!") C += A.dot(B_trans.T) vcl_C += vcl_A * vcl_B_trans.T act_diff = math.fabs(diff(C, vcl_C)) if (act_diff > epsilon): raise Exception("Error at operation: matrix-matrix product; diff = %s" % act_diff) print("Test C += A * trans(B) passed!") C -= A.dot(B_trans.T) vcl_C -= vcl_A * vcl_B_trans.T act_diff = math.fabs(diff(C, vcl_C)) if (act_diff > epsilon): raise Exception("Error at operation: matrix-matrix product; diff = %s" % act_diff) print("Test C -= A * trans(B) passed!") # C +-= trans(A) * B C = A_trans.T.dot(B) vcl_C = vcl_A_trans.T * vcl_B act_diff = math.fabs(diff(C, vcl_C)) if (act_diff > epsilon): raise Exception("Error at operation: matrix-matrix product; diff = %s" % act_diff) print("Test C = trans(A) * B passed!") C += A_trans.T.dot(B) vcl_C += vcl_A_trans.T * vcl_B act_diff = math.fabs(diff(C, vcl_C)) if (act_diff > epsilon): raise Exception("Error at operation: matrix-matrix product; diff = %s" % act_diff) print("Test C += trans(A) * B passed!") C -= A_trans.T.dot(B) vcl_C -= vcl_A_trans.T * vcl_B act_diff = math.fabs(diff(C, vcl_C)) if (act_diff > epsilon): raise Exception("Error at operation: matrix-matrix product; diff = %s" % act_diff) print("Test C -= trans(A) * B passed!") # C +-= trans(A) * trans(B) C = A_trans.T.dot(B_trans.T) vcl_C = vcl_A_trans.T * vcl_B_trans.T act_diff = math.fabs(diff(C, vcl_C)) if (act_diff > epsilon): raise Exception("Error at operation: matrix-matrix product; diff = %s" % act_diff) print("Test C = trans(A) * trans(B) passed!") C += A_trans.T.dot(B_trans.T) vcl_C += vcl_A_trans.T * vcl_B_trans.T act_diff = math.fabs(diff(C, vcl_C)) if (act_diff > epsilon): raise Exception("Error at operation: matrix-matrix product; diff = %s" % act_diff) print("Test C += trans(A) * trans(B) passed!") C -= A_trans.T.dot(B_trans.T) vcl_C -= vcl_A_trans.T * vcl_B_trans.T act_diff = math.fabs(diff(C, vcl_C)) if (act_diff > epsilon): raise Exception("Error at operation: matrix-matrix product; diff = %s" % act_diff) print("Test C -= trans(A) * trans(B) passed!") return os.EX_OK def test(): print("----------------------------------------------") print("----------------------------------------------") print("## Test :: BLAS 3 routines") print("----------------------------------------------") print("----------------------------------------------") print() print("----------------------------------------------") print("--- Part 1: Testing matrix-matrix products ---") print("*** Using float numeric type ***") print("# Testing setup:") epsilon = 1.0E-3 print(" eps: %s" % epsilon) test_matrix_layout(test_matrix_slice, run_test, epsilon, p.float32) #, 11, 11, 11) print("*** Using double numeric type ***") print("# Testing setup:") epsilon = 1.0E-11 print(" eps: %s" % epsilon) test_matrix_layout(test_matrix_slice, run_test, epsilon, p.float64) print("# Test passed") return os.EX_OK if __name__ == "__main__": sys.exit(test()) pyviennacl-1.0.2+dfsg.orig/tests/test_common.py0000644000000000000000000014707112307335633020320 0ustar rootroot#!/usr/bin/env python import math import numpy as np import os import pyviennacl as p import random import logging logger = logging.getLogger('pyviennacl') def noop(*args, **kwargs): return os.EX_OK def diff(a, b): p.util.backend_finish() ret = 0 # Convert NumPy types to ViennaCL types (they're much more convenient!) if isinstance(a, np.ndarray): if a.ndim == 1: a = p.Vector(a, dtype = a.dtype) elif a.ndim == 2: if isinstance(b, p.MagicMethods): a = p.Matrix(a, dtype = a.dtype, layout = b.layout) else: a = p.Matrix(a, dtype = a.dtype) else: raise TypeError("Something went wrong") if isinstance(b, np.ndarray): if b.ndim == 1: b = p.Vector(b) elif b.ndim == 2: if isinstance(a, p.MagicMethods): b = p.Matrix(b, dtype = b.dtype, layout = a.layout) else: b = p.Matrix(b, dtype = b.dtype) else: raise TypeError("Something went wrong") # The MagicMethods class guarantees that we have some useful facilities # (and both Node and Leaf are derived from MagicMethods) if isinstance(a, p.MagicMethods) and isinstance(b, p.MagicMethods): if a.layout != b.layout: # We want to make sure that a and b have the same layout # So construct a temporary matrix, and assign b to it temp = p.Matrix(b.shape, dtype = b.dtype, layout = a.layout) p.Assign(temp, b.result).execute() b = temp log.warning("HERE") d = p.ElementFabs(a - b) cpu_d = d.as_ndarray() if len(d.shape) == 1: # vector for i in range(d.shape[0]): act = math.fabs(cpu_d[i]) if act > ret: ret = act elif len(d.shape) == 2: # matrix for i in range(d.shape[0]): for j in range(d.shape[1]): act = math.fabs(cpu_d[i, j]) if act > ret: ret = act else: raise TypeError("Something went wrong..") return ret else: # We don't have either ndarrays or ViennaCL types so assume plain scalar return math.fabs(a - b) / max(math.fabs(a), math.fabs(b)) def test_vector_slice(test_func, epsilon, dtype, size = 131): # Create reference numpy types A = np.empty((size,), dtype = dtype) big_A = np.ones((size*4,), dtype = dtype) * 3.1415 B = np.empty((size,), dtype = dtype) big_B = np.ones((size*4,), dtype = dtype) * 42.0 C = np.empty((size,), dtype = dtype) big_C = np.ones((size*4,), dtype = dtype) * 2.718 # Fill A and B with random values for i in range(A.shape[0]): A[i] = random.random() for i in range(B.shape[0]): B[i] = random.random() # Construct appropriate ViennaCL objects vcl_A = p.Vector(A) vcl_big_range_A = p.Vector(big_A) vcl_big_range_A[size:2*size] = vcl_A vcl_range_A = vcl_big_range_A[size:2*size] vcl_big_slice_A = p.Vector(big_A) vcl_big_slice_A[size:-size:2] = vcl_A vcl_slice_A = vcl_big_slice_A[size:-size:2] vcl_B = p.Vector(B) vcl_big_range_B = p.Vector(big_B) vcl_big_range_B[size:2*size] = vcl_B vcl_range_B = vcl_big_range_B[size:2*size] vcl_big_slice_B = p.Vector(big_B) vcl_big_slice_B[size:-size:2] = vcl_B vcl_slice_B = vcl_big_slice_B[size:-size:2] vcl_C = p.Vector(C) vcl_big_range_C = p.Vector(big_C) vcl_range_C = vcl_big_range_C[(size - 1):(2*size - 1)] vcl_big_slice_C = p.Vector(big_C) vcl_slice_C = vcl_big_slice_C[(size - 1):(4*size - 1):3] # A=vector, B=vector, C=vector print("Now using A=vector, B=vector, C=vector") try: ret = test_func(epsilon, A, B, C, vcl_A, vcl_B, vcl_C, dtype = dtype) except TypeError as e: if not "Vectors do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=vector, B=vector, C=range print("Now using A=vector, B=vector, C=range") try: ret = test_func(epsilon, A, B, C, vcl_A, vcl_B, vcl_range_C, dtype = dtype) except TypeError as e: if not "Vectors do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=vector, B=vector, C=slice #print("Now using A=vector, B=vector, C=slice") #try: # ret = test_func(epsilon, # A, B, C, # vcl_A, vcl_B, vcl_slice_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=vector, B=range, C=vector print("Now using A=vector, B=range, C=vector") try: ret = test_func(epsilon, A, B, C, vcl_A, vcl_range_B, vcl_C, dtype = dtype) except TypeError as e: if not "Vectors do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=vector, B=range, C=range print("Now using A=vector, B=range, C=range") try: ret = test_func(epsilon, A, B, C, vcl_A, vcl_range_B, vcl_range_C, dtype = dtype) except TypeError as e: if not "Vectors do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=vector, B=range, C=slice #print("Now using A=vector, B=range, C=slice") #try: # ret = test_func(epsilon, # A, B, C, # vcl_A, vcl_range_B, vcl_slice_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=vector, B=slice, C=vector #print("Now using A=vector, B=slice, C=vector") #try: # ret = test_func(epsilon, # A, B, C, # vcl_A, vcl_slice_B, vcl_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=vector, B=slice, C=range #print("Now using A=vector, B=slice, C=range") #try: # ret = test_func(epsilon, # A, B, C, # vcl_A, vcl_slice_B, vcl_range_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=vector, B=slice, C=slice #print("Now using A=vector, B=slice, C=slice") #try: # ret = test_func(epsilon, # A, B, C, # vcl_A, vcl_slice_B, vcl_slice_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=vector, C=vector print("Now using A=range, B=vector, C=vector") try: ret = test_func(epsilon, A, B, C, vcl_range_A, vcl_B, vcl_C, dtype = dtype) except TypeError as e: if not "Vectors do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=vector, C=range print("Now using A=range, B=vector, C=range") try: ret = test_func(epsilon, A, B, C, vcl_range_A, vcl_B, vcl_range_C, dtype = dtype) except TypeError as e: if not "Vectors do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=vector, C=slice #print("Now using A=range, B=vector, C=slice") #try: # ret = test_func(epsilon, # A, B, C, # vcl_range_A, vcl_B, vcl_slice_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=range, C=vector print("Now using A=range, B=range, C=vector") try: ret = test_func(epsilon, A, B, C, vcl_range_A, vcl_range_B, vcl_C, dtype = dtype) except TypeError as e: if not "Vectors do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=range, C=range print("Now using A=range, B=range, C=range") try: ret = test_func(epsilon, A, B, C, vcl_range_A, vcl_range_B, vcl_range_C, dtype = dtype) except TypeError as e: if not "Vectors do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=range, C=slice #print("Now using A=range, B=range, C=slice") #try: # ret = test_func(epsilon, # A, B, C, # vcl_range_A, vcl_range_B, vcl_slice_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=slice, C=vector #print("Now using A=range, B=slice, C=vector") #try: # ret = test_func(epsilon, # A, B, C, # vcl_range_A, vcl_slice_B, vcl_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=slice, C=range #print("Now using A=range, B=slice, C=range") #try: # ret = test_func(epsilon, # A, B, C, # vcl_range_A, vcl_slice_B, vcl_range_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=slice, C=slice #print("Now using A=range, B=slice, C=slice") #try: # ret = test_func(epsilon, # A, B, C, # vcl_range_A, vcl_slice_B, vcl_slice_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=vector, C=vector #print("Now using A=slice, B=vector, C=vector") #try: # ret = test_func(epsilon, # A, B, C, # vcl_slice_A, vcl_B, vcl_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=vector, C=range #print("Now using A=slice, B=vector, C=range") #try: # ret = test_func(epsilon, # A, B, C, # vcl_slice_A, vcl_B, vcl_range_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=vector, C=slice #print("Now using A=slice, B=vector, C=slice") #try: # ret = test_func(epsilon, # A, B, C, # vcl_slice_A, vcl_B, vcl_slice_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=range, C=vector #print("Now using A=slice, B=range, C=vector") #try: # ret = test_func(epsilon, # A, B, C, # vcl_slice_A, vcl_range_B, vcl_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=range, C=range #print("Now using A=slice, B=range, C=range") #try: # ret = test_func(epsilon, # A, B, C, # vcl_slice_A, vcl_range_B, vcl_range_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=range, C=slice #print("Now using A=slice, B=range, C=slice") #try: # ret = test_func(epsilon, # A, B, C, # vcl_slice_A, vcl_range_B, vcl_slice_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=slice, C=vector #print("Now using A=slice, B=slice, C=vector") #try: # ret = test_func(epsilon, # A, B, C, # vcl_slice_A, vcl_slice_B, vcl_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=slice, C=range #print("Now using A=slice, B=slice, C=range") #try: # ret = test_func(epsilon, # A, B, C, # vcl_slice_A, vcl_slice_B, vcl_range_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=slice, C=slice #print("Now using A=slice, B=slice, C=slice") #try: # ret = test_func(epsilon, # A, B, C, # vcl_slice_A, vcl_slice_B, vcl_slice_C, # dtype = dtype) #except TypeError as e: # if not "Vectors do not have the same layout" in e.args[0]: # raise # else: # logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) return os.EX_OK def test_matrix_slice(test_func, epsilon, dtype, A_layout = p.ROW_MAJOR, B_layout = p.ROW_MAJOR, C_layout = p.ROW_MAJOR, size1 = 131, size2 = 67, size3 = 73): if A_layout == p.ROW_MAJOR: A_order = 'C' else: A_order = 'F' if B_layout == p.ROW_MAJOR: B_order = 'C' else: B_order = 'F' if C_layout == p.ROW_MAJOR: C_order = 'C' else: C_order = 'F' # Create reference numpy types A = np.empty((size1, size2), dtype = dtype, order = A_order) big_A = np.ones((size1 * 4, size2 * 4), dtype = dtype, order = A_order) * 3.1415 B = np.empty((size2, size3), dtype = dtype, order = B_order) big_B = np.ones((size2 * 4, size3 * 4), dtype = dtype, order = B_order) * 42.0 C = np.empty((size1, size3), dtype = dtype, order = C_order) big_C = np.ones((size1 * 4, size3 * 4), dtype = dtype, order = C_order) * 2.718 # Fill A and B with random values for i in range(A.shape[0]): for j in range(A.shape[1]): A[i, j] = random.random() for i in range(B.shape[0]): for j in range(B.shape[1]): B[i, j] = random.random() A_trans = A.T big_A_trans = big_A.T B_trans = B.T big_B_trans = big_B.T C_trans = C.T big_C_trans = big_C.T # Construct appropriate ViennaCL objects vcl_A = p.Matrix(A, layout = A_layout) vcl_big_range_A = p.Matrix(big_A, layout = A_layout) vcl_big_range_A[size1:2*size1, size2:2*size2] = vcl_A vcl_range_A = vcl_big_range_A[size1:2*size1, size2:2*size2] vcl_big_slice_A = p.Matrix(big_A, layout = A_layout) vcl_big_slice_A[size1:-size1:2, size2::3] = vcl_A vcl_slice_A = vcl_big_slice_A[size1:-size1:2, size2::3] vcl_A_trans = p.Matrix(A_trans, layout = A_layout) vcl_big_range_A_trans = p.Matrix(big_A_trans, layout = A_layout) vcl_big_range_A_trans[size2:2*size2, size1:2*size1] = vcl_A_trans vcl_range_A_trans = vcl_big_range_A_trans[size2:2*size2, size1:2*size1] vcl_big_slice_A_trans = p.Matrix(big_A_trans, layout = A_layout) vcl_big_slice_A_trans[size2:-size2:2, size1::3] = vcl_A_trans vcl_slice_A_trans = vcl_big_slice_A_trans[size2:-size2:2, size1::3] vcl_B = p.Matrix(B, layout = B_layout) vcl_big_range_B = p.Matrix(big_B, layout = B_layout) vcl_big_range_B[size2:2*size2, size3:2*size3] = vcl_B vcl_range_B = vcl_big_range_B[size2:2*size2, size3:2*size3] vcl_big_slice_B = p.Matrix(big_B, layout = B_layout) vcl_big_slice_B[size2:-size2:2, size3::3] = vcl_B vcl_slice_B = vcl_big_slice_B[size2:-size2:2, size3::3] vcl_B_trans = p.Matrix(B_trans, layout = B_layout) vcl_big_range_B_trans = p.Matrix(big_B_trans, layout = B_layout) vcl_big_range_B_trans[size3:2*size3, size2:2*size2] = vcl_B_trans vcl_range_B_trans = vcl_big_range_B_trans[size3:2*size3, size2:2*size2] vcl_big_slice_B_trans = p.Matrix(big_B_trans, layout = B_layout) vcl_big_slice_B_trans[size3:-size3:2, size2::3] = vcl_B_trans vcl_slice_B_trans = vcl_big_slice_B_trans[size3:-size3:2, size2::3] vcl_C = p.Matrix(C, layout = C_layout) vcl_big_range_C = p.Matrix(big_C, layout = C_layout) vcl_range_C = vcl_big_range_C[(size1 - 1):(2*size1 - 1), (size3 - 1):(2*size3 - 1)] vcl_big_slice_C = p.Matrix(big_C, layout = C_layout) vcl_slice_C = vcl_big_slice_C[(size1 - 1):(4*size1 - 1):3, (size3 - 1):(4*size3 - 1):3] # A=matrix, B=matrix, C=matrix print("Now using A=matrix, B=matrix, C=matrix") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_B, vcl_B_trans, vcl_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=matrix, B=matrix, C=range print("Now using A=matrix, B=matrix, C=range") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_B, vcl_B_trans, vcl_range_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=matrix, B=matrix, C=slice print("Now using A=matrix, B=matrix, C=slice") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_B, vcl_B_trans, vcl_slice_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=matrix, B=range, C=matrix print("Now using A=matrix, B=range, C=matrix") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_range_B, vcl_range_B_trans, vcl_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=matrix, B=range, C=range print("Now using A=matrix, B=range, C=range") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_range_B, vcl_range_B_trans, vcl_range_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=matrix, B=range, C=slice print("Now using A=matrix, B=range, C=slice") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_range_B, vcl_range_B_trans, vcl_slice_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=matrix, B=slice, C=matrix print("Now using A=matrix, B=slice, C=matrix") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=matrix, B=slice, C=range print("Now using A=matrix, B=slice, C=range") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_range_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=matrix, B=slice, C=slice print("Now using A=matrix, B=slice, C=slice") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_slice_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=matrix, C=matrix print("Now using A=range, B=matrix, C=matrix") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_B, vcl_B_trans, vcl_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=matrix, C=range print("Now using A=range, B=matrix, C=range") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_B, vcl_B_trans, vcl_range_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=matrix, C=slice print("Now using A=range, B=matrix, C=slice") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_B, vcl_B_trans, vcl_slice_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=range, C=matrix print("Now using A=range, B=range, C=matrix") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_range_B, vcl_range_B_trans, vcl_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=range, C=range print("Now using A=range, B=range, C=range") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_range_B, vcl_range_B_trans, vcl_range_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=range, C=slice print("Now using A=range, B=range, C=slice") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_range_B, vcl_range_B_trans, vcl_slice_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=slice, C=matrix print("Now using A=range, B=slice, C=matrix") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=slice, C=range print("Now using A=range, B=slice, C=range") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_range_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=slice, C=slice print("Now using A=range, B=slice, C=slice") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_slice_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=matrix, C=matrix print("Now using A=slice, B=matrix, C=matrix") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_B, vcl_B_trans, vcl_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=matrix, C=range print("Now using A=slice, B=matrix, C=range") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_B, vcl_B_trans, vcl_range_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=matrix, C=slice print("Now using A=slice, B=matrix, C=slice") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_B, vcl_B_trans, vcl_slice_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=range, C=matrix print("Now using A=slice, B=range, C=matrix") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_range_B, vcl_range_B_trans, vcl_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=range, C=range print("Now using A=slice, B=range, C=range") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_range_B, vcl_range_B_trans, vcl_range_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=range, C=slice print("Now using A=slice, B=range, C=slice") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_range_B, vcl_range_B_trans, vcl_slice_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=slice, C=matrix print("Now using A=slice, B=slice, C=matrix") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=slice, C=range print("Now using A=slice, B=slice, C=range") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_range_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=slice, C=slice print("Now using A=slice, B=slice, C=slice") try: ret = test_func(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_slice_C, dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) return os.EX_OK def test_matrix_solvers(test_func, epsilon, dtype, A_layout = p.ROW_MAJOR, B_layout = p.ROW_MAJOR, C_layout = p.ROW_MAJOR, size1 = 131, size2 = 131, size3 = 99): if size1 != size2: raise AttributeError("size1 must equal size2 for solving a system: %d and %d" % (size1, size2)) if A_layout == p.ROW_MAJOR: A_order = 'C' else: A_order = 'F' if B_layout == p.ROW_MAJOR: B_order = 'C' else: B_order = 'F' if C_layout == p.ROW_MAJOR: C_order = 'C' else: C_order = 'F' # Create reference numpy types A = np.empty((size1, size2), dtype = dtype, order = A_order) big_A = np.ones((size1 * 4, size2 * 4), dtype = dtype, order = A_order) * 3.1415 B = np.empty((size2, size3), dtype = dtype, order = B_order) big_B = np.ones((size2 * 4, size3 * 4), dtype = dtype, order = B_order) * 42.0 # Fill A and B with random values for i in range(A.shape[0]): for j in range(A.shape[1]): A[i, j] = random.random() for i in range(B.shape[0]): for j in range(B.shape[1]): B[i, j] = random.random() A_trans = A.T big_A_trans = big_A.T B_trans = B.T big_B_trans = big_B.T A_upper = A.copy() for i in range(A.shape[0]): for j in range(A.shape[1]): if j < i: A_upper[i, j] = 0 A_lower = A.copy() for i in range(A.shape[0]): for j in range(A.shape[1]): if j > i: A_lower[i, j] = 0 A_unit_upper = A_upper.copy() for i in range(A.shape[0]): for j in range(A.shape[1]): if i == j: A_unit_upper[i, j] = 1.0 A_unit_lower = A_lower.copy() for i in range(A.shape[0]): for j in range(A.shape[1]): if i == j: A_unit_lower[i, j] = 1.0 A_trans_upper = A_trans.copy() for i in range(A_trans.shape[0]): for j in range(A_trans.shape[1]): if j < i: A_trans_upper[i, j] = 0 A_trans_lower = A_trans.copy() for i in range(A_trans.shape[0]): for j in range(A_trans.shape[1]): if j > i: A_trans_lower[i, j] = 0 A_trans_unit_upper = A_trans_upper.copy() for i in range(A_trans.shape[0]): for j in range(A_trans.shape[1]): if i == j: A_trans_unit_upper[i, j] = 1.0 A_trans_unit_lower = A_trans_lower.copy() for i in range(A_trans.shape[0]): for j in range(A_trans.shape[1]): if i == j: A_trans_unit_lower[i, j] = 1.0 # Construct appropriate ViennaCL objects # -- A_upper vcl_A_upper = p.Matrix(A_upper, layout = A_layout) vcl_big_range_A_upper = p.Matrix(big_A, layout = A_layout) vcl_big_range_A_upper[size1:2*size1, size2:2*size2] = vcl_A_upper vcl_range_A_upper = vcl_big_range_A_upper[size1:2*size1, size2:2*size2] vcl_big_slice_A_upper = p.Matrix(big_A, layout = A_layout) vcl_big_slice_A_upper[size1:-size1:2, size2::3] = vcl_A_upper vcl_slice_A_upper = vcl_big_slice_A_upper[size1:-size1:2, size2::3] vcl_A_trans_upper = p.Matrix(A_trans_upper, layout = A_layout) vcl_big_range_A_trans_upper = p.Matrix(big_A_trans, layout = A_layout) vcl_big_range_A_trans_upper[size2:2*size2, size1:2*size1] = vcl_A_trans_upper vcl_range_A_trans_upper = vcl_big_range_A_trans_upper[size2:2*size2, size1:2*size1] vcl_big_slice_A_trans_upper = p.Matrix(big_A_trans, layout = A_layout) vcl_big_slice_A_trans_upper[size2:-size2:2, size1::3] = vcl_A_trans_upper vcl_slice_A_trans_upper = vcl_big_slice_A_trans_upper[size2:-size2:2, size1::3] # -- A_unit_upper vcl_A_unit_upper = p.Matrix(A_unit_upper, layout = A_layout) vcl_big_range_A_unit_upper = p.Matrix(big_A, layout = A_layout) vcl_big_range_A_unit_upper[size1:2*size1, size2:2*size2] = vcl_A_unit_upper vcl_range_A_unit_upper = vcl_big_range_A_unit_upper[size1:2*size1, size2:2*size2] vcl_big_slice_A_unit_upper = p.Matrix(big_A, layout = A_layout) vcl_big_slice_A_unit_upper[size1:-size1:2, size2::3] = vcl_A_unit_upper vcl_slice_A_unit_upper = vcl_big_slice_A_unit_upper[size1:-size1:2, size2::3] vcl_A_trans_unit_upper = p.Matrix(A_trans_unit_upper, layout = A_layout) vcl_big_range_A_trans_unit_upper = p.Matrix(big_A_trans, layout = A_layout) vcl_big_range_A_trans_unit_upper[size2:2*size2, size1:2*size1] = vcl_A_trans_unit_upper vcl_range_A_trans_unit_upper = vcl_big_range_A_trans_unit_upper[size2:2*size2, size1:2*size1] vcl_big_slice_A_trans_unit_upper = p.Matrix(big_A_trans, layout = A_layout) vcl_big_slice_A_trans_unit_upper[size2:-size2:2, size1::3] = vcl_A_trans_unit_upper vcl_slice_A_trans_unit_upper = vcl_big_slice_A_trans_unit_upper[size2:-size2:2, size1::3] # -- A_lower vcl_A_lower = p.Matrix(A_lower, layout = A_layout) vcl_big_range_A_lower = p.Matrix(big_A, layout = A_layout) vcl_big_range_A_lower[size1:2*size1, size2:2*size2] = vcl_A_lower vcl_range_A_lower = vcl_big_range_A_lower[size1:2*size1, size2:2*size2] vcl_big_slice_A_lower = p.Matrix(big_A, layout = A_layout) vcl_big_slice_A_lower[size1:-size1:2, size2::3] = vcl_A_lower vcl_slice_A_lower = vcl_big_slice_A_lower[size1:-size1:2, size2::3] vcl_A_trans_lower = p.Matrix(A_trans_lower, layout = A_layout) vcl_big_range_A_trans_lower = p.Matrix(big_A_trans, layout = A_layout) vcl_big_range_A_trans_lower[size2:2*size2, size1:2*size1] = vcl_A_trans_lower vcl_range_A_trans_lower = vcl_big_range_A_trans_lower[size2:2*size2, size1:2*size1] vcl_big_slice_A_trans_lower = p.Matrix(big_A_trans, layout = A_layout) vcl_big_slice_A_trans_lower[size2:-size2:2, size1::3] = vcl_A_trans_lower vcl_slice_A_trans_lower = vcl_big_slice_A_trans_lower[size2:-size2:2, size1::3] # -- A_unit_lower vcl_A_unit_lower = p.Matrix(A_unit_lower, layout = A_layout) vcl_big_range_A_unit_lower = p.Matrix(big_A, layout = A_layout) vcl_big_range_A_unit_lower[size1:2*size1, size2:2*size2] = vcl_A_unit_lower vcl_range_A_unit_lower = vcl_big_range_A_unit_lower[size1:2*size1, size2:2*size2] vcl_big_slice_A_unit_lower = p.Matrix(big_A, layout = A_layout) vcl_big_slice_A_unit_lower[size1:-size1:2, size2::3] = vcl_A_unit_lower vcl_slice_A_unit_lower = vcl_big_slice_A_unit_lower[size1:-size1:2, size2::3] vcl_A_trans_unit_lower = p.Matrix(A_trans_unit_lower, layout = A_layout) vcl_big_range_A_trans_unit_lower = p.Matrix(big_A_trans, layout = A_layout) vcl_big_range_A_trans_unit_lower[size2:2*size2, size1:2*size1] = vcl_A_trans_unit_lower vcl_range_A_trans_unit_lower = vcl_big_range_A_trans_unit_lower[size2:2*size2, size1:2*size1] vcl_big_slice_A_trans_unit_lower = p.Matrix(big_A_trans, layout = A_layout) vcl_big_slice_A_trans_unit_lower[size2:-size2:2, size1::3] = vcl_A_trans_unit_lower vcl_slice_A_trans_unit_lower = vcl_big_slice_A_trans_unit_lower[size2:-size2:2, size1::3] # -- B vcl_B = p.Matrix(B, layout = B_layout) vcl_big_range_B = p.Matrix(big_B, layout = B_layout) vcl_big_range_B[size2:2*size2, size3:2*size3] = vcl_B vcl_range_B = vcl_big_range_B[size2:2*size2, size3:2*size3] vcl_big_slice_B = p.Matrix(big_B, layout = B_layout) vcl_big_slice_B[size2:-size2:2, size3::3] = vcl_B vcl_slice_B = vcl_big_slice_B[size2:-size2:2, size3::3] vcl_B_trans = p.Matrix(B_trans, layout = B_layout) vcl_big_range_B_trans = p.Matrix(big_B_trans, layout = B_layout) vcl_big_range_B_trans[size3:2*size3, size2:2*size2] = vcl_B_trans vcl_range_B_trans = vcl_big_range_B_trans[size3:2*size3, size2:2*size2] vcl_big_slice_B_trans = p.Matrix(big_B_trans, layout = B_layout) vcl_big_slice_B_trans[size3:-size3:2, size2::3] = vcl_B_trans vcl_slice_B_trans = vcl_big_slice_B_trans[size3:-size3:2, size2::3] # A=matrix, B=matrix print("Now using A=matrix, B=matrix") try: ret = test_func(epsilon, (A_upper, A_unit_upper, A_lower, A_unit_lower, A_trans_upper, A_trans_unit_upper, A_trans_lower, A_trans_unit_lower), (B, B_trans), (vcl_A_upper, vcl_A_unit_upper, vcl_A_lower, vcl_A_unit_lower, vcl_A_trans_upper, vcl_A_trans_unit_upper, vcl_A_trans_lower, vcl_A_trans_unit_lower), (vcl_B, vcl_B_trans), dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=matrix, B=range print("Now using A=matrix, B=range") try: ret = test_func(epsilon, (A_upper, A_unit_upper, A_lower, A_unit_lower, A_trans_upper, A_trans_unit_upper, A_trans_lower, A_trans_unit_lower), (B, B_trans), (vcl_A_upper, vcl_A_unit_upper, vcl_A_lower, vcl_A_unit_lower, vcl_A_trans_upper, vcl_A_trans_unit_upper, vcl_A_trans_lower, vcl_A_trans_unit_lower), (vcl_range_B, vcl_range_B_trans), dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=matrix, B=slice print("Now using A=matrix, B=slice") try: ret = test_func(epsilon, (A_upper, A_unit_upper, A_lower, A_unit_lower, A_trans_upper, A_trans_unit_upper, A_trans_lower, A_trans_unit_lower), (B, B_trans), (vcl_A_upper, vcl_A_unit_upper, vcl_A_lower, vcl_A_unit_lower, vcl_A_trans_upper, vcl_A_trans_unit_upper, vcl_A_trans_lower, vcl_A_trans_unit_lower), (vcl_slice_B, vcl_slice_B_trans), dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=matrix print("Now using A=range, B=matrix") try: ret = test_func(epsilon, (A_upper, A_unit_upper, A_lower, A_unit_lower, A_trans_upper, A_trans_unit_upper, A_trans_lower, A_trans_unit_lower), (B, B_trans), (vcl_range_A_upper, vcl_range_A_unit_upper, vcl_range_A_lower, vcl_range_A_unit_lower, vcl_range_A_trans_upper,vcl_range_A_trans_unit_upper, vcl_range_A_trans_lower,vcl_range_A_trans_unit_lower), (vcl_B, vcl_B_trans), dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=range print("Now using A=range, B=range") try: ret = test_func(epsilon, (A_upper, A_unit_upper, A_lower, A_unit_lower, A_trans_upper, A_trans_unit_upper, A_trans_lower, A_trans_unit_lower), (B, B_trans), (vcl_range_A_upper, vcl_range_A_unit_upper, vcl_range_A_lower, vcl_range_A_unit_lower, vcl_range_A_trans_upper,vcl_range_A_trans_unit_upper, vcl_range_A_trans_lower,vcl_range_A_trans_unit_lower), (vcl_range_B, vcl_range_B_trans), dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=range, B=slice print("Now using A=range, B=slice") try: ret = test_func(epsilon, (A_upper, A_unit_upper, A_lower, A_unit_lower, A_trans_upper, A_trans_unit_upper, A_trans_lower, A_trans_unit_lower), (B, B_trans), (vcl_range_A_upper, vcl_range_A_unit_upper, vcl_range_A_lower, vcl_range_A_unit_lower, vcl_range_A_trans_upper,vcl_range_A_trans_unit_upper, vcl_range_A_trans_lower,vcl_range_A_trans_unit_lower), (vcl_slice_B, vcl_slice_B_trans), dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=matrix print("Now using A=slice, B=matrix") try: ret = test_func(epsilon, (A_upper, A_unit_upper, A_lower, A_unit_lower, A_trans_upper, A_trans_unit_upper, A_trans_lower, A_trans_unit_lower), (B, B_trans), (vcl_slice_A_upper, vcl_slice_A_unit_upper, vcl_slice_A_lower, vcl_slice_A_unit_lower, vcl_slice_A_trans_upper,vcl_slice_A_trans_unit_upper, vcl_slice_A_trans_lower,vcl_slice_A_trans_unit_lower), (vcl_B, vcl_B_trans), dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=range print("Now using A=slice, B=range") try: ret = test_func(epsilon, (A_upper, A_unit_upper, A_lower, A_unit_lower, A_trans_upper, A_trans_unit_upper, A_trans_lower, A_trans_unit_lower), (B, B_trans), (vcl_slice_A_upper, vcl_slice_A_unit_upper, vcl_slice_A_lower, vcl_slice_A_unit_lower, vcl_slice_A_trans_upper,vcl_slice_A_trans_unit_upper, vcl_slice_A_trans_lower,vcl_slice_A_trans_unit_lower), (vcl_range_B, vcl_range_B_trans), dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) # A=slice, B=slice print("Now using A=slice, B=slice") try: ret = test_func(epsilon, (A_upper, A_unit_upper, A_lower, A_unit_lower, A_trans_upper, A_trans_unit_upper, A_trans_lower, A_trans_unit_lower), (B, B_trans), (vcl_slice_A_upper, vcl_slice_A_unit_upper, vcl_slice_A_lower, vcl_slice_A_unit_lower, vcl_slice_A_trans_upper,vcl_slice_A_trans_unit_upper, vcl_slice_A_trans_lower,vcl_slice_A_trans_unit_lower), (vcl_slice_B, vcl_slice_B_trans), dtype = dtype) except TypeError as e: if not "Matrices do not have the same layout" in e.args[0]: raise else: logger.debug("EXCEPTION EXECUTING was: %s" % e.args[0]) return os.EX_OK def test_matrix_layout(test_func, test_kernel, epsilon, dtype, size1 = 131, size2 = 131, size3 = 73, num_matrices = 3): # A=row, B=row, C=row print("///////////////////////////////////////") print("/// Now testing A=row, B=row, C=row ///") print("///////////////////////////////////////") test_func(test_kernel, epsilon, dtype, p.ROW_MAJOR, p.ROW_MAJOR, p.ROW_MAJOR, size1, size2, size3) if num_matrices == 3: # A=row, B=row, C=col print("///////////////////////////////////////") print("/// Now testing A=row, B=row, C=col ///") print("///////////////////////////////////////") test_func(test_kernel, epsilon, dtype, p.ROW_MAJOR, p.ROW_MAJOR, p.COL_MAJOR, size1, size2, size3) # A=row, B=col, C=row print("///////////////////////////////////////") print("/// Now testing A=row, B=col, C=row ///") print("///////////////////////////////////////") test_func(test_kernel, epsilon, dtype, p.ROW_MAJOR, p.COL_MAJOR, p.ROW_MAJOR, size1, size2, size3) if num_matrices == 3: # A=row, B=col, C=col print("///////////////////////////////////////") print("/// Now testing A=row, B=col, C=col ///") print("///////////////////////////////////////") test_func(test_kernel, epsilon, dtype, p.ROW_MAJOR, p.COL_MAJOR, p.COL_MAJOR, size1, size2, size3) # A=col, B=row, C=row print("///////////////////////////////////////") print("/// Now testing A=col, B=row, C=row ///") print("///////////////////////////////////////") test_func(test_kernel, epsilon, dtype, p.COL_MAJOR, p.ROW_MAJOR, p.ROW_MAJOR, size1, size2, size3) if num_matrices == 3: # A=col, B=row, C=col print("///////////////////////////////////////") print("/// Now testing A=col, B=row, C=col ///") print("///////////////////////////////////////") test_func(test_kernel, epsilon, dtype, p.COL_MAJOR, p.ROW_MAJOR, p.COL_MAJOR, size1, size2, size3) # A=col, B=col, C=row print("///////////////////////////////////////") print("/// Now testing A=col, B=col, C=row ///") print("///////////////////////////////////////") test_func(test_kernel, epsilon, dtype, p.COL_MAJOR, p.COL_MAJOR, p.ROW_MAJOR, size1, size2, size3) if num_matrices == 3: # A=col, B=col, C=col print("///////////////////////////////////////") print("/// Now testing A=col, B=col, C=col ///") print("///////////////////////////////////////") test_func(test_kernel, epsilon, dtype, p.COL_MAJOR, p.COL_MAJOR, p.COL_MAJOR, size1, size2, size3) return os.EX_OK pyviennacl-1.0.2+dfsg.orig/tests/blas3_solve.py0000644000000000000000000002156112307335633020200 0ustar rootroot#!/usr/bin/env python import math import os import pyviennacl as p import scipy.linalg as sp import scipy.sparse.linalg as spsp import sys from test_common import diff, test_matrix_layout, test_matrix_solvers def test_kernel(*args, **kwargs): """ A, A_trans, B, B_trans must be numpy array or matrix instances """ epsilon = args[0] A_upper, A_unit_upper, A_lower, A_unit_lower, A_trans_upper, A_trans_unit_upper, A_trans_lower, A_trans_unit_lower = args[1] B, B_trans = args[2] vcl_A_upper, vcl_A_unit_upper, vcl_A_lower, vcl_A_unit_lower, vcl_A_trans_upper, vcl_A_trans_unit_upper, vcl_A_trans_lower, vcl_A_trans_unit_lower = args[3] vcl_B, vcl_B_trans = args[4] Bvec = B[::, 0] vcl_Bvec = p.Vector(vcl_B.value[::, 0]) # TODO: get rid of .value if not (Bvec == vcl_Bvec).all(): print(Bvec) print(vcl_Bvec) raise RuntimeError("Failed creating B vector") # A \ B vcl_X = p.solve(vcl_A_upper, vcl_B, p.upper_tag()) X = sp.solve(A_upper, B) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A \ B for upper triangular A: %s" % act_diff) print("Test passed: solving A \ B for upper triangular A: %s" % act_diff) vcl_X = p.solve(vcl_A_unit_upper, vcl_B, p.unit_upper_tag()) X = sp.solve(A_unit_upper, B) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A \ B for unit upper triangular A: %s" % act_diff) print("Test passed: solving A \ B for unit upper triangular A: %s" % act_diff) vcl_X = p.solve(vcl_A_lower, vcl_B, p.lower_tag()) X = sp.solve(A_lower, B, lower = True) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A \ B for lower triangular A: %s" % act_diff) print("Test passed: solving A \ B for lower triangular A: %s" % act_diff) vcl_X = p.solve(vcl_A_unit_lower, vcl_B, p.unit_lower_tag()) X = sp.solve(A_unit_lower, B, lower = True) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A \ B for unit lower triangular A: %s" % act_diff) print("Test passed: solving A \ B for unit lower triangular A: %s" % act_diff) # A^T \ B vcl_X = p.solve(vcl_A_trans_upper, vcl_B, p.upper_tag()) X = sp.solve(A_trans_upper, B) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A^T \ B for upper triangular A: %s" % act_diff) print("Test passed: solving A^T \ B for upper triangular A: %s" % act_diff) vcl_X = p.solve(vcl_A_trans_unit_upper, vcl_B, p.unit_upper_tag()) X = sp.solve(A_trans_unit_upper, B) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A^T \ B for unit upper triangular A: %s" % act_diff) print("Test passed: solving A^T \ B for unit upper triangular A: %s" % act_diff) vcl_X = p.solve(vcl_A_trans_lower, vcl_B, p.lower_tag()) X = sp.solve(A_trans_lower, B, lower = True) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A^T \ B for lower triangular A: %s" % act_diff) print("Test passed: solving A^T \ B for lower triangular A: %s" % act_diff) vcl_X = p.solve(vcl_A_trans_unit_lower, vcl_B, p.unit_lower_tag()) X = sp.solve(A_trans_unit_lower, B, lower = True) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A^T \ B for unit lower triangular A: %s" % act_diff) print("Test passed: solving A^T \ B for unit lower triangular A: %s" % act_diff) # A \ B^T vcl_X = p.solve(vcl_A_upper, vcl_B_trans, p.upper_tag()) X = sp.solve(A_upper, B_trans) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A \ B^T for upper triangular A: %s" % act_diff) print("Test passed: solving A \ B^T for upper triangular A: %s" % act_diff) vcl_X = p.solve(vcl_A_unit_upper, vcl_B_trans, p.unit_upper_tag()) X = sp.solve(A_unit_upper, B_trans) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A \ B^T for unit upper triangular A: %s" % act_diff) print("Test passed: solving A \ B^T for unit upper triangular A: %s" % act_diff) vcl_X = p.solve(vcl_A_lower, vcl_B_trans, p.lower_tag()) X = sp.solve(A_lower, B_trans, lower = True) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A \ B^T for lower triangular A: %s" % act_diff) print("Test passed: solving A \ B^T for lower triangular A: %s" % act_diff) vcl_X = p.solve(vcl_A_unit_lower, vcl_B_trans, p.unit_lower_tag()) X = sp.solve(A_unit_lower, B_trans, lower = True) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A \ B^T for unit lower triangular A: %s" % act_diff) print("Test passed: solving A \ B^T for unit lower triangular A: %s" % act_diff) # A^T \ B^T vcl_X = p.solve(vcl_A_trans_upper, vcl_B_trans, p.upper_tag()) X = sp.solve(A_trans_upper, B_trans) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A^T \ B^T for upper triangular A: %s" % act_diff) print("Test passed: solving A^T \ B^T for upper triangular A: %s" % act_diff) vcl_X = p.solve(vcl_A_trans_unit_upper, vcl_B_trans, p.unit_upper_tag()) X = sp.solve(A_trans_unit_upper, B_trans) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A^T \ B^T for unit upper triangular A: %s" % act_diff) print("Test passed: solving A^T \ B^T for unit upper triangular A: %s" % act_diff) vcl_X = p.solve(vcl_A_trans_lower, vcl_B_trans, p.lower_tag()) X = sp.solve(A_trans_lower, B_trans, lower = True) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A^T \ B^T for lower triangular A: %s" % act_diff) print("Test passed: solving A^T \ B^T for lower triangular A: %s" % act_diff) vcl_X = p.solve(vcl_A_trans_unit_lower, vcl_B_trans, p.unit_lower_tag()) X = sp.solve(A_trans_unit_lower, B_trans, lower = True) act_diff = math.fabs(diff(X, vcl_X)) if act_diff > epsilon: raise RuntimeError("Failed solving A^T \ B^T for unit lower triangular A: %s" % act_diff) print("Test passed: solving A^T \ B^T for unit lower triangular A: %s" % act_diff) # !!! NB: ITERATIVE SOLVERS NOT DEFINED FOR DENSE MATRICES CURRENTLY # # GMRES #vcl_X = p.solve(vcl_A_upper, vcl_Bvec, p.gmres_tag(tolerance=(epsilon/10))) #X, info = spsp.gmres(A_upper, Bvec, tol=(epsilon/10)) #act_diff = math.fabs(diff(X, vcl_X)) #if act_diff > epsilon: # raise RuntimeError("Failed solving A \ b using GMRES: %s" % act_diff) #print("Test passed: solving A \ b using GMRES: %s" % act_diff) # # CG -- TODO: need a symmetric positive definite matrix for test #vcl_X = p.solve(vcl_A_upper, vcl_Bvec, p.cg_tag()) #X, info = spsp.cg(A_upper, Bvec) #act_diff = math.fabs(diff(X, vcl_X)) #if act_diff > epsilon: # raise RuntimeError("Failed solving A \ b using CG: %s" % act_diff) #print("Test passed: solving A \ b using CG: %s" % act_diff) # # BiCGStab -- TODO: need a non-symmetric matrix for test #vcl_X = p.solve(vcl_A_upper, vcl_Bvec, p.cg_tag()) #X, info = spsp.cg(A_upper, Bvec) #act_diff = math.fabs(diff(X, vcl_X)) #if act_diff > epsilon: # raise RuntimeError("Failed solving A \ b using CG: %s" % act_diff) #print("Test passed: solving A \ b using CG: %s" % act_diff) # TODO: in-place solvers # TODO: iterative solvers on sparse matrices return os.EX_OK def test(): print("----------------------------------------------") print("----------------------------------------------") print("## Test :: BLAS 3 routines :: solvers") print("----------------------------------------------") print("----------------------------------------------") print() print("----------------------------------------------") print("*** Using float numeric type ***") print("# Testing setup:") epsilon = 1.0E-1 print(" eps: %s" % epsilon) test_matrix_layout(test_matrix_solvers, test_kernel, epsilon, p.float32, 9, 9, 9, num_matrices = 2) print("*** Using double numeric type ***") print("# Testing setup:") epsilon = 1.0E-08 print(" eps: %s" % epsilon) test_matrix_layout(test_matrix_solvers, test_kernel, epsilon, p.float64, 9, 9, 9, num_matrices = 2) print("# Test passed") return os.EX_OK if __name__ == "__main__": sys.exit(test()) pyviennacl-1.0.2+dfsg.orig/tests/scalar_operations.py0000644000000000000000000001010112307335633021460 0ustar rootroot#!/usr/bin/env python import math import numpy as np import os import pyviennacl as p import random import sys def test_scalar(epsilon, dtype): """ Basic arithmetic: + add, sub, mul, div Scalar result types: Host and Device scalars """ a = dtype(random.random()) b = dtype(random.random()) c = dtype(random.random()) d = dtype(random.random()) alpha = p.Scalar(a) beta = p.Scalar(b) gamma = p.HostScalar(c) delta = p.HostScalar(d) if not alpha == a: raise RuntimeError("Failed to initialise device scalar") if not beta == b: raise RuntimeError("Failed to initialise device scalar") if not gamma == c: raise RuntimeError("Failed to initialise host scalar") if not delta == d: raise RuntimeError("Failed to initialise host scalar") print("Test: scalar initialisation passed") ### Test copy A = alpha.copy() if A != a: raise RuntimeError("Failed to copy device scalar") G = gamma.copy() if G != c: raise RuntimeError("Failed to copy host scalar") print("Test: scalar copy passed") ### Test inter-type initialisation A_tmp = A A = p.Scalar(G) if A != c: raise RuntimeError("Failed to initialise device scalar from copied host scalar") B = p.HostScalar(beta) if B != b: raise RuntimeError("Failed to initialise host scalar from device scalar") G = p.HostScalar(A_tmp) if G != a: raise RuntimeError("Failed to initialise host scalar from copied device scalar") D = p.Scalar(delta) if D != d: raise RuntimeError("Failed to initialise device scalar from host scalar") print("Test: inter-type scalar initialisation passed") ### pyvcl type arithmetic X = (a / c) + (b ** a) * (c - d) // b Y = (alpha / gamma) + (beta ** alpha) * (gamma - delta) // beta X += a Y += alpha X -= b Y -= beta X *= c Y *= gamma X /= d Y /= delta X **= dtype(2) Y **= p.HostScalar(dtype(2)) X //= Y Y //= Y if (X - Y) > epsilon: raise RuntimeError("Failed basic arithmetic test") print("Test: basic arithmetic passed") ### Inter-type arithmetic X = (a / gamma) + (b ** alpha) * (c - delta) // beta Y = (alpha / c) + (beta ** a) * (gamma - d) // b X = p.Scalar(X, dtype = dtype) X += alpha Y += a X -= b Y -= beta X *= gamma Y *= c X /= d Y /= delta X **= p.HostScalar(dtype(2)) Y **= dtype(2) if (X - Y) > epsilon: raise RuntimeError("Failed inter-type arithmetic test") print("Test: inter-type arithmetic passed") ### Scalar result type arithmetic """ + Norm_1, Norm_2, Norm_Inf + Element* operations? + Dot (ie, inner product) """ vec = p.Vector([X, a, beta, c, delta, Y], dtype = dtype) r1 = vec.norm(1) r2 = vec.norm(2) r3 = vec.norm(p.inf) r4 = vec.dot(vec * alpha) R1 = r1.value R2 = r2.value R3 = r3.value R4 = r4.value X = (r1 * a + r2 * beta - r3 / c - r4 // delta) * (r1 + r4 - R3) Y = (R1 * a + R2 * beta - R3 / c - R4 // delta) * (R1 + R4 - r3) if (X - Y) > epsilon: raise RuntimeError("Failed scalar result type arithmetic test") print("Test: scalar result type arithmetic passed") def test(): print("----------------------------------------------") print("----------------------------------------------") print("## Test :: Scalar operations") print("----------------------------------------------") print("----------------------------------------------") print() print("----------------------------------------------") print("*** Using float numeric type ***") print("# Testing setup:") epsilon = 1.0E-3 print(" eps: %s" % epsilon) test_scalar(epsilon, p.float32) print("*** Using double numeric type ***") print("# Testing setup:") epsilon = 1.0E-11 print(" eps: %s" % epsilon) test_scalar(epsilon, p.float64) print("# Test passed") return os.EX_OK if __name__ == "__main__": sys.exit(test()) pyviennacl-1.0.2+dfsg.orig/README.rst0000644000000000000000000001752612315046241015736 0ustar rootroot***************** PyViennaCL Readme ***************** PyViennaCL around the web ========================= * `Home page `_ * `Documentation `_ * `GitHub `_ (`Issue tracker `_) About PyViennaCL ================ *PyViennaCL* aims to make fast, powerful GPGPU and heterogeneous scientific computing really transparently easy, especially for users already using NumPy for representing matrices. PyViennaCL does this by harnessing the `ViennaCL `_ linear algebra and numerical computation library for GPGPU and heterogeneous systems, thereby making available to Python programmers ViennaCL’s fast *OpenCL* and *CUDA* algorithms. PyViennaCL does this in a way that is idiomatic and compatible with the Python community’s most popular scientific packages, *NumPy* and *SciPy*. PyViennaCL exposes the following functionality: * sparse (compressed, co-ordinate, ELL, and hybrid) and dense (row-major and column-major) matrices, vectors and scalars on your compute device using OpenCL; * standard arithmetic operations and mathematical functions; * fast matrix products for sparse and dense matrices, and inner and outer products for vectors; * direct solvers for dense triangular systems; * iterative solvers for sparse and dense systems, using the BiCGStab, CG, and GMRES algorithms; * iterative algorithms for eigenvalue estimation problems. Requirements ============ PyViennaCL requires the following build dependencies: * a C++ compiler; * *Python* (2.7+) with *setuptools* [see below]; * *NumPy* (1.7+); * *Sphinx* (1.0+) [if you want to build HTML documentation]. It is also highly recommended to have an available *OpenCL* implementation, since PyViennaCL was designed for this case. If you do not have OpenCL available, then PyViennaCL will still build and function, but will not perform to full effect. If you have a Boost installation on your system, then PyViennaCL can also optionally use that, rather than the Boost subset shipped with the PyViennaCL sources. setuptools ---------- PyViennaCL uses the Python package `setuptools `_ for installation. Unless you are using **Python 3.4**, which comes with the required pieces, you may need to install setuptools. The **best way to do so**, which will also ensure you have the Python package manager *pip* installed, is to follow `the instructions here `_. OpenCL ------ By default, you will need an OpenCL implementation. PyViennaCL can still build and function without one, but will not perform to full effect. For information on how to get an OpenCL implementation on Linux, see this `howto `_. See also the installation section in the `ViennaCL Manual `_ on installation hints for Windows. If you have an OpenCL installation that you installed and is not managed by your system's package manager, then it is likely you will need to use the '--cl-lib-dir' configure option. If you do not wish to use OpenCL, then follow the *Custom installation* instructions below, and use the '--no-use-opencl' configure option. Extra requirements for building from source on Windows systems -------------------------------------------------------------- In addition to the components required above, Windows builds require the use of the Windows SDK version specific to the version of your Python installation. For instance, when you run Python, if you see the following:: Python 2.7.6 (default, Nov 10 2013, 19:24:18) [MSC v.1500 32 bit (Intel)] on win32 then you are using a release of Python 2.7 and you are building for a 32-bit installation of that version. You must therefore choose the SDK version and set the build environment accordingly. If you are building for a standard distribution (such as described in the example above) of Python 2.6, 2.7, 3.0, 3.1 or 3.2 (either 32- or 64-bit), you will need the `Microsoft Windows SDK v7.0 for Windows 7 and .NET Framework 3.5 SP1 `_. If you are building for a standard distribution of Python 3.3 (32- or 64-bit), you will need the `Microsoft Windows SDK v7.1 for Windows 7 and .NET Framework 4 `_. Having installed the correct SDK version, you will need to open an SDK command prompt and issue the following commands, according the architecture of your Python installation. If you are building for a 32-bit Python installation, use:: $> set DISTUTILS_USE_SDK=1 $> setenv /x86 /release If you are building for a 64-bit Python installation, use:: $> set DISTUTILS_USE_SDK=1 $> setenv /x64 /release At this point, you will be able to follow the instructions detailed below under *Installation*. Issue all commands from within the SDK command window. You might also be interested in the `Python Tools for Visual Studio `_, though these are not required either for building or using PyViennaCL. Installation ============ Please note that the commands below assume that the various programs invoked are available in your system PATH; if they are not, please provide the full path to the executable on invocation. This is especially relevant on Windows systems, where Python is not by default installed into the path. So, in this case, you might have to run something like:: $> C:\Python2.7\python -m pip install pyviennacl instead of just:: $> pip install pyviennacl Quick installation using pip ---------------------------- The following command should usually be enough to install PyViennaCL, as long as you have setuptools and pip installed (see above):: $> pip install pyviennacl If you have a recent installation of Python (2.7 or 3.3+), and a recent installation of pip (1.4+), then this should be painless. Note that this command assumes you have OpenCL available, and if you are on Linux, an OpenCL SDK. If this does not succeed, follow the instructions below. Custom installation ------------------- These instructions assume a UNIX-like platform (such as a Linux distribution or Mac OS X), but will work on a well-configured Windows system with little modification. If you are building from the release package, move on to the next paragraph. If you are building from git, then before doing anything else, navigate to your PyViennaCL folder and get the external submodules with:: $> git submodule update --init (On Windows you usually want to use the git bash for this) If you are in a hurry, then the following should just work:: $> python setup.py build $> sudo python setup.py install Otherwise, read the configuration options, configure, build and install:: $> ./configure.py --help $> ./configure.py --some-options $> python setup.py build $> sudo python setup.py install To build the HTML documentation using Sphinx, first install PyViennaCL as above, and then run:: $> cd doc $> make html after which HTML documentation will be in doc/_build/html. Or you can just access the documentation from within the Python interpreter after installation:: >>> import pyviennacl >>> help(pyviennacl) Authors and Contact =================== PyViennaCL was developed during the 2013 *Google Summer of Code* by `Toby St Clere Smithe `_. ViennaCL was developed under the aegis of the *Institute for Microelectronics* at the *Vienna University of Technology*. For any technical questions related to ViennaCL, please use `our mailing list `_. Licence ======= (Py)ViennaCL is distributed under the MIT (X11) License. See the file LICENSE in the source root directory. pyviennacl-1.0.2+dfsg.orig/MANIFEST.in0000644000000000000000000000160112332257206015774 0ustar rootrootinclude ChangeLog include configure.py include Makefile.in include aksetup_helper.py include README.rst recursive-include doc * prune doc/_build include examples/*.py include examples/README recursive-include external/boost-python-ublas-subset/boost_subset/boost *.h *.hpp *.inl *.ipp *.pl *.txt recursive-include external/boost-python-ublas-subset/boost_subset/libs *.h *.hpp *.cpp *.html *.inl *.ipp *.pl *.txt exclude external/boost-python-ublas-subset/boost_subset/pyviennaclboost recursive-include external/boost_numpy/boost *.h *.hpp *.inl *.ipp *.pl *.txt recursive-include external/boost_numpy/libs *.h *.hpp *.cpp *.html *.inl *.ipp *.pl *.txt recursive-include external/viennacl-dev/CL *.h *.hpp recursive-include external/viennacl-dev/viennacl *.h *.hpp include pyviennacl/*.py include src/_viennacl/*.h include src/_viennacl/*.hpp include src/_viennacl/*.cpp include tests/*.py pyviennacl-1.0.2+dfsg.orig/aksetup_helper.py0000644000000000000000000006274312307335633017644 0ustar rootrootimport setuptools # noqa from setuptools import Extension def count_down_delay(delay): from time import sleep import sys while delay: sys.stdout.write("Continuing in %d seconds... \r" % delay) sys.stdout.flush() delay -= 1 sleep(1) print("") DASH_SEPARATOR = 75 * "-" def setup(*args, **kwargs): from setuptools import setup try: setup(*args, **kwargs) except KeyboardInterrupt: raise except SystemExit: raise except: print(DASH_SEPARATOR) print("Sorry, your build failed. Try rerunning configure.py with " "different options.") print(DASH_SEPARATOR) raise class NumpyExtension(Extension): # nicked from # http://mail.python.org/pipermail/distutils-sig/2007-September/008253.html # solution by Michael Hoffmann def __init__(self, *args, **kwargs): Extension.__init__(self, *args, **kwargs) self._include_dirs = self.include_dirs del self.include_dirs # restore overwritten property def get_numpy_incpath(self): from imp import find_module # avoid actually importing numpy, it screws up distutils file, pathname, descr = find_module("numpy") from os.path import join return join(pathname, "core", "include") def get_include_dirs(self): return self._include_dirs + [self.get_numpy_incpath()] def set_include_dirs(self, value): self._include_dirs = value def del_include_dirs(self): pass include_dirs = property(get_include_dirs, set_include_dirs, del_include_dirs) class PyUblasExtension(NumpyExtension): def get_module_include_path(self, name): from pkg_resources import Requirement, resource_filename return resource_filename(Requirement.parse(name), "%s/include" % name) @property def include_dirs(self): return self._include_dirs + [ self.get_numpy_incpath(), self.get_module_include_path("pyublas"), ] class HedgeExtension(PyUblasExtension): @property def include_dirs(self): return self._include_dirs + [ self.get_numpy_incpath(), self.get_module_include_path("pyublas"), self.get_module_include_path("hedge"), ] # {{{ tools def flatten(list): """For an iterable of sub-iterables, generate each member of each sub-iterable in turn, i.e. a flattened version of that super-iterable. Example: Turn [[a,b,c],[d,e,f]] into [a,b,c,d,e,f]. """ for sublist in list: for j in sublist: yield j def humanize(sym_str): words = sym_str.lower().replace("_", " ").split(" ") return " ".join([word.capitalize() for word in words]) # }}} # {{{ siteconf handling def get_config(schema=None, warn_about_no_config=True): if schema is None: from setup import get_config_schema schema = get_config_schema() if (not schema.have_config() and not schema.have_global_config() and warn_about_no_config): print("*************************************************************") print("*** I have detected that you have not run configure.py.") print("*************************************************************") print("*** Additionally, no global config files were found.") print("*** I will go ahead with the default configuration.") print("*** In all likelihood, this will not work out.") print("*** ") print("*** See README_SETUP.txt for more information.") print("*** ") print("*** If the build does fail, just re-run configure.py with the") print("*** correct arguments, and then retry. Good luck!") print("*************************************************************") print("*** HIT Ctrl-C NOW IF THIS IS NOT WHAT YOU WANT") print("*************************************************************") count_down_delay(delay=10) return expand_options(schema.read_config()) def hack_distutils(debug=False, fast_link=True, what_opt=3): # hack distutils.sysconfig to eliminate debug flags # stolen from mpi4py def remove_prefixes(optlist, bad_prefixes): for bad_prefix in bad_prefixes: for i, flag in enumerate(optlist): if flag.startswith(bad_prefix): optlist.pop(i) break return optlist import sys if not sys.platform.lower().startswith("win"): from distutils import sysconfig cvars = sysconfig.get_config_vars() cflags = cvars.get('OPT') if cflags: cflags = remove_prefixes(cflags.split(), ['-g', '-O', '-Wstrict-prototypes', '-DNDEBUG']) if debug: cflags.append("-g") else: if what_opt is None: pass else: cflags.append("-O%s" % what_opt) cflags.append("-DNDEBUG") cvars['OPT'] = str.join(' ', cflags) cvars["CFLAGS"] = cvars["BASECFLAGS"] + " " + cvars["OPT"] if fast_link: for varname in ["LDSHARED", "BLDSHARED"]: ldsharedflags = cvars.get(varname) if ldsharedflags: ldsharedflags = remove_prefixes(ldsharedflags.split(), ['-Wl,-O']) cvars[varname] = str.join(' ', ldsharedflags) # }}} # {{{ configure guts def default_or(a, b): if a is None: return b else: return a def expand_str(s, options): import re def my_repl(match): sym = match.group(1) try: repl = options[sym] except KeyError: from os import environ repl = environ[sym] return expand_str(repl, options) return re.subn(r"\$\{([a-zA-Z0-9_]+)\}", my_repl, s)[0] def expand_value(v, options): if isinstance(v, str): return expand_str(v, options) elif isinstance(v, list): result = [] for i in v: try: exp_i = expand_value(i, options) except: pass else: result.append(exp_i) return result else: return v def expand_options(options): return dict( (k, expand_value(v, options)) for k, v in options.items()) class ConfigSchema: def __init__(self, options, conf_file="siteconf.py", conf_dir="."): self.optdict = dict((opt.name, opt) for opt in options) self.options = options self.conf_dir = conf_dir self.conf_file = conf_file from os.path import expanduser self.user_conf_file = expanduser("~/.aksetup-defaults.py") import sys if not sys.platform.lower().startswith("win"): self.global_conf_file = "/etc/aksetup-defaults.py" else: self.global_conf_file = None def get_conf_file(self): import os return os.path.join(self.conf_dir, self.conf_file) def set_conf_dir(self, conf_dir): self.conf_dir = conf_dir def get_default_config(self): return dict((opt.name, opt.default) for opt in self.options) def read_config_from_pyfile(self, filename): result = {} filevars = {} infile = open(filename, "r") try: contents = infile.read() finally: infile.close() exec(compile(contents, filename, "exec"), filevars) for key, value in filevars.items(): if key in self.optdict: result[key] = value return result def update_conf_file(self, filename, config): result = {} filevars = {} try: exec(compile(open(filename, "r").read(), filename, "exec"), filevars) except IOError: pass if "__builtins__" in filevars: del filevars["__builtins__"] for key, value in config.items(): if value is not None: filevars[key] = value keys = filevars.keys() keys.sort() outf = open(filename, "w") for key in keys: outf.write("%s = %s\n" % (key, repr(filevars[key]))) outf.close() return result def update_user_config(self, config): self.update_conf_file(self.user_conf_file, config) def update_global_config(self, config): if self.global_conf_file is not None: self.update_conf_file(self.global_conf_file, config) def get_default_config_with_files(self): result = self.get_default_config() import os confignames = [] if self.global_conf_file is not None: confignames.append(self.global_conf_file) confignames.append(self.user_conf_file) for fn in confignames: if os.access(fn, os.R_OK): result.update(self.read_config_from_pyfile(fn)) return result def have_global_config(self): import os result = os.access(self.user_conf_file, os.R_OK) if self.global_conf_file is not None: result = result or os.access(self.global_conf_file, os.R_OK) return result def have_config(self): import os return os.access(self.get_conf_file(), os.R_OK) def read_config(self, warn_if_none=True): import os cfile = self.get_conf_file() result = self.get_default_config_with_files() if os.access(cfile, os.R_OK): filevars = {} exec(compile(open(cfile, "r").read(), cfile, "exec"), filevars) for key, value in filevars.items(): if key in self.optdict: result[key] = value elif key == "__builtins__": pass else: raise KeyError("invalid config key in %s: %s" % ( cfile, key)) return result def add_to_configparser(self, parser, def_config=None): if def_config is None: def_config = self.get_default_config_with_files() for opt in self.options: default = default_or(def_config.get(opt.name), opt.default) opt.add_to_configparser(parser, default) def get_from_configparser(self, options): result = {} for opt in self.options: result[opt.name] = opt.take_from_configparser(options) return result def write_config(self, config): outf = open(self.get_conf_file(), "w") for opt in self.options: value = config[opt.name] if value is not None: outf.write("%s = %s\n" % (opt.name, repr(config[opt.name]))) outf.close() def make_substitutions(self, config): return dict((opt.name, opt.value_to_str(config[opt.name])) for opt in self.options) class Option(object): def __init__(self, name, default=None, help=None): self.name = name self.default = default self.help = help def as_option(self): return self.name.lower().replace("_", "-") def metavar(self): last_underscore = self.name.rfind("_") return self.name[last_underscore+1:] def get_help(self, default): result = self.help if self.default: result += " (default: %s)" % self.value_to_str( default_or(default, self.default)) return result def value_to_str(self, default): return default def add_to_configparser(self, parser, default=None): default = default_or(default, self.default) default_str = self.value_to_str(default) parser.add_option( "--" + self.as_option(), dest=self.name, default=default_str, metavar=self.metavar(), help=self.get_help(default)) def take_from_configparser(self, options): return getattr(options, self.name) class Switch(Option): def add_to_configparser(self, parser, default=None): if not isinstance(self.default, bool): raise ValueError("Switch options must have a default") if default is None: default = self.default option_name = self.as_option() if default: option_name = "no-" + option_name action = "store_false" else: action = "store_true" parser.add_option( "--" + option_name, dest=self.name, help=self.get_help(default), default=default, action=action) class StringListOption(Option): def value_to_str(self, default): if default is None: return None return ",".join([str(el).replace(",", r"\,") for el in default]) def get_help(self, default): return Option.get_help(self, default) + " (several ok)" def take_from_configparser(self, options): opt = getattr(options, self.name) if opt is None: return None else: if opt: import re sep = re.compile(r"(? #include #include #include namespace boost { namespace numpy { /** * @brief A boost.python "object manager" (subclass of object) for PyArray_MultiIter. * * multi_iter is a Python object, but a very low-level one. It should generally only be used * in loops of the form: * @code * while (iter.not_done()) { * ... * iter.next(); * } * @endcode * * @todo I can't tell if this type is exposed in Python anywhere; if it is, we should use that name. * It's more dangerous than most object managers, however - maybe it actually belongs in * a detail namespace? */ class multi_iter : public python::object { public: BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(multi_iter, python::object); /// @brief Increment the iterator. void next(); /// @brief Check if the iterator is at its end. bool not_done() const; /// @brief Return a pointer to the element of the nth broadcasted array. char * get_data(int n) const; /// @brief Return the number of dimensions of the broadcasted array expression. int const get_nd() const; /// @brief Return the shape of the broadcasted array expression as an array of integers. Py_intptr_t const * get_shape() const; /// @brief Return the shape of the broadcasted array expression in the nth dimension. Py_intptr_t const shape(int n) const; }; /// @brief Construct a multi_iter over a single sequence or scalar object. multi_iter make_multi_iter(python::object const & a1); /// @brief Construct a multi_iter by broadcasting two objects. multi_iter make_multi_iter(python::object const & a1, python::object const & a2); /// @brief Construct a multi_iter by broadcasting three objects. multi_iter make_multi_iter(python::object const & a1, python::object const & a2, python::object const & a3); /** * @brief Helps wrap a C++ functor taking a single scalar argument as a broadcasting ufunc-like * Python object. * * Typical usage looks like this: * @code * struct TimesPI * { * typedef double argument_type; * typedef double result_type; * double operator()(double input) const { return input * M_PI; } * }; * * BOOST_PYTHON_MODULE(example) * { * class_< TimesPI >("TimesPI") * .def("__call__", unary_ufunc::make()); * } * @endcode * */ template struct unary_ufunc { /** * @brief A C++ function with object arguments that broadcasts its arguments before * passing them to the underlying C++ functor. */ static python::object call(TUnaryFunctor & self, python::object const & input, python::object const & output) { dtype in_dtype = dtype::get_builtin(); dtype out_dtype = dtype::get_builtin(); ndarray in_array = from_object(input, in_dtype, ndarray::ALIGNED); ndarray out_array = (output != python::object()) ? from_object(output, out_dtype, ndarray::ALIGNED | ndarray::WRITEABLE) : zeros(in_array.get_nd(), in_array.get_shape(), out_dtype); multi_iter iter = make_multi_iter(in_array, out_array); while (iter.not_done()) { TArgument * argument = reinterpret_cast(iter.get_data(0)); TResult * result = reinterpret_cast(iter.get_data(1)); *result = self(*argument); iter.next(); } return out_array.scalarize(); } /** * @brief Construct a boost.python function object from call() with reasonable keyword names. * * Users will often want to specify their own keyword names with the same signature, but this * is a convenient shortcut. */ static python::object make() { namespace p = python; return p::make_function(call, p::default_call_policies(), (p::arg("input"), p::arg("output")=p::object())); } }; /** * @brief Helps wrap a C++ functor taking a pair of scalar arguments as a broadcasting ufunc-like * Python object. * * Typical usage looks like this: * @code * struct CosSum * { * typedef double first_argument_type; * typedef double second_argument_type; * typedef double result_type; * double operator()(double input1, double input2) const { return std::cos(input1 + input2); } * }; * * BOOST_PYTHON_MODULE(example) * { * class_< CosSum >("CosSum") * .def("__call__", binary_ufunc::make()); * } * @endcode * */ template struct binary_ufunc { static python::object call(TBinaryFunctor & self, python::object const & input1, python::object const & input2, python::object const & output) { dtype in1_dtype = dtype::get_builtin(); dtype in2_dtype = dtype::get_builtin(); dtype out_dtype = dtype::get_builtin(); ndarray in1_array = from_object(input1, in1_dtype, ndarray::ALIGNED); ndarray in2_array = from_object(input2, in2_dtype, ndarray::ALIGNED); multi_iter iter = make_multi_iter(in1_array, in2_array); ndarray out_array = (output != python::object()) ? from_object(output, out_dtype, ndarray::ALIGNED | ndarray::WRITEABLE) : zeros(iter.get_nd(), iter.get_shape(), out_dtype); iter = make_multi_iter(in1_array, in2_array, out_array); while (iter.not_done()) { TArgument1 * argument1 = reinterpret_cast(iter.get_data(0)); TArgument2 * argument2 = reinterpret_cast(iter.get_data(1)); TResult * result = reinterpret_cast(iter.get_data(2)); *result = self(*argument1, *argument2); iter.next(); } return out_array.scalarize(); } static python::object make() { namespace p = python; return p::make_function(call, p::default_call_policies(), (p::arg("input1"), p::arg("input2"), p::arg("output")=p::object())); } }; } // namespace boost::numpy namespace python { namespace converter { NUMPY_OBJECT_MANAGER_TRAITS(numpy::multi_iter); } // namespace boost::python::converter } // namespace boost::python } // namespace boost #endif // !BOOST_NUMPY_UFUNC_HPP_INCLUDED pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/boost/numpy/dtype.hpp0000644000000000000000000000676112307353133024604 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NUMPY_DTYPE_HPP_INCLUDED #define BOOST_NUMPY_DTYPE_HPP_INCLUDED /** * @file boost/numpy/dtype.hpp * @brief Object manager for Python's numpy.dtype class. */ #include #include #include #include namespace boost { namespace numpy { /** * @brief A boost.python "object manager" (subclass of object) for numpy.dtype. * * @todo This could have a lot more interesting accessors. */ class dtype : public python::object { static python::detail::new_reference convert(python::object::object_cref arg, bool align); public: /// @brief Convert an arbitrary Python object to a data-type descriptor object. template explicit dtype(T arg, bool align=false) : python::object(convert(arg, align)) {} /** * @brief Get the built-in numpy dtype associated with the given scalar template type. * * This is perhaps the most useful part of the numpy API: it returns the dtype object * corresponding to a built-in C++ type. This should work for any integer or floating point * type supported by numpy, and will also work for std::complex if * sizeof(std::complex) == 2*sizeof(T). * * It can also be useful for users to add explicit specializations for POD structs * that return field-based dtypes. */ template static dtype get_builtin(); /// @brief Return the size of the data type in bytes. int get_itemsize() const; /** * @brief Compare two dtypes for equivalence. * * This is more permissive than equality tests. For instance, if long and int are the same * size, the dtypes corresponding to each will be equivalent, but not equal. */ friend bool equivalent(dtype const & a, dtype const & b); /** * @brief Register from-Python converters for NumPy's built-in array scalar types. * * This is usually called automatically by initialize(), and shouldn't be called twice * (doing so just adds unused converters to the Boost.Python registry). */ static void register_scalar_converters(); BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(dtype, python::object); }; bool equivalent(dtype const & a, dtype const & b); namespace detail { template dtype get_int_dtype(); template dtype get_float_dtype(); template dtype get_complex_dtype(); template ::value> struct builtin_dtype; template struct builtin_dtype { static dtype get() { return get_int_dtype< 8*sizeof(T), boost::is_unsigned::value >(); } }; template <> struct builtin_dtype { static dtype get(); }; template struct builtin_dtype { static dtype get() { return get_float_dtype< 8*sizeof(T) >(); } }; template struct builtin_dtype< std::complex, false > { static dtype get() { return get_complex_dtype< 16*sizeof(T) >(); } }; } // namespace detail template inline dtype dtype::get_builtin() { return detail::builtin_dtype::get(); } }} // namespace boost::numpy namespace boost { namespace python { namespace converter { NUMPY_OBJECT_MANAGER_TRAITS(numpy::dtype); }}} // namespace boost::python::converter #endif // !BOOST_NUMPY_DTYPE_HPP_INCLUDED pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/boost/numpy/internal.hpp0000644000000000000000000000210612307353133025260 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NUMPY_INTERNAL_HPP_INCLUDED #define BOOST_NUMPY_INTERNAL_HPP_INCLUDED /** * @file boost/numpy/internal.hpp * @brief Internal header file to include the Numpy C-API headers. * * This should only be included by source files in the boost.numpy library itself. */ #include #ifdef BOOST_NUMPY_INTERNAL #define NO_IMPORT_ARRAY #define NO_IMPORT_UFUNC #else #ifndef BOOST_NUMPY_INTERNAL_MAIN ERROR_internal_hpp_is_for_internal_use_only #endif #endif #define PY_ARRAY_UNIQUE_SYMBOL BOOST_NUMPY_ARRAY_API #define PY_UFUNC_UNIQUE_SYMBOL BOOST_UFUNC_ARRAY_API #include #include #include #define NUMPY_OBJECT_MANAGER_TRAITS_IMPL(pytype,manager) \ PyTypeObject const * object_manager_traits::get_pytype() { return &pytype; } #endif // !BOOST_NUMPY_INTERNAL_HPP_INCLUDED pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/boost/numpy/ndarray.hpp0000644000000000000000000002464112307353133025114 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NUMPY_NDARRAY_HPP_INCLUDED #define BOOST_NUMPY_NDARRAY_HPP_INCLUDED /** * @file boost/numpy/ndarray.hpp * @brief Object manager and various utilities for numpy.ndarray. */ #include #include #include #include #include #include namespace boost { namespace numpy { /** * @brief A boost.python "object manager" (subclass of object) for numpy.ndarray. * * @todo This could have a lot more functionality (like boost::python::numeric::array). * Right now all that exists is what was needed to move raw data between C++ and Python. */ class ndarray : public python::object { /** * @brief An internal struct that's byte-compatible with PyArrayObject. * * This is just a hack to allow inline access to this stuff while hiding numpy/arrayobject.h * from the user. */ struct array_struct { PyObject_HEAD char * data; int nd; Py_intptr_t * shape; Py_intptr_t * strides; PyObject * base; PyObject * descr; int flags; PyObject * weakreflist; }; /// @brief Return the held Python object as an array_struct. array_struct * get_struct() const { return reinterpret_cast(this->ptr()); } public: /** * @brief Enum to represent (some) of Numpy's internal flags. * * These don't match the actual Numpy flag values; we can't get those without including * numpy/arrayobject.h or copying them directly. That's very unfortunate. * * @todo I'm torn about whether this should be an enum. It's very convenient to not * make these simple integer values for overloading purposes, but the need to * define every possible combination and custom bitwise operators is ugly. */ enum bitflag { NONE=0x0, C_CONTIGUOUS=0x1, F_CONTIGUOUS=0x2, V_CONTIGUOUS=0x1|0x2, ALIGNED=0x4, WRITEABLE=0x8, BEHAVED=0x4|0x8, CARRAY_RO=0x1|0x4, CARRAY=0x1|0x4|0x8, CARRAY_MIS=0x1|0x8, FARRAY_RO=0x2|0x4, FARRAY=0x2|0x4|0x8, FARRAY_MIS=0x2|0x8, UPDATE_ALL=0x1|0x2|0x4, VARRAY=0x1|0x2|0x8, ALL=0x1|0x2|0x4|0x8 }; BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(ndarray, object); /// @brief Return a view of the scalar with the given dtype. ndarray view(dtype const & dt) const; /// @brief Copy the array, cast to a specified type. ndarray astype(dtype const & dt) const; /// @brief Copy the scalar (deep for all non-object fields). ndarray copy() const; /// @brief Return the size of the nth dimension. int const shape(int n) const { return get_shape()[n]; } /// @brief Return the stride of the nth dimension. int const strides(int n) const { return get_strides()[n]; } /** * @brief Return the array's raw data pointer. * * This returns char so stride math works properly on it. It's pretty much * expected that the user will have to reinterpret_cast it. */ char * get_data() const { return get_struct()->data; } /// @brief Return the array's data-type descriptor object. dtype get_dtype() const; /// @brief Return the object that owns the array's data, or None if the array owns its own data. python::object get_base() const; /// @brief Set the object that owns the array's data. Use with care. void set_base(object const & base); /// @brief Return the shape of the array as an array of integers (length == get_nd()). Py_intptr_t const * get_shape() const { return get_struct()->shape; } /// @brief Return the stride of the array as an array of integers (length == get_nd()). Py_intptr_t const * get_strides() const { return get_struct()->strides; } /// @brief Return the number of array dimensions. int const get_nd() const { return get_struct()->nd; } /// @brief Return the array flags. bitflag const get_flags() const; /// @brief Reverse the dimensions of the array. ndarray transpose() const; /// @brief Eliminate any unit-sized dimensions. ndarray squeeze() const; /// @brief Equivalent to self.reshape(*shape) in Python. ndarray reshape(python::tuple const & shape) const; /** * @brief If the array contains only a single element, return it as an array scalar; otherwise return * the array. * * @internal This is simply a call to PyArray_Return(); */ python::object scalarize() const; }; /** * @brief Construct a new array with the given shape and data type, with data initialized to zero. */ ndarray zeros(python::tuple const & shape, dtype const & dt); ndarray zeros(int nd, Py_intptr_t const * shape, dtype const & dt); /** * @brief Construct a new array with the given shape and data type, with data left uninitialized. */ ndarray empty(python::tuple const & shape, dtype const & dt); ndarray empty(int nd, Py_intptr_t const * shape, dtype const & dt); /** * @brief Construct a new array from an arbitrary Python sequence. * * @todo This does't seem to handle ndarray subtypes the same way that "numpy.array" does in Python. */ ndarray array(python::object const & obj); ndarray array(python::object const & obj, dtype const & dt); namespace detail { ndarray from_data_impl(void * data, dtype const & dt, std::vector const & shape, std::vector const & strides, python::object const & owner, bool writeable); template ndarray from_data_impl(void * data, dtype const & dt, Container shape, Container strides, python::object const & owner, bool writeable, typename boost::enable_if< boost::is_integral >::type * enabled = NULL) { std::vector shape_(shape.begin(),shape.end()); std::vector strides_(strides.begin(), strides.end()); return from_data_impl(data, dt, shape_, strides_, owner, writeable); } ndarray from_data_impl(void * data, dtype const & dt, python::object const & shape, python::object const & strides, python::object const & owner, bool writeable); } // namespace boost::numpy::detail /** * @brief Construct a new ndarray object from a raw pointer. * * @param[in] data Raw pointer to the first element of the array. * @param[in] dt Data type descriptor. Often retrieved with dtype::get_builtin(). * @param[in] shape Shape of the array as STL container of integers; must have begin() and end(). * @param[in] strides Shape of the array as STL container of integers; must have begin() and end(). * @param[in] owner An arbitray Python object that owns that data pointer. The array object will * keep a reference to the object, and decrement it's reference count when the * array goes out of scope. Pass None at your own peril. * * @todo Should probably take ranges of iterators rather than actual container objects. */ template inline ndarray from_data(void * data, dtype const & dt, Container shape, Container strides, python::object const & owner) { return numpy::detail::from_data_impl(data, dt, shape, strides, owner, true); } /** * @brief Construct a new ndarray object from a raw pointer. * * @param[in] data Raw pointer to the first element of the array. * @param[in] dt Data type descriptor. Often retrieved with dtype::get_builtin(). * @param[in] shape Shape of the array as STL container of integers; must have begin() and end(). * @param[in] strides Shape of the array as STL container of integers; must have begin() and end(). * @param[in] owner An arbitray Python object that owns that data pointer. The array object will * keep a reference to the object, and decrement it's reference count when the * array goes out of scope. Pass None at your own peril. * * This overload takes a const void pointer and sets the "writeable" flag of the array to false. * * @todo Should probably take ranges of iterators rather than actual container objects. */ template inline ndarray from_data(void const * data, dtype const & dt, Container shape, Container strides, python::object const & owner) { return numpy::detail::from_data_impl(const_cast(data), dt, shape, strides, owner, false); } /** * @brief Transform an arbitrary object into a numpy array with the given requirements. * * @param[in] obj An arbitrary python object to convert. Arrays that meet the requirements * will be passed through directly. * @param[in] dt Data type descriptor. Often retrieved with dtype::get_builtin(). * @param[in] nd_min Minimum number of dimensions. * @param[in] nd_max Maximum number of dimensions. * @param[in] flags Bitwise OR of flags specifying additional requirements. */ ndarray from_object(python::object const & obj, dtype const & dt, int nd_min, int nd_max, ndarray::bitflag flags=ndarray::NONE); inline ndarray from_object(python::object const & obj, dtype const & dt, int nd, ndarray::bitflag flags=ndarray::NONE) { return from_object(obj, dt, nd, nd, flags); } inline ndarray from_object(python::object const & obj, dtype const & dt, ndarray::bitflag flags=ndarray::NONE) { return from_object(obj, dt, 0, 0, flags); } ndarray from_object(python::object const & obj, int nd_min, int nd_max, ndarray::bitflag flags=ndarray::NONE); inline ndarray from_object(python::object const & obj, int nd, ndarray::bitflag flags=ndarray::NONE) { return from_object(obj, nd, nd, flags); } inline ndarray from_object(python::object const & obj, ndarray::bitflag flags=ndarray::NONE) { return from_object(obj, 0, 0, flags); } inline ndarray::bitflag operator|(ndarray::bitflag a, ndarray::bitflag b) { return ndarray::bitflag(int(a) | int(b)); } inline ndarray::bitflag operator&(ndarray::bitflag a, ndarray::bitflag b) { return ndarray::bitflag(int(a) & int(b)); } } // namespace boost::numpy namespace python { namespace converter { NUMPY_OBJECT_MANAGER_TRAITS(numpy::ndarray); } // namespace boost::python::converter } // namespace boost::python } // namespace boost #endif // !BOOST_NUMPY_NDARRAY_HPP_INCLUDED pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/boost/numpy/invoke_matching.hpp0000644000000000000000000001133612307353133026616 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NUMPY_INVOKE_MATCHING_HPP_INCLUDED #define BOOST_NUMPY_INVOKE_MATCHING_HPP_INCLUDED /** * @file boost/numpy/invoke_matching.hpp * @brief Template invocation based on dtype matching. */ #include #include #include namespace boost { namespace numpy { namespace detail { struct add_pointer_meta { template struct apply { typedef typename boost::add_pointer::type type; }; }; struct dtype_template_match_found {}; struct nd_template_match_found {}; template struct dtype_template_invoker { template void operator()(T *) const { if (dtype::get_builtin() == m_dtype) { m_func.Function::template apply(); throw dtype_template_match_found(); } } dtype_template_invoker(dtype const & dtype_, Function func) : m_dtype(dtype_), m_func(func) {} private: dtype const & m_dtype; Function m_func; }; template struct dtype_template_invoker< boost::reference_wrapper > { template void operator()(T *) const { if (dtype::get_builtin() == m_dtype) { m_func.Function::template apply(); throw dtype_template_match_found(); } } dtype_template_invoker(dtype const & dtype_, Function & func) : m_dtype(dtype_), m_func(func) {} private: dtype const & m_dtype; Function & m_func; }; template struct nd_template_invoker { template void operator()(boost::mpl::integral_c *) const { if (m_nd == N) { m_func.Function::template apply(); throw nd_template_match_found(); } } nd_template_invoker(int nd, Function func) : m_nd(nd), m_func(func) {} private: int m_nd; Function m_func; }; template struct nd_template_invoker< boost::reference_wrapper > { template void operator()(boost::mpl::integral_c *) const { if (m_nd == N) { m_func.Function::template apply(); throw nd_template_match_found(); } } nd_template_invoker(int nd, Function & func) : m_nd(nd), m_func(func) {} private: int m_nd; Function & m_func; }; } // namespace boost::numpy::detail template void invoke_matching_nd(int nd, Function f) { detail::nd_template_invoker invoker(nd, f); try { boost::mpl::for_each< Sequence, detail::add_pointer_meta >(invoker);} catch (detail::nd_template_match_found &) { return;} PyErr_SetString(PyExc_TypeError, "number of dimensions not found in template list."); python::throw_error_already_set(); } template void invoke_matching_dtype(dtype const & dtype_, Function f) { detail::dtype_template_invoker invoker(dtype_, f); try { boost::mpl::for_each< Sequence, detail::add_pointer_meta >(invoker);} catch (detail::dtype_template_match_found &) { return;} PyErr_SetString(PyExc_TypeError, "dtype not found in template list."); python::throw_error_already_set(); } namespace detail { template struct array_template_invoker_wrapper_2 { template void apply() const { m_func.Function::template apply();} array_template_invoker_wrapper_2(Function & func) : m_func(func) {} private: Function & m_func; }; template struct array_template_invoker_wrapper_1 { template void apply() const { invoke_matching_nd(m_nd, array_template_invoker_wrapper_2(m_func));} array_template_invoker_wrapper_1(int nd, Function & func) : m_nd(nd), m_func(func) {} private: int m_nd; Function & m_func; }; template struct array_template_invoker_wrapper_1< DimSequence, boost::reference_wrapper > : public array_template_invoker_wrapper_1< DimSequence, Function > { array_template_invoker_wrapper_1(int nd, Function & func) : array_template_invoker_wrapper_1< DimSequence, Function >(nd, func) {} }; } // namespace boost::numpy::detail template void invoke_matching_array(ndarray const & array_, Function f) { detail::array_template_invoker_wrapper_1 wrapper(array_.get_nd(), f); invoke_matching_dtype(array_.get_dtype(), wrapper); } } // namespace boost::numpy } // namespace boost #endif // !BOOST_NUMPY_INVOKE_MATCHING_HPP_INCLUDED pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/boost/numpy/matrix.hpp0000644000000000000000000000527412307353133024761 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NUMPY_MATRIX_HPP_INCLUDED #define BOOST_NUMPY_MATRIX_HPP_INCLUDED /** * @file boost/numpy/matrix.hpp * @brief Object manager for numpy.matrix. */ #include #include #include namespace boost { namespace numpy { /** * @brief A boost.python "object manager" (subclass of object) for numpy.matrix. * * @internal numpy.matrix is defined in Python, so object_manager_traits::get_pytype() * is implemented by importing numpy and getting the "matrix" attribute of the module. * We then just hope that doesn't get destroyed while we need it, because if we put * a dynamic python object in a static-allocated boost::python::object or handle<>, * bad things happen when Python shuts down. I think this solution is safe, but I'd * love to get that confirmed. */ class matrix : public ndarray { static python::object construct(object_cref obj, dtype const & dt, bool copy); static python::object construct(object_cref obj, bool copy); public: BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(matrix, ndarray); /// @brief Equivalent to "numpy.matrix(obj,dt,copy)" in Python. explicit matrix(python::object const & obj, dtype const & dt, bool copy=true) : ndarray(python::extract(construct(obj, dt, copy))) {} /// @brief Equivalent to "numpy.matrix(obj,copy=copy)" in Python. explicit matrix(python::object const & obj, bool copy=true) : ndarray(python::extract(construct(obj, copy))) {} /// \brief Return a view of the matrix with the given dtype. matrix view(dtype const & dt) const; /// \brief Copy the scalar (deep for all non-object fields). matrix copy() const; /// \brief Transpose the matrix. matrix transpose() const; }; /** * @brief CallPolicies that causes a function that returns a numpy.ndarray to * return a numpy.matrix instead. */ template struct as_matrix : Base { static PyObject * postcall(PyObject *, PyObject * result) { python::object a = python::object(python::handle<>(result)); numpy::matrix m(a, false); Py_INCREF(m.ptr()); return m.ptr(); } }; } // namespace boost::numpy namespace python { namespace converter { NUMPY_OBJECT_MANAGER_TRAITS(numpy::matrix); } // namespace boost::python::converter } // namespace boost::python } // namespace boost #endif // !BOOST_NUMPY_MATRIX_HPP_INCLUDED pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/boost/numpy/scalars.hpp0000644000000000000000000000320412307353133025074 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NUMPY_SCALARS_HPP_INCLUDED #define BOOST_NUMPY_SCALARS_HPP_INCLUDED /** * @file boost/numpy/scalars.hpp * @brief Object managers for array scalars (currently only numpy.void is implemented). */ #include #include #include namespace boost { namespace numpy { /** * @brief A boost.python "object manager" (subclass of object) for numpy.void. * * @todo This could have a lot more functionality. */ class void_ : public python::object { static python::detail::new_reference convert(object_cref arg, bool align); public: /** * @brief Construct a new array scalar with the given size and void dtype. * * Data is initialized to zero. One can create a standalone scalar object * with a certain dtype "dt" with: * @code * void_ scalar = void_(dt.get_itemsize()).view(dt); * @endcode */ explicit void_(Py_ssize_t size); BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(void_, object); /// @brief Return a view of the scalar with the given dtype. void_ view(dtype const & dt) const; /// @brief Copy the scalar (deep for all non-object fields). void_ copy() const; }; } // namespace boost::numpy namespace python { namespace converter { NUMPY_OBJECT_MANAGER_TRAITS(numpy::void_); } // namespace boost::python::converter } // namespace boost::python } // namespace boost #endif // !BOOST_NUMPY_SCALARS_HPP_INCLUDED pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/boost/numpy/numpy_object_mgr_traits.hpp0000644000000000000000000000246012307353133030400 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NUMPY_NUMPY_OBJECT_MGR_TRAITS_HPP_INCLUDED #define BOOST_NUMPY_NUMPY_OBJECT_MGR_TRAITS_HPP_INCLUDED /** * @file boost/numpy/numpy_object_mgr_traits.hpp * @brief Macro that specializes object_manager_traits by requiring a * source-file implementation of get_pytype(). */ #define NUMPY_OBJECT_MANAGER_TRAITS(manager) \ template <> \ struct object_manager_traits \ { \ BOOST_STATIC_CONSTANT(bool, is_specialized = true); \ static inline python::detail::new_reference adopt(PyObject* x) \ { \ return python::detail::new_reference(python::pytype_check((PyTypeObject*)get_pytype(), x)); \ } \ static bool check(PyObject* x) \ { \ return ::PyObject_IsInstance(x, (PyObject*)get_pytype()); \ } \ static manager* checked_downcast(PyObject* x) \ { \ return python::downcast((checked_downcast_impl)(x, (PyTypeObject*)get_pytype())); \ } \ static PyTypeObject const * get_pytype(); \ } #endif // !BOOST_NUMPY_NUMPY_OBJECT_MGR_TRAITS_HPP_INCLUDED pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/boost/numpy.hpp0000644000000000000000000000212312307353133023443 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NUMPY_HPP_INCLUDED #define BOOST_NUMPY_HPP_INCLUDED /** * @file boost/numpy.hpp * @brief Main public header file for boost.numpy. */ #include #include #include #include #include #include namespace boost { namespace numpy { /** * @brief Initialize the Numpy C-API * * This must be called before using anything in boost.numpy; * It should probably be the first line inside BOOST_PYTHON_MODULE. * * @internal This just calls the Numpy C-API functions "import_array()" * and "import_ufunc()", and then calls * dtype::register_scalar_converters(). */ void initialize(bool register_scalar_converters=true); } // namespace boost::numpy } // namespace boost #endif // !BOOST_NUMPY_HPP_INCLUDED pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/0000755000000000000000000000000012332260014021360 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/0000755000000000000000000000000012332260014022530 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/src/0000755000000000000000000000000012332260016023321 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/src/ufunc.cpp0000644000000000000000000000325412307353133025156 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_NUMPY_INTERNAL #include #include namespace boost { namespace python { namespace converter { NUMPY_OBJECT_MANAGER_TRAITS_IMPL(PyArrayMultiIter_Type, numpy::multi_iter) } // namespace boost::python::converter } // namespace boost::python namespace numpy { multi_iter make_multi_iter(python::object const & a1) { return multi_iter(python::detail::new_reference(PyArray_MultiIterNew(1, a1.ptr()))); } multi_iter make_multi_iter(python::object const & a1, python::object const & a2) { return multi_iter(python::detail::new_reference(PyArray_MultiIterNew(2, a1.ptr(), a2.ptr()))); } multi_iter make_multi_iter(python::object const & a1, python::object const & a2, python::object const & a3) { return multi_iter(python::detail::new_reference(PyArray_MultiIterNew(3, a1.ptr(), a2.ptr(), a3.ptr()))); } void multi_iter::next() { PyArray_MultiIter_NEXT(ptr()); } bool multi_iter::not_done() const { return PyArray_MultiIter_NOTDONE(ptr()); } char * multi_iter::get_data(int i) const { return reinterpret_cast(PyArray_MultiIter_DATA(ptr(), i)); } int const multi_iter::get_nd() const { return reinterpret_cast(ptr())->nd; } Py_intptr_t const * multi_iter::get_shape() const { return reinterpret_cast(ptr())->dimensions; } Py_intptr_t const multi_iter::shape(int n) const { return reinterpret_cast(ptr())->dimensions[n]; } } } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/src/numpy.cpp0000644000000000000000000000113512307353133025202 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_NUMPY_INTERNAL_MAIN #include #include namespace boost { namespace numpy { #if PY_MAJOR_VERSION >= 3 int #else void #endif do_import_array() { import_array(); } void initialize(bool register_scalar_converters) { do_import_array(); import_ufunc(); if (register_scalar_converters) dtype::register_scalar_converters(); } } } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/src/scalars.cpp0000644000000000000000000000200012307353133025452 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_NUMPY_INTERNAL #include namespace boost { namespace python { namespace converter { NUMPY_OBJECT_MANAGER_TRAITS_IMPL(PyVoidArrType_Type, numpy::void_) } // namespace boost::python::converter } // namespace boost::python namespace numpy { void_::void_(Py_ssize_t size) : object(python::detail::new_reference (PyObject_CallFunction((PyObject*)&PyVoidArrType_Type, const_cast("i"), size))) {} void_ void_::view(dtype const & dt) const { return void_(python::detail::new_reference (PyObject_CallMethod(this->ptr(), const_cast("view"), const_cast("O"), dt.ptr()))); } void_ void_::copy() const { return void_(python::detail::new_reference (PyObject_CallMethod(this->ptr(), const_cast("copy"), const_cast("")))); } } } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/src/ndarray.cpp0000644000000000000000000001777212307353133025510 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_NUMPY_INTERNAL #include #include namespace boost { namespace python { namespace converter { NUMPY_OBJECT_MANAGER_TRAITS_IMPL(PyArray_Type, numpy::ndarray) } // namespace boost::python::converter } // namespace boost::python namespace numpy { namespace detail { ndarray::bitflag numpy_to_bitflag(int const f) { ndarray::bitflag r = ndarray::NONE; if (f & NPY_C_CONTIGUOUS) r = (r | ndarray::C_CONTIGUOUS); if (f & NPY_F_CONTIGUOUS) r = (r | ndarray::F_CONTIGUOUS); if (f & NPY_ALIGNED) r = (r | ndarray::ALIGNED); if (f & NPY_WRITEABLE) r = (r | ndarray::WRITEABLE); return r; } int const bitflag_to_numpy(ndarray::bitflag f) { int r = 0; if (f & ndarray::C_CONTIGUOUS) r |= NPY_C_CONTIGUOUS; if (f & ndarray::F_CONTIGUOUS) r |= NPY_F_CONTIGUOUS; if (f & ndarray::ALIGNED) r |= NPY_ALIGNED; if (f & ndarray::WRITEABLE) r |= NPY_WRITEABLE; return r; } bool is_c_contiguous(std::vector const & shape, std::vector const & strides, int itemsize) { std::vector::const_reverse_iterator j = strides.rbegin(); int total = itemsize; for (std::vector::const_reverse_iterator i = shape.rbegin(); i != shape.rend(); ++i, ++j) { if (total != *j) return false; total *= (*i); } return true; } bool is_f_contiguous(std::vector const & shape, std::vector const & strides, int itemsize) { std::vector::const_iterator j = strides.begin(); int total = itemsize; for (std::vector::const_iterator i = shape.begin(); i != shape.end(); ++i, ++j) { if (total != *j) return false; total *= (*i); } return true; } bool is_aligned(std::vector const & strides, int itemsize) { for (std::vector::const_iterator i = strides.begin(); i != strides.end(); ++i) { if (*i % itemsize) return false; } return true; } inline PyArray_Descr * incref_dtype(dtype const & dt) { Py_INCREF(dt.ptr()); return reinterpret_cast(dt.ptr()); } ndarray from_data_impl(void * data, dtype const & dt, python::object const & shape, python::object const & strides, python::object const & owner, bool writeable) { std::vector shape_(len(shape)); std::vector strides_(len(strides)); if (shape_.size() != strides_.size()) { PyErr_SetString(PyExc_ValueError, "Length of shape and strides arrays do not match."); python::throw_error_already_set(); } for (std::size_t i = 0; i < shape_.size(); ++i) { shape_[i] = python::extract(shape[i]); strides_[i] = python::extract(strides[i]); } return from_data_impl(data, dt, shape_, strides_, owner, writeable); } ndarray from_data_impl(void * data, dtype const & dt, std::vector const & shape, std::vector const & strides, python::object const & owner, bool writeable) { if (shape.size() != strides.size()) { PyErr_SetString(PyExc_ValueError, "Length of shape and strides arrays do not match."); python::throw_error_already_set(); } int itemsize = dt.get_itemsize(); int flags = 0; if (writeable) flags |= NPY_WRITEABLE; if (is_c_contiguous(shape, strides, itemsize)) flags |= NPY_C_CONTIGUOUS; if (is_f_contiguous(shape, strides, itemsize)) flags |= NPY_F_CONTIGUOUS; if (is_aligned(strides, itemsize)) flags |= NPY_ALIGNED; ndarray r(python::detail::new_reference (PyArray_NewFromDescr(&PyArray_Type, incref_dtype(dt), shape.size(), const_cast(&shape.front()), const_cast(&strides.front()), data, flags, NULL))); r.set_base(owner); return r; } } // namespace detail ndarray ndarray::view(dtype const & dt) const { return ndarray(python::detail::new_reference (PyObject_CallMethod(this->ptr(), const_cast("view"), const_cast("O"), dt.ptr()))); } ndarray ndarray::astype(dtype const & dt) const { return ndarray(python::detail::new_reference (PyObject_CallMethod(this->ptr(), const_cast("astype"), const_cast("O"), dt.ptr()))); } ndarray ndarray::copy() const { return ndarray(python::detail::new_reference (PyObject_CallMethod(this->ptr(), const_cast("copy"), const_cast("")))); } dtype ndarray::get_dtype() const { return dtype(python::detail::borrowed_reference(get_struct()->descr)); } python::object ndarray::get_base() const { if (get_struct()->base == NULL) return object(); return python::object(python::detail::borrowed_reference(get_struct()->base)); } void ndarray::set_base(object const & base) { Py_XDECREF(get_struct()->base); if (base != object()) { Py_INCREF(base.ptr()); get_struct()->base = base.ptr(); } else { get_struct()->base = NULL; } } ndarray::bitflag const ndarray::get_flags() const { return numpy::detail::numpy_to_bitflag(get_struct()->flags); } ndarray ndarray::transpose() const { return ndarray(python::detail::new_reference (PyArray_Transpose(reinterpret_cast(this->ptr()), NULL))); } ndarray ndarray::squeeze() const { return ndarray(python::detail::new_reference (PyArray_Squeeze(reinterpret_cast(this->ptr())))); } ndarray ndarray::reshape(python::tuple const & shape) const { return ndarray(python::detail::new_reference (PyArray_Reshape(reinterpret_cast(this->ptr()), shape.ptr()))); } python::object ndarray::scalarize() const { Py_INCREF(ptr()); return python::object(python::detail::new_reference(PyArray_Return(reinterpret_cast(ptr())))); } ndarray zeros(python::tuple const & shape, dtype const & dt) { int nd = len(shape); boost::scoped_array dims(new Py_intptr_t[nd]); for (int n=0; n(shape[n]); return ndarray(python::detail::new_reference (PyArray_Zeros(nd, dims.get(), detail::incref_dtype(dt), 0))); } ndarray zeros(int nd, Py_intptr_t const * shape, dtype const & dt) { return ndarray(python::detail::new_reference (PyArray_Zeros(nd, const_cast(shape), detail::incref_dtype(dt), 0))); } ndarray empty(python::tuple const & shape, dtype const & dt) { int nd = len(shape); boost::scoped_array dims(new Py_intptr_t[nd]); for (int n=0; n(shape[n]); return ndarray(python::detail::new_reference (PyArray_Empty(nd, dims.get(), detail::incref_dtype(dt), 0))); } ndarray empty(int nd, Py_intptr_t const * shape, dtype const & dt) { return ndarray(python::detail::new_reference (PyArray_Empty(nd, const_cast(shape), detail::incref_dtype(dt), 0))); } ndarray array(python::object const & obj) { return ndarray(python::detail::new_reference (PyArray_FromAny(obj.ptr(), NULL, 0, 0, NPY_ENSUREARRAY, NULL))); } ndarray array(python::object const & obj, dtype const & dt) { return ndarray(python::detail::new_reference (PyArray_FromAny(obj.ptr(), detail::incref_dtype(dt), 0, 0, NPY_ENSUREARRAY, NULL))); } ndarray from_object(python::object const & obj, dtype const & dt, int nd_min, int nd_max, ndarray::bitflag flags) { int requirements = detail::bitflag_to_numpy(flags); return ndarray(python::detail::new_reference (PyArray_FromAny(obj.ptr(), detail::incref_dtype(dt), nd_min, nd_max, requirements, NULL))); } ndarray from_object(python::object const & obj, int nd_min, int nd_max, ndarray::bitflag flags) { int requirements = detail::bitflag_to_numpy(flags); return ndarray(python::detail::new_reference (PyArray_FromAny(obj.ptr(), NULL, nd_min, nd_max, requirements, NULL))); } } } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/src/dtype.cpp0000644000000000000000000001422012307353133025156 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_NUMPY_INTERNAL #include #define DTYPE_FROM_CODE(code) \ dtype(python::detail::new_reference(reinterpret_cast(PyArray_DescrFromType(code)))) #define BUILTIN_INT_DTYPE(bits) \ template <> struct builtin_int_dtype< bits, false > { \ static dtype get() { return DTYPE_FROM_CODE(NPY_INT ## bits); } \ }; \ template <> struct builtin_int_dtype< bits, true > { \ static dtype get() { return DTYPE_FROM_CODE(NPY_UINT ## bits); } \ }; \ template dtype get_int_dtype< bits, false >(); \ template dtype get_int_dtype< bits, true >() #define BUILTIN_FLOAT_DTYPE(bits) \ template <> struct builtin_float_dtype< bits > { \ static dtype get() { return DTYPE_FROM_CODE(NPY_FLOAT ## bits); } \ }; \ template dtype get_float_dtype< bits >() #define BUILTIN_COMPLEX_DTYPE(bits) \ template <> struct builtin_complex_dtype< bits > { \ static dtype get() { return DTYPE_FROM_CODE(NPY_COMPLEX ## bits); } \ }; \ template dtype get_complex_dtype< bits >() namespace boost { namespace python { namespace converter { NUMPY_OBJECT_MANAGER_TRAITS_IMPL(PyArrayDescr_Type, numpy::dtype) }}} // namespace boost::python::converter namespace boost { namespace numpy { namespace detail { dtype builtin_dtype::get() { return DTYPE_FROM_CODE(NPY_BOOL); } template struct builtin_int_dtype; template struct builtin_float_dtype; template struct builtin_complex_dtype; template dtype get_int_dtype() { return builtin_int_dtype::get(); } template dtype get_float_dtype() { return builtin_float_dtype::get(); } template dtype get_complex_dtype() { return builtin_complex_dtype::get(); } BUILTIN_INT_DTYPE(8); BUILTIN_INT_DTYPE(16); BUILTIN_INT_DTYPE(32); BUILTIN_INT_DTYPE(64); BUILTIN_FLOAT_DTYPE(32); BUILTIN_FLOAT_DTYPE(64); BUILTIN_COMPLEX_DTYPE(64); BUILTIN_COMPLEX_DTYPE(128); #if NPY_BITSOF_LONGDOUBLE > NPY_BITSOF_DOUBLE template <> struct builtin_float_dtype< NPY_BITSOF_LONGDOUBLE > { static dtype get() { return DTYPE_FROM_CODE(NPY_LONGDOUBLE); } }; template dtype get_float_dtype< NPY_BITSOF_LONGDOUBLE >(); template <> struct builtin_complex_dtype< 2 * NPY_BITSOF_LONGDOUBLE > { static dtype get() { return DTYPE_FROM_CODE(NPY_CLONGDOUBLE); } }; template dtype get_complex_dtype< 2 * NPY_BITSOF_LONGDOUBLE >(); #endif } // namespace detail python::detail::new_reference dtype::convert(python::object const & arg, bool align) { PyArray_Descr* obj=NULL; if (align) { if (PyArray_DescrAlignConverter(arg.ptr(), &obj) < 0) python::throw_error_already_set(); } else { if (PyArray_DescrConverter(arg.ptr(), &obj) < 0) python::throw_error_already_set(); } return python::detail::new_reference(reinterpret_cast(obj)); } int dtype::get_itemsize() const { return reinterpret_cast(ptr())->elsize;} bool equivalent(dtype const & a, dtype const & b) { return PyArray_EquivTypes( reinterpret_cast(a.ptr()), reinterpret_cast(b.ptr()) ); } namespace { namespace pyconv = boost::python::converter; template class array_scalar_converter { public: static PyTypeObject const * get_pytype() { // This implementation depends on the fact that get_builtin returns pointers to objects // NumPy has declared statically, and that the typeobj member also refers to a static // object. That means we don't need to do any reference counting. // In fact, I'm somewhat concerned that increasing the reference count of any of these // might cause leaks, because I don't think Boost.Python ever decrements it, but it's // probably a moot point if everything is actually static. return reinterpret_cast(dtype::get_builtin().ptr())->typeobj; } static void * convertible(PyObject * obj) { if (obj->ob_type == get_pytype()) { return obj; } else { return 0; } } static void convert(PyObject * obj, pyconv::rvalue_from_python_stage1_data* data) { void * storage = reinterpret_cast*>(data)->storage.bytes; // We assume std::complex is a "standard layout" here and elsewhere; not guaranteed by // C++03 standard, but true in every known implementation (and guaranteed by C++11). PyArray_ScalarAsCtype(obj, reinterpret_cast(storage)); data->convertible = storage; } static void declare() { pyconv::registry::push_back( &convertible, &convert, python::type_id() #ifndef BOOST_PYTHON_NO_PY_SIGNATURES , &get_pytype #endif ); } }; } // anonymous void dtype::register_scalar_converters() { array_scalar_converter::declare(); array_scalar_converter::declare(); array_scalar_converter::declare(); array_scalar_converter::declare(); array_scalar_converter::declare(); array_scalar_converter::declare(); array_scalar_converter::declare(); array_scalar_converter::declare(); array_scalar_converter::declare(); array_scalar_converter::declare(); array_scalar_converter::declare(); array_scalar_converter< std::complex >::declare(); array_scalar_converter< std::complex >::declare(); #if NPY_BITSOF_LONGDOUBLE > NPY_BITSOF_DOUBLE array_scalar_converter::declare(); array_scalar_converter< std::complex >::declare(); #endif } } // namespace boost::numpy } // namespace boost pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/src/CMakeLists.txt0000644000000000000000000000131712307353133026070 0ustar rootrootadd_library(boost_numpy ${LIBRARY_TYPE} # header files ../../../boost/numpy/dtype.hpp ../../../boost/numpy/internal.hpp ../../../boost/numpy/invoke_matching.hpp ../../../boost/numpy/matrix.hpp ../../../boost/numpy/ndarray.hpp ../../../boost/numpy/numpy_object_mgr_traits.hpp ../../../boost/numpy/scalars.hpp ../../../boost/numpy/ufunc.hpp # source files (in current directory) dtype.cpp scalars.cpp ndarray.cpp matrix.cpp ufunc.cpp numpy.cpp ) TARGET_LINK_LIBRARIES(boost_numpy ${Boost_LIBRARIES}) install(TARGETS boost_numpy ARCHIVE DESTINATION lib LIBRARY DESTINATION lib PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE ) pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/src/matrix.cpp0000644000000000000000000000320012307353133025331 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_NUMPY_INTERNAL #include #include namespace boost { namespace numpy { namespace detail { inline python::object get_matrix_type() { python::object module = python::import("numpy"); return module.attr("matrix"); } } // namespace boost::numpy::detail } // namespace boost::numpy namespace python { namespace converter { PyTypeObject const * object_manager_traits::get_pytype() { return reinterpret_cast(numpy::detail::get_matrix_type().ptr()); } } // namespace boost::python::converter } // namespace boost::python namespace numpy { python::object matrix::construct(python::object const & obj, dtype const & dt, bool copy) { return numpy::detail::get_matrix_type()(obj, dt, copy); } python::object matrix::construct(python::object const & obj, bool copy) { return numpy::detail::get_matrix_type()(obj, object(), copy); } matrix matrix::view(dtype const & dt) const { return matrix(python::detail::new_reference (PyObject_CallMethod(this->ptr(), const_cast("view"), const_cast("O"), dt.ptr()))); } matrix matrix::copy() const { return matrix(python::detail::new_reference (PyObject_CallMethod(this->ptr(), const_cast("copy"), const_cast("")))); } matrix matrix::transpose() const { return matrix(python::extract(ndarray::transpose())); } } // namespace boost::numpy } // namespace boost pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/doc/0000755000000000000000000000000012332260016023277 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/doc/_templates/0000755000000000000000000000000012332260016025434 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/doc/_templates/layout.html0000644000000000000000000001153312307353133027647 0ustar rootroot{%- macro navbar() %}
{#%- if parents|count > 0 %#} {#{ parents[1].title }#} {%- if prev %} {%- endif %} {%- if parents %} up {%- endif %} {%- if next %} {%- endif %} {#%- endif %#}
{%- endmacro %} {{ metatags }} {%- if builder != 'htmlhelp' %} {%- set titlesuffix = docstitle|e %} {%- set titlesuffix = " - " + titlesuffix %} {%- endif %} {{ title|striptags }}{{ titlesuffix }} {%- if builder == 'web' %} {%- for link, type, title in page_links %} {%- endfor %} {%- else %} {%- endif %} {%- if builder != 'htmlhelp' %} {%- for scriptfile in script_files %} {%- endfor %} {%- if use_opensearch %} {%- endif %} {%- if favicon %} {%- endif %} {%- endif %} {%- block linktags %} {%- if hasdoc('about') %} {%- endif %} {%- if hasdoc('copyright') %} {%- endif %} {%- if parents %} {%- endif %} {%- if next %} {%- endif %} {%- if prev %} {%- endif %} {%- endblock %} {%- block extrahead %} {% endblock %}

C++ Boost

Boost.NumPy

 {%- if pagename != "search" %} {%- endif %}
{%- block top_navbar %}{{ navbar() }}{% endblock %} {% block body %} {% endblock %} {%- block bottom_navbar %}{{ navbar() }}{% endblock %}
pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/doc/CMakeLists.txt0000644000000000000000000000273212307353133026050 0ustar rootrootproject(doc-html) file(GLOB NUMPY_DOC_DEPS conf.py *.rst) message( STATUS "NUMPY_DOC_DEPS=${NUMPY_DOC_DEPS}" ) # add_custom_target(doc-html make -C ${PROJECT_SOURCE_DIR} html BUILDDIR=${PROJECT_BINARY_DIR}/_build) # # this custom target is a cross-platform python/sphinx way to # replicate what the above make command is doing. # add_custom_target(doc-html ${SPHINX_BUILD} -b html -c ${CMAKE_CURRENT_SOURCE_DIR} -d .doctrees ${CMAKE_CURRENT_SOURCE_DIR} html DEPENDS ${NUMPY_DOC_DEPS} WORKING_DIRECTORY ${PROJECT_BINARY_DIR} COMMENT "Generating HTML Documentation" ) SET_PROPERTY(TARGET doc-html PROPERTY FOLDER "doc") install(DIRECTORY ${PROJECT_BINARY_DIR}/html DESTINATION share/doc/libboost_numpy OPTIONAL ) if (PDFLATEX_COMPILER) project(doc-pdf) add_custom_target(doc-pdf ${SPHINX_BUILD} -b latex -c ${CMAKE_CURRENT_SOURCE_DIR} -d .doctrees ${CMAKE_CURRENT_SOURCE_DIR} latex COMMAND ${PDFLATEX_COMPILER} --include-directory=latex --output-directory=latex latex/BoostNumPy.tex COMMAND ${PDFLATEX_COMPILER} --include-directory=latex --output-directory=latex latex/BoostNumPy.tex DEPENDS ${NUMPY_DOC_DEPS} WORKING_DIRECTORY ${PROJECT_BINARY_DIR} COMMENT "Generating Latex-pdf Documentation" ) SET_PROPERTY(TARGET doc-pdf PROPERTY FOLDER "doc") install(FILES ${PROJECT_BINARY_DIR}/latex/BoostNumPy.pdf DESTINATION share/doc/libboost_numpy OPTIONAL ) endif() pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/example/0000755000000000000000000000000012332260016024165 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/example/wrap.cpp0000644000000000000000000001210012307353133025641 0ustar rootroot// Copyright Jim Bosch 2011-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) /** * A simple example showing how to wrap a couple of C++ functions that * operate on 2-d arrays into Python functions that take NumPy arrays * as arguments. * * If you find have a lot of such functions to wrap, you may want to * create a C++ array type (or use one of the many existing C++ array * libraries) that maps well to NumPy arrays and create Boost.Python * converters. There's more work up front than the approach here, * but much less boilerplate per function. See the "Gaussian" example * included with Boost.NumPy for an example of custom converters, or * take a look at the "ndarray" project on GitHub for a more complete, * high-level solution. * * Note that we're using embedded Python here only to make a convenient * self-contained example; you could just as easily put the wrappers * in a regular C++-compiled module and imported them in regular * Python. Again, see the Gaussian demo for an example. */ #include #include #include namespace p = boost::python; namespace np = boost::numpy; // This is roughly the most efficient way to write a C/C++ function that operates // on a 2-d NumPy array - operate directly on the array by incrementing a pointer // with the strides. void fill1(double * array, int rows, int cols, int row_stride, int col_stride) { double * row_iter = array; double n = 0.0; // just a counter we'll fill the array with. for (int i = 0; i < rows; ++i, row_iter += row_stride) { double * col_iter = row_iter; for (int j = 0; j < cols; ++j, col_iter += col_stride) { *col_iter = ++n; } } } // Here's a simple wrapper function for fill1. It requires that the passed // NumPy array be exactly what we're looking for - no conversion from nested // sequences or arrays with other data types, because we want to modify it // in-place. void wrap_fill1(np::ndarray const & array) { if (array.get_dtype() != np::dtype::get_builtin()) { PyErr_SetString(PyExc_TypeError, "Incorrect array data type"); p::throw_error_already_set(); } if (array.get_nd() != 2) { PyErr_SetString(PyExc_TypeError, "Incorrect number of dimensions"); p::throw_error_already_set(); } fill1(reinterpret_cast(array.get_data()), array.shape(0), array.shape(1), array.strides(0) / sizeof(double), array.strides(1) / sizeof(double)); } // Another fill function that takes a double**. This is less efficient, because // it's not the native NumPy data layout, but it's common enough in C/C++ that // it's worth its own example. This time we don't pass the strides, and instead // in wrap_fill2 we'll require the C_CONTIGUOUS bitflag, which guarantees that // the column stride is 1 and the row stride is the number of columns. That // restricts the arrays that can be passed to fill2 (it won't work on most // subarray views or transposes, for instance). void fill2(double ** array, int rows, int cols) { double n = 0.0; // just a counter we'll fill the array with. for (int i = 0; i < rows; ++i) { for (int j = 0; j < cols; ++j) { array[i][j] = ++n; } } } // Here's the wrapper for fill2; it's a little more complicated because we need // to check the flags and create the array of pointers. void wrap_fill2(np::ndarray const & array) { if (array.get_dtype() != np::dtype::get_builtin()) { PyErr_SetString(PyExc_TypeError, "Incorrect array data type"); p::throw_error_already_set(); } if (array.get_nd() != 2) { PyErr_SetString(PyExc_TypeError, "Incorrect number of dimensions"); p::throw_error_already_set(); } if (!(array.get_flags() & np::ndarray::C_CONTIGUOUS)) { PyErr_SetString(PyExc_TypeError, "Array must be row-major contiguous"); p::throw_error_already_set(); } double * iter = reinterpret_cast(array.get_data()); int rows = array.shape(0); int cols = array.shape(1); boost::scoped_array ptrs(new double*[rows]); for (int i = 0; i < rows; ++i, iter += cols) { ptrs[i] = iter; } fill2(ptrs.get(), array.shape(0), array.shape(1)); } BOOST_PYTHON_MODULE(example) { np::initialize(); // have to put this in any module that uses Boost.NumPy p::def("fill1", wrap_fill1); p::def("fill2", wrap_fill2); } int main(int argc, char **argv) { // This line makes our module available to the embedded Python intepreter. PyImport_AppendInittab("example", &initexample); // Initialize the Python runtime. Py_Initialize(); PyRun_SimpleString( "import example\n" "import numpy\n" "z1 = numpy.zeros((5,6), dtype=float)\n" "z2 = numpy.zeros((4,3), dtype=float)\n" "example.fill1(z1)\n" "example.fill2(z2)\n" "print z1\n" "print z2\n" ); Py_Finalize(); } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/example/gaussian.cpp0000644000000000000000000002430612307353133026515 0ustar rootroot// Copyright Jim Bosch 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #ifndef M_PI #include const double M_PI = boost::math::constants::pi(); #endif namespace bp = boost::python; namespace bn = boost::numpy; /** * A 2x2 matrix class, purely for demonstration purposes. * * Instead of wrapping this class with Boost.Python, we'll convert it to/from numpy.ndarray. */ class matrix2 { public: double & operator()(int i, int j) { return _data[i*2 + j]; } double const & operator()(int i, int j) const { return _data[i*2 + j]; } double const * data() const { return _data; } private: double _data[4]; }; /** * A 2-element vector class, purely for demonstration purposes. * * Instead of wrapping this class with Boost.Python, we'll convert it to/from numpy.ndarray. */ class vector2 { public: double & operator[](int i) { return _data[i]; } double const & operator[](int i) const { return _data[i]; } double const * data() const { return _data; } vector2 operator+(vector2 const & other) const { vector2 r; r[0] = _data[0] + other[0]; r[1] = _data[1] + other[1]; return r; } vector2 operator-(vector2 const & other) const { vector2 r; r[0] = _data[0] - other[0]; r[1] = _data[1] - other[1]; return r; } private: double _data[2]; }; /** * Matrix-vector multiplication. */ vector2 operator*(matrix2 const & m, vector2 const & v) { vector2 r; r[0] = m(0, 0) * v[0] + m(0, 1) * v[1]; r[1] = m(1, 0) * v[0] + m(1, 1) * v[1]; return r; } /** * Vector inner product. */ double dot(vector2 const & v1, vector2 const & v2) { return v1[0] * v2[0] + v1[1] * v2[1]; } /** * This class represents a simple 2-d Gaussian (Normal) distribution, defined by a * mean vector 'mu' and a covariance matrix 'sigma'. */ class bivariate_gaussian { public: vector2 const & get_mu() const { return _mu; } matrix2 const & get_sigma() const { return _sigma; } /** * Evaluate the density of the distribution at a point defined by a two-element vector. */ double operator()(vector2 const & p) const { vector2 u = _cholesky * (p - _mu); return 0.5 * _cholesky(0, 0) * _cholesky(1, 1) * std::exp(-0.5 * dot(u, u)) / M_PI; } /** * Evaluate the density of the distribution at an (x, y) point. */ double operator()(double x, double y) const { vector2 p; p[0] = x; p[1] = y; return operator()(p); } /** * Construct from a mean vector and covariance matrix. */ bivariate_gaussian(vector2 const & mu, matrix2 const & sigma) : _mu(mu), _sigma(sigma), _cholesky(compute_inverse_cholesky(sigma)) {} private: /** * This evaluates the inverse of the Cholesky factorization of a 2x2 matrix; * it's just a shortcut in evaluating the density. */ static matrix2 compute_inverse_cholesky(matrix2 const & m) { matrix2 l; // First do cholesky factorization: l l^t = m l(0, 0) = std::sqrt(m(0, 0)); l(0, 1) = m(0, 1) / l(0, 0); l(1, 1) = std::sqrt(m(1, 1) - l(0,1) * l(0,1)); // Now do forward-substitution (in-place) to invert: l(0, 0) = 1.0 / l(0, 0); l(1, 0) = l(0, 1) = -l(0, 1) / l(1, 1); l(1, 1) = 1.0 / l(1, 1); return l; } vector2 _mu; matrix2 _sigma; matrix2 _cholesky; }; /* * We have a two options for wrapping get_mu and get_sigma into NumPy-returning Python methods: * - we could deep-copy the data, making totally new NumPy arrays; * - we could make NumPy arrays that point into the existing memory. * The latter is often preferable, especially if the arrays are large, but it's dangerous unless * the reference counting is correct: the returned NumPy array needs to hold a reference that * keeps the memory it points to from being deallocated as long as it is alive. This is what the * "owner" argument to from_data does - the NumPy array holds a reference to the owner, keeping it * from being destroyed. * * Note that this mechanism isn't completely safe for data members that can have their internal * storage reallocated. A std::vector, for instance, can be invalidated when it is resized, * so holding a Python reference to a C++ class that holds a std::vector may not be a guarantee * that the memory in the std::vector will remain valid. */ /** * These two functions are custom wrappers for get_mu and get_sigma, providing the shallow-copy * conversion with reference counting described above. * * It's also worth noting that these return NumPy arrays that cannot be modified in Python; * the const overloads of vector::data() and matrix::data() return const references, * and passing a const pointer to from_data causes NumPy's 'writeable' flag to be set to false. */ static bn::ndarray py_get_mu(bp::object const & self) { vector2 const & mu = bp::extract(self)().get_mu(); return bn::from_data( mu.data(), bn::dtype::get_builtin(), bp::make_tuple(2), bp::make_tuple(sizeof(double)), self ); } static bn::ndarray py_get_sigma(bp::object const & self) { matrix2 const & sigma = bp::extract(self)().get_sigma(); return bn::from_data( sigma.data(), bn::dtype::get_builtin(), bp::make_tuple(2, 2), bp::make_tuple(2 * sizeof(double), sizeof(double)), self ); } /** * To allow the constructor to work, we need to define some from-Python converters from NumPy arrays * to the matrix/vector types. The rvalue-from-python functionality is not well-documented in Boost.Python * itself; you can learn more from boost/python/converter/rvalue_from_python_data.hpp. */ /** * We start with two functions that just copy a NumPy array into matrix/vector objects. These will be used * in the templated converted below. The first just uses the operator[] overloads provided by * bp::object. */ static void copy_ndarray_to_mv2(bn::ndarray const & array, vector2 & vec) { vec[0] = bp::extract(array[0]); vec[1] = bp::extract(array[1]); } /** * Here, we'll take the alternate approach of using the strides to access the array's memory directly. * This can be much faster for large arrays. */ static void copy_ndarray_to_mv2(bn::ndarray const & array, matrix2 & mat) { // Unfortunately, get_strides() can't be inlined, so it's best to call it once up-front. Py_intptr_t const * strides = array.get_strides(); for (int i = 0; i < 2; ++i) { for (int j = 0; j < 2; ++j) { mat(i, j) = *reinterpret_cast(array.get_data() + i * strides[0] + j * strides[1]); } } } /** * Here's the actual converter. Because we've separated the differences into the above functions, * we can write a single template class that works for both matrix2 and vector2. */ template struct mv2_from_python { /** * Register the converter. */ mv2_from_python() { bp::converter::registry::push_back( &convertible, &construct, bp::type_id< T >() ); } /** * Test to see if we can convert this to the desired type; if not return zero. * If we can convert, returned pointer can be used by construct(). */ static void * convertible(PyObject * p) { try { bp::object obj(bp::handle<>(bp::borrowed(p))); std::auto_ptr array( new bn::ndarray( bn::from_object(obj, bn::dtype::get_builtin(), N, N, bn::ndarray::V_CONTIGUOUS) ) ); if (array->shape(0) != 2) return 0; if (N == 2 && array->shape(1) != 2) return 0; return array.release(); } catch (bp::error_already_set & err) { bp::handle_exception(); return 0; } } /** * Finish the conversion by initializing the C++ object into memory prepared by Boost.Python. */ static void construct(PyObject * obj, bp::converter::rvalue_from_python_stage1_data * data) { // Extract the array we passed out of the convertible() member function. std::auto_ptr array(reinterpret_cast(data->convertible)); // Find the memory block Boost.Python has prepared for the result. typedef bp::converter::rvalue_from_python_storage storage_t; storage_t * storage = reinterpret_cast(data); // Use placement new to initialize the result. T * m_or_v = new (storage->storage.bytes) T(); // Fill the result with the values from the NumPy array. copy_ndarray_to_mv2(*array, *m_or_v); // Finish up. data->convertible = storage->storage.bytes; } }; BOOST_PYTHON_MODULE(gaussian) { bn::initialize(); // Register the from-python converters mv2_from_python< vector2, 1 >(); mv2_from_python< matrix2, 2 >(); typedef double (bivariate_gaussian::*call_vector)(vector2 const &) const; bp::class_("bivariate_gaussian", bp::init()) // Declare the constructor (wouldn't work without the from-python converters). .def(bp::init< vector2 const &, matrix2 const & >()) // Use our custom reference-counting getters .add_property("mu", &py_get_mu) .add_property("sigma", &py_get_sigma) // First overload accepts a two-element array argument .def("__call__", (call_vector)&bivariate_gaussian::operator()) // This overload works like a binary NumPy universal function: you can pass // in scalars or arrays, and the C++ function will automatically be called // on each element of an array argument. .def("__call__", bn::binary_ufunc::make()) ; } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/example/fromdata.cpp0000644000000000000000000000325312307353133026476 0ustar rootroot// Copyright Ankit Daftery 2011-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) /** * @brief An example to show how to access data using raw pointers. This shows that you can use and * manipulate data in either Python or C++ and have the changes reflected in both. */ #include #include namespace p = boost::python; namespace np = boost::numpy; int main(int argc, char **argv) { // Initialize the Python runtime. Py_Initialize(); // Initialize NumPy np::initialize(); // Create an array in C++ int arr[] = {1,2,3,4} ; // Create the ndarray in Python np::ndarray py_array = np::from_data(arr, np::dtype::get_builtin() , p::make_tuple(4), p::make_tuple(4), p::object()); // Print the ndarray that we just created, and the source C++ array std::cout << "C++ array :" << std::endl ; for (int j=0;j<4;j++) { std::cout << arr[j] << ' ' ; } std::cout << std::endl << "Python ndarray :" << p::extract(p::str(py_array)) << std::endl; // Change an element in the python ndarray py_array[1] = 5 ; // And see if the C++ container is changed or not std::cout << "Is the change reflected in the C++ array used to create the ndarray ? " << std::endl ; for (int j = 0;j<4 ; j++) { std::cout << arr[j] << ' ' ; } // Conversely, change it in C++ arr[2] = 8 ; // And see if the changes are reflected in the Python ndarray std::cout << std::endl << "Is the change reflected in the Python ndarray ?" << std::endl << p::extract(p::str(py_array)) << std::endl; } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/example/ufunc.cpp0000644000000000000000000000701512307353133026021 0ustar rootroot// Copyright Ankit Daftery 2011-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) /** * @brief An example to demonstrate use of universal functions or ufuncs * * * @todo Calling the overloaded () operator is in a roundabout manner, find a simpler way * None of the methods like np::add, np::multiply etc are supported as yet */ #include #include namespace p = boost::python; namespace np = boost::numpy; // Create the structs necessary to implement the ufuncs // The typedefs *must* be made struct UnarySquare { typedef double argument_type; typedef double result_type; double operator()(double r) const { return r * r;} }; struct BinarySquare { typedef double first_argument_type; typedef double second_argument_type; typedef double result_type; double operator()(double a,double b) const { return (a*a + b*b) ; } }; int main(int argc, char **argv) { // Initialize the Python runtime. Py_Initialize(); // Initialize NumPy np::initialize(); // Expose the struct UnarySquare to Python as a class, and let ud be the class object p::object ud = p::class_ >("UnarySquare") .def("__call__", np::unary_ufunc::make()); // Let inst be an instance of the class ud p::object inst = ud(); // Use the "__call__" method to call the overloaded () operator and print the value std::cout << "Square of unary scalar 1.0 is " << p::extract (p::str(inst.attr("__call__")(1.0))) << std::endl ; // Create an array in C++ int arr[] = {1,2,3,4} ; // ..and use it to create the ndarray in Python np::ndarray demo_array = np::from_data(arr, np::dtype::get_builtin() , p::make_tuple(4), p::make_tuple(4), p::object()); // Print out the demo array std::cout << "Demo array is " << p::extract (p::str(demo_array)) << std::endl ; // Call the "__call__" method to perform the operation and assign the value to result_array p::object result_array = inst.attr("__call__")(demo_array) ; // Print the resultant array std::cout << "Square of demo array is " << p::extract (p::str(result_array)) << std::endl ; // Lets try the same with a list p::list li ; li.append(3); li.append(7); // Print out the demo list std::cout << "Demo list is " << p::extract (p::str(li)) << std::endl ; // Call the ufunc for the list result_array = inst.attr("__call__")(li) ; // And print the list out std::cout << "Square of demo list is " << p::extract (p::str(result_array)) << std::endl ; // Now lets try Binary ufuncs // Expose the struct BinarySquare to Python as a class, and let ud be the class object ud = p::class_ >("BinarySquare") .def("__call__", np::binary_ufunc::make()); // Again initialise inst as an instance of the class ud inst = ud(); // Print the two input listsPrint the two input lists std::cout << "The two input list for binary ufunc are " << std::endl << p::extract (p::str(demo_array)) << std::endl << p::extract (p::str(demo_array)) << std::endl ; // Call the binary ufunc taking demo_array as both inputs result_array = inst.attr("__call__")(demo_array,demo_array) ; std::cout << "Square of list with binary ufunc is " << p::extract (p::str(result_array)) << std::endl ; } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/example/ndarray.cpp0000644000000000000000000000607512307353133026346 0ustar rootroot// Copyright Ankit Daftery 2011-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) /** * @brief An example to show how to create ndarrays using arbitrary Python sequences. * * The Python sequence could be any object whose __array__ method returns an array, or any * (nested) sequence. This example also shows how to create arrays using both unit and * non-unit strides. */ #include #include namespace p = boost::python; namespace np = boost::numpy; #if _MSC_VER using boost::uint8_t; #endif int main(int argc, char **argv) { // Initialize the Python runtime. Py_Initialize(); // Initialize NumPy np::initialize(); // Create an ndarray from a simple tuple p::object tu = p::make_tuple('a','b','c') ; np::ndarray example_tuple = np::array (tu) ; // and from a list p::list l ; np::ndarray example_list = np::array (l) ; // Optionally, you can also specify a dtype np::dtype dt = np::dtype::get_builtin(); np::ndarray example_list1 = np::array (l,dt); // You can also create an array by supplying data.First,create an integer array int data[] = {1,2,3,4} ; // Create a shape, and strides, needed by the function p::tuple shape = p::make_tuple(4) ; p::tuple stride = p::make_tuple(4) ; // The function also needs an owner, to keep track of the data array passed. Passing none is dangerous p::object own ; // The from_data function takes the data array, datatype,shape,stride and owner as arguments // and returns an ndarray np::ndarray data_ex = np::from_data(data,dt,shape,stride,own); // Print the ndarray we created std::cout << "Single dimensional array ::" << std::endl << p::extract < char const * > (p::str(data_ex)) << std::endl ; // Now lets make an 3x2 ndarray from a multi-dimensional array using non-unit strides // First lets create a 3x4 array of 8-bit integers uint8_t mul_data[][4] = {{1,2,3,4},{5,6,7,8},{1,3,5,7}}; // Now let's create an array of 3x2 elements, picking the first and third elements from each row // For that, the shape will be 3x2 shape = p::make_tuple(3,2) ; // The strides will be 4x2 i.e. 4 bytes to go to the next desired row, and 2 bytes to go to the next desired column stride = p::make_tuple(4,2) ; // Get the numpy dtype for the built-in 8-bit integer data type np::dtype dt1 = np::dtype::get_builtin(); // First lets create and print out the ndarray as is np::ndarray mul_data_ex = np::from_data(mul_data,dt1, p::make_tuple(3,4),p::make_tuple(4,1),p::object()); std::cout << "Original multi dimensional array :: " << std::endl << p::extract < char const * > (p::str(mul_data_ex)) << std::endl ; // Now create the new ndarray using the shape and strides mul_data_ex = np::from_data(mul_data,dt1, shape,stride,p::object()); // Print out the array we created using non-unit strides std::cout << "Selective multidimensional array :: "< (p::str(mul_data_ex)) << std::endl ; } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/example/simple.cpp0000644000000000000000000000210312307353133026163 0ustar rootroot// Copyright 2011 Stefan Seefeld. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace p = boost::python; namespace np = boost::numpy; int main(int argc, char **argv) { // Initialize the Python runtime. Py_Initialize(); // Initialize NumPy np::initialize(); // Create a 3x3 shape... p::tuple shape = p::make_tuple(3, 3); // ...as well as a type for C++ float np::dtype dtype = np::dtype::get_builtin(); // Construct an array with the above shape and type np::ndarray a = np::zeros(shape, dtype); // Construct an empty array with the above shape and dtype as well np::ndarray b = np::empty(shape,dtype); // Print the array std::cout << "Original array:\n" << p::extract(p::str(a)) << std::endl; // Reshape the array into a 1D array a = a.reshape(p::make_tuple(9)); // Print it again. std::cout << "Reshaped array:\n" << p::extract(p::str(a)) << std::endl; } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/example/dtype.cpp0000644000000000000000000000352112307353133026024 0ustar rootroot// Copyright Ankit Daftery 2011-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) /** * @brief An example to show how to create ndarrays with built-in python data types, and extract * the types and values of member variables * * @todo Add an example to show type conversion. * Add an example to show use of user-defined types * */ #include #include namespace p = boost::python; namespace np = boost::numpy; int main(int argc, char **argv) { // Initialize the Python runtime. Py_Initialize(); // Initialize NumPy np::initialize(); // Create a 3x3 shape... p::tuple shape = p::make_tuple(3, 3); // ...as well as a type for C++ double np::dtype dtype = np::dtype::get_builtin(); // Construct an array with the above shape and type np::ndarray a = np::zeros(shape, dtype); // Print the array std::cout << "Original array:\n" << p::extract(p::str(a)) << std::endl; // Print the datatype of the elements std::cout << "Datatype is:\n" << p::extract(p::str(a.get_dtype())) << std::endl ; // Using user defined dtypes to create dtype and an array of the custom dtype // First create a tuple with a variable name and its dtype, double, to create a custom dtype p::tuple for_custom_dtype = p::make_tuple("ha",dtype) ; // The list needs to be created, because the constructor to create the custom dtype // takes a list of (variable,variable_type) as an argument p::list list_for_dtype ; list_for_dtype.append(for_custom_dtype) ; // Create the custom dtype np::dtype custom_dtype = np::dtype(list_for_dtype) ; // Create an ndarray with the custom dtype np::ndarray new_array = np::zeros(shape,custom_dtype); } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/example/CMakeLists.txt0000644000000000000000000000325412307353133026736 0ustar rootroot# custom macro with most of the redundant code for making a python example module macro( addPythonExe _name _srccpp ) ADD_EXECUTABLE(${_name} ${_srccpp}) # make the pyd library link against boost_numpy python and boost TARGET_LINK_LIBRARIES(${_name} boost_numpy ${PYTHON_LIBRARIES} ${Boost_LIBRARIES}) # put the example target into a VS solution folder named example (should # be a no-op for Linux) SET_PROPERTY(TARGET ${_name} PROPERTY FOLDER "example") endmacro() macro( addPythonMod _name _srccpp ) PYTHON_ADD_MODULE(${_name} ${_srccpp}) # make the pyd library link against boost_numpy python and boost TARGET_LINK_LIBRARIES(${_name} boost_numpy ${PYTHON_LIBRARIES} ${Boost_LIBRARIES}) # put the example target into a VS solution folder named example (should # be a no-op for Linux) SET_PROPERTY(TARGET ${_name} PROPERTY FOLDER "example") endmacro() addPythonMod(gaussian gaussian.cpp) addPythonExe(dtype dtype.cpp) addPythonExe(fromdata fromdata.cpp) addPythonExe(ndarray ndarray.cpp) addPythonExe(simple simple.cpp) addPythonExe(ufunc ufunc.cpp) addPythonExe(wrap wrap.cpp) # # installation logic (skip until it is better thought out) # set(DEST_EXAMPLE boost.numpy/example) # # # install executables demonstrating embedding python # install(TARGETS dtype fromdata ndarray simple ufunc wrap RUNTIME # DESTINATION ${DEST_EXAMPLE} # ${INSTALL_PERMSSIONS_RUNTIME} # ) # # # install extension module # install(TARGETS gaussian LIBRARY # DESTINATION ${DEST_EXAMPLE} # ${INSTALL_PERMSSIONS_RUNTIME} # ) # # # install source file using the extension module # install(FILES demo_gaussian.py # DESTINATION ${DEST_EXAMPLE} # ${INSTALL_PERMSSIONS_SRC} # ) pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/cmake/0000755000000000000000000000000012332260016023612 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/cmake/README.txt0000644000000000000000000000070512307353133025317 0ustar rootrootThe cmake files, FindNumPy.cmake and FindPythonLibsNew.cmake, in this folder came from the numexpr project at http://code.google.com/p/numexpr. The numexpr project was also a valuable resource in making many of the cmake constructs used in the cmake lists files written for Boost.NumPy. The boost-python-examples project at https://github.com/TNG/boost-python-examples was another helpful resource for understanding how to use cmake with boost.python. pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/test/0000755000000000000000000000000012332260016023511 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/test/shapes_mod.cpp0000644000000000000000000000102512307353133026342 0ustar rootroot// Copyright Jim Bosch & Ankit Daftery 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace p = boost::python; namespace np = boost::numpy; np::ndarray reshape(np::ndarray old_array, p::tuple shape) { np::ndarray local_shape = old_array.reshape(shape); return local_shape; } BOOST_PYTHON_MODULE(shapes_mod) { np::initialize(); p::def("reshape", reshape); } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/test/ndarray_mod.cpp0000644000000000000000000000303612307353133026523 0ustar rootroot// Copyright Jim Bosch & Ankit Daftery 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace p = boost::python; namespace np = boost::numpy; np::ndarray zeros(p::tuple shape, np::dtype dt) { return np::zeros(shape, dt);} np::ndarray array2(p::object obj, np::dtype dt) { return np::array(obj,dt);} np::ndarray array1(p::object obj) { return np::array(obj);} np::ndarray empty1(p::tuple shape, np::dtype dt) { return np::empty(shape,dt);} np::ndarray c_empty(p::tuple shape, np::dtype dt) { // convert 'shape' to a C array so we can test the corresponding // version of the constructor unsigned len = p::len(shape); Py_intptr_t *c_shape = new Py_intptr_t[len]; for (unsigned i = 0; i != len; ++i) c_shape[i] = p::extract(shape[i]); np::ndarray result = np::empty(len, c_shape, dt); delete [] c_shape; return result; } np::ndarray transpose(np::ndarray arr) { return arr.transpose();} np::ndarray squeeze(np::ndarray arr) { return arr.squeeze();} np::ndarray reshape(np::ndarray arr,p::tuple tup) { return arr.reshape(tup);} BOOST_PYTHON_MODULE(ndarray_mod) { np::initialize(); p::def("zeros", zeros); p::def("zeros_matrix", zeros, np::as_matrix<>()); p::def("array", array2); p::def("array", array1); p::def("empty", empty1); p::def("c_empty", c_empty); p::def("transpose", transpose); p::def("squeeze", squeeze); p::def("reshape", reshape); } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/test/dtype_mod.cpp0000644000000000000000000000340612307353133026211 0ustar rootroot// Copyright Jim Bosch & Ankit Daftery 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace p = boost::python; namespace np = boost::numpy; template np::dtype accept(T) { return np::dtype::get_builtin(); } BOOST_PYTHON_MODULE(dtype_mod) { np::initialize(); // wrap dtype equivalence test, since it isn't available in Python API. p::def("equivalent", np::equivalent); // integers, by number of bits p::def("accept_int8", accept); p::def("accept_uint8", accept); p::def("accept_int16", accept); p::def("accept_uint16", accept); p::def("accept_int32", accept); p::def("accept_uint32", accept); p::def("accept_int64", accept); p::def("accept_uint64", accept); // integers, by C name according to NumPy p::def("accept_bool_", accept); p::def("accept_byte", accept); p::def("accept_ubyte", accept); p::def("accept_short", accept); p::def("accept_ushort", accept); p::def("accept_intc", accept); p::def("accept_uintc", accept); // floats and complex p::def("accept_float32", accept); p::def("accept_complex64", accept< std::complex >); p::def("accept_float64", accept); p::def("accept_complex128", accept< std::complex >); if (sizeof(long double) > sizeof(double)) { p::def("accept_longdouble", accept); p::def("accept_clongdouble", accept< std::complex >); } } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/test/ufunc_mod.cpp0000644000000000000000000000164312307353133026205 0ustar rootroot// Copyright Jim Bosch & Ankit Daftery 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace p = boost::python; namespace np = boost::numpy; struct UnaryCallable { typedef double argument_type; typedef double result_type; double operator()(double r) const { return r * 2;} }; struct BinaryCallable { typedef double first_argument_type; typedef double second_argument_type; typedef double result_type; double operator()(double a, double b) const { return a * 2 + b * 3;} }; BOOST_PYTHON_MODULE(ufunc_mod) { np::initialize(); p::class_("UnaryCallable") .def("__call__", np::unary_ufunc::make()); p::class_< BinaryCallable>("BinaryCallable") .def("__call__", np::binary_ufunc::make()); } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/test/templates_mod.cpp0000644000000000000000000000314512307353133027062 0ustar rootroot// Copyright Jim Bosch & Ankit Daftery 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace p = boost::python; namespace np = boost::numpy; struct ArrayFiller { typedef boost::mpl::vector< short, int, float, std::complex > TypeSequence; typedef boost::mpl::vector_c< int, 1, 2 > DimSequence; explicit ArrayFiller(np::ndarray const & arg) : argument(arg) {} template void apply() const { if (N == 1) { char * p = argument.get_data(); int stride = argument.strides(0); int size = argument.shape(0); for (int n = 0; n != size; ++n, p += stride) *reinterpret_cast(p) = static_cast(n); } else { char * row_p = argument.get_data(); int row_stride = argument.strides(0); int col_stride = argument.strides(1); int rows = argument.shape(0); int cols = argument.shape(1); int i = 0; for (int n = 0; n != rows; ++n, row_p += row_stride) { char * col_p = row_p; for (int m = 0; m != cols; ++i, ++m, col_p += col_stride) *reinterpret_cast(col_p) = static_cast(i); } } } np::ndarray argument; }; void fill(np::ndarray const & arg) { ArrayFiller filler(arg); np::invoke_matching_array(arg, filler); } BOOST_PYTHON_MODULE(templates_mod) { np::initialize(); p::def("fill", fill); } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/test/indexing_mod.cpp0000644000000000000000000000174512307353133026675 0ustar rootroot// Copyright Jim Bosch & Ankit Daftery 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace p = boost::python; namespace np = boost::numpy; p::object single(np::ndarray ndarr, int i) { return ndarr[i];} p::object slice(np::ndarray ndarr, p::slice sl) { return ndarr[sl];} p::object indexarray(np::ndarray ndarr, np::ndarray d1) { return ndarr[d1];} p::object indexarray_2d(np::ndarray ndarr, np::ndarray d1,np::ndarray d2) { return ndarr[p::make_tuple(d1,d2)];} p::object indexslice(np::ndarray ndarr, np::ndarray d1, p::slice sl) { return ndarr[p::make_tuple(d1, sl)];} BOOST_PYTHON_MODULE(indexing_mod) { np::initialize(); p::def("single", single); p::def("slice", slice); p::def("indexarray", indexarray); p::def("indexarray", indexarray_2d); p::def("indexslice", indexslice); } pyviennacl-1.0.2+dfsg.orig/external/boost_numpy/libs/numpy/test/CMakeLists.txt0000644000000000000000000000454712307353133026270 0ustar rootrootproject(BoostNumpyTests) if (WIN32) set(runCmakeTest runCmakeTest.bat) foreach(cfg ${CMAKE_CONFIGURATION_TYPES}) message( STATUS "configuring runCmakeTest for cfg=${cfg}" ) CONFIGURE_FILE( ${runCmakeTest}.in ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${cfg}/${runCmakeTest} @ONLY ) endforeach() else() set(runCmakeTest runCmakeTest.sh) CONFIGURE_FILE( ${runCmakeTest}.in ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${runCmakeTest} @ONLY ) endif() set( TEST_SOURCE_DIR ${PROJECT_SOURCE_DIR} ) set( TestCommand ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${runCmakeTest} ) # custom macro with most of the redundant code for making a python test macro( addPythonTest _name _srcpy ) # make the pyd library link against boost_numpy python and boost TARGET_LINK_LIBRARIES(${_name} boost_numpy ${PYTHON_LIBRARIES} ${Boost_LIBRARIES}) # make a test of the module using the python source file in the test directory ADD_TEST(${_name} ${TestCommand} ${TEST_SOURCE_DIR}/${_srcpy}) # set the regex to use to recognize a failure since `python testfoo.py` # does not seem to return non-zero with a test failure set_property(TEST ${_name} PROPERTY FAIL_REGULAR_EXPRESSION "ERROR\\:" "ImportError\\: DLL load failed\\: " ) # put the test target into a VS solution folder named test (should # be a no-op for Linux) SET_PROPERTY(TARGET ${_name} PROPERTY FOLDER "test") endmacro() PYTHON_ADD_MODULE(dtype_mod dtype_mod.cpp) addPythonTest( dtype_mod dtype.py ) PYTHON_ADD_MODULE(indexing_mod indexing_mod.cpp) addPythonTest( indexing_mod indexing.py ) PYTHON_ADD_MODULE(ndarray_mod ndarray_mod.cpp) addPythonTest( ndarray_mod ndarray.py ) PYTHON_ADD_MODULE(shapes_mod shapes_mod.cpp) addPythonTest( shapes_mod shapes.py ) PYTHON_ADD_MODULE(templates_mod templates_mod.cpp) addPythonTest( templates_mod templates.py ) PYTHON_ADD_MODULE(ufunc_mod ufunc_mod.cpp) addPythonTest( ufunc_mod ufunc.py ) # installation logic (skip until it is better thought out) # set(DEST_TEST boost.numpy/test) # # # copy the extension modules to DEST_TEST # install(TARGETS dtype_mod indexing_mod ndarray_mod shapes_mod templates_mod ufunc_mod LIBRARY # DESTINATION ${DEST_TEST} # ${INSTALL_PERMSSIONS_RUNTIME} # ) # # # copy the source test python modules to DEST_TEST too # install(FILES dtype.py indexing.py ndarray.py shapes.py templates.py ufunc.py # DESTINATION ${DEST_TEST} # ${INSTALL_PERMSSIONS_SRC} # ) pyviennacl-1.0.2+dfsg.orig/PKG-INFO0000644000000000000000000002552412332260016015336 0ustar rootrootMetadata-Version: 1.1 Name: pyviennacl Version: 1.0.2 Summary: Sparse/dense linear algebra on GPUs and CPUs using OpenCL Home-page: http://viennacl.sourceforge.net/pyviennacl.html Author: Toby St Clere Smithe Author-email: pyviennacl@tsmithe.net License: UNKNOWN Description: ***************** PyViennaCL Readme ***************** PyViennaCL around the web ========================= * `Home page `_ * `Documentation `_ * `GitHub `_ (`Issue tracker `_) About PyViennaCL ================ *PyViennaCL* aims to make fast, powerful GPGPU and heterogeneous scientific computing really transparently easy, especially for users already using NumPy for representing matrices. PyViennaCL does this by harnessing the `ViennaCL `_ linear algebra and numerical computation library for GPGPU and heterogeneous systems, thereby making available to Python programmers ViennaCL’s fast *OpenCL* and *CUDA* algorithms. PyViennaCL does this in a way that is idiomatic and compatible with the Python community’s most popular scientific packages, *NumPy* and *SciPy*. PyViennaCL exposes the following functionality: * sparse (compressed, co-ordinate, ELL, and hybrid) and dense (row-major and column-major) matrices, vectors and scalars on your compute device using OpenCL; * standard arithmetic operations and mathematical functions; * fast matrix products for sparse and dense matrices, and inner and outer products for vectors; * direct solvers for dense triangular systems; * iterative solvers for sparse and dense systems, using the BiCGStab, CG, and GMRES algorithms; * iterative algorithms for eigenvalue estimation problems. Requirements ============ PyViennaCL requires the following build dependencies: * a C++ compiler; * *Python* (2.7+) with *setuptools* [see below]; * *NumPy* (1.7+); * *Sphinx* (1.0+) [if you want to build HTML documentation]. It is also highly recommended to have an available *OpenCL* implementation, since PyViennaCL was designed for this case. If you do not have OpenCL available, then PyViennaCL will still build and function, but will not perform to full effect. If you have a Boost installation on your system, then PyViennaCL can also optionally use that, rather than the Boost subset shipped with the PyViennaCL sources. setuptools ---------- PyViennaCL uses the Python package `setuptools `_ for installation. Unless you are using **Python 3.4**, which comes with the required pieces, you may need to install setuptools. The **best way to do so**, which will also ensure you have the Python package manager *pip* installed, is to follow `the instructions here `_. OpenCL ------ By default, you will need an OpenCL implementation. PyViennaCL can still build and function without one, but will not perform to full effect. For information on how to get an OpenCL implementation on Linux, see this `howto `_. See also the installation section in the `ViennaCL Manual `_ on installation hints for Windows. If you have an OpenCL installation that you installed and is not managed by your system's package manager, then it is likely you will need to use the '--cl-lib-dir' configure option. If you do not wish to use OpenCL, then follow the *Custom installation* instructions below, and use the '--no-use-opencl' configure option. Extra requirements for building from source on Windows systems -------------------------------------------------------------- In addition to the components required above, Windows builds require the use of the Windows SDK version specific to the version of your Python installation. For instance, when you run Python, if you see the following:: Python 2.7.6 (default, Nov 10 2013, 19:24:18) [MSC v.1500 32 bit (Intel)] on win32 then you are using a release of Python 2.7 and you are building for a 32-bit installation of that version. You must therefore choose the SDK version and set the build environment accordingly. If you are building for a standard distribution (such as described in the example above) of Python 2.6, 2.7, 3.0, 3.1 or 3.2 (either 32- or 64-bit), you will need the `Microsoft Windows SDK v7.0 for Windows 7 and .NET Framework 3.5 SP1 `_. If you are building for a standard distribution of Python 3.3 (32- or 64-bit), you will need the `Microsoft Windows SDK v7.1 for Windows 7 and .NET Framework 4 `_. Having installed the correct SDK version, you will need to open an SDK command prompt and issue the following commands, according the architecture of your Python installation. If you are building for a 32-bit Python installation, use:: $> set DISTUTILS_USE_SDK=1 $> setenv /x86 /release If you are building for a 64-bit Python installation, use:: $> set DISTUTILS_USE_SDK=1 $> setenv /x64 /release At this point, you will be able to follow the instructions detailed below under *Installation*. Issue all commands from within the SDK command window. You might also be interested in the `Python Tools for Visual Studio `_, though these are not required either for building or using PyViennaCL. Installation ============ Please note that the commands below assume that the various programs invoked are available in your system PATH; if they are not, please provide the full path to the executable on invocation. This is especially relevant on Windows systems, where Python is not by default installed into the path. So, in this case, you might have to run something like:: $> C:\Python2.7\python -m pip install pyviennacl instead of just:: $> pip install pyviennacl Quick installation using pip ---------------------------- The following command should usually be enough to install PyViennaCL, as long as you have setuptools and pip installed (see above):: $> pip install pyviennacl If you have a recent installation of Python (2.7 or 3.3+), and a recent installation of pip (1.4+), then this should be painless. Note that this command assumes you have OpenCL available, and if you are on Linux, an OpenCL SDK. If this does not succeed, follow the instructions below. Custom installation ------------------- These instructions assume a UNIX-like platform (such as a Linux distribution or Mac OS X), but will work on a well-configured Windows system with little modification. If you are building from the release package, move on to the next paragraph. If you are building from git, then before doing anything else, navigate to your PyViennaCL folder and get the external submodules with:: $> git submodule update --init (On Windows you usually want to use the git bash for this) If you are in a hurry, then the following should just work:: $> python setup.py build $> sudo python setup.py install Otherwise, read the configuration options, configure, build and install:: $> ./configure.py --help $> ./configure.py --some-options $> python setup.py build $> sudo python setup.py install To build the HTML documentation using Sphinx, first install PyViennaCL as above, and then run:: $> cd doc $> make html after which HTML documentation will be in doc/_build/html. Or you can just access the documentation from within the Python interpreter after installation:: >>> import pyviennacl >>> help(pyviennacl) Authors and Contact =================== PyViennaCL was developed during the 2013 *Google Summer of Code* by `Toby St Clere Smithe `_. ViennaCL was developed under the aegis of the *Institute for Microelectronics* at the *Vienna University of Technology*. For any technical questions related to ViennaCL, please use `our mailing list `_. Licence ======= (Py)ViennaCL is distributed under the MIT (X11) License. See the file LICENSE in the source root directory. Platform: UNKNOWN Classifier: Environment :: Console Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: Intended Audience :: Other Audience Classifier: Intended Audience :: Science/Research Classifier: License :: OSI Approved :: MIT License Classifier: Natural Language :: English Classifier: Programming Language :: C++ Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.2 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Topic :: Scientific/Engineering Classifier: Topic :: Scientific/Engineering :: Mathematics Classifier: Topic :: Scientific/Engineering :: Physics pyviennacl-1.0.2+dfsg.orig/pyviennacl.egg-info/0000755000000000000000000000000012332260016020073 5ustar rootrootpyviennacl-1.0.2+dfsg.orig/pyviennacl.egg-info/top_level.txt0000644000000000000000000000002512332260013022617 0ustar rootrootpyviennacl _viennacl pyviennacl-1.0.2+dfsg.orig/pyviennacl.egg-info/SOURCES.txt0000644000000000000000000121324012332260014021760 0ustar rootrootChangeLog MANIFEST.in Makefile.in README.rst aksetup_helper.py configure.py setup.cfg setup.py doc/Makefile doc/build-doc.py doc/conf.py doc/index.rst doc/linalg.rst doc/make.bat doc/pycore.rst doc/util.rst doc/vclmath.rst doc/examples/basics.rst doc/examples/direct-solvers.rst doc/examples/index.rst doc/examples/iterative-solvers.rst doc/examples/products.rst doc/examples/slices-and-proxies.rst doc/examples/sparse-matrices.rst examples/README examples/basics.py examples/direct-solvers.py examples/iterative-solvers.py examples/products.py examples/slices-and-proxies.py examples/sparse-matrices.py examples/util.py external/boost-python-ublas-subset/boost_subset/boost/aligned_storage.hpp external/boost-python-ublas-subset/boost_subset/boost/array.hpp external/boost-python-ublas-subset/boost_subset/boost/assert.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic.hpp external/boost-python-ublas-subset/boost_subset/boost/bind.hpp external/boost-python-ublas-subset/boost_subset/boost/blank.hpp external/boost-python-ublas-subset/boost_subset/boost/blank_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/call_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/cast.hpp external/boost-python-ublas-subset/boost_subset/boost/cerrno.hpp external/boost-python-ublas-subset/boost_subset/boost/checked_delete.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono.hpp external/boost-python-ublas-subset/boost_subset/boost/circular_buffer.hpp external/boost-python-ublas-subset/boost_subset/boost/circular_buffer_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/compressed_pair.hpp external/boost-python-ublas-subset/boost_subset/boost/concept_archetype.hpp external/boost-python-ublas-subset/boost_subset/boost/concept_check.hpp external/boost-python-ublas-subset/boost_subset/boost/config.hpp external/boost-python-ublas-subset/boost_subset/boost/cstdint.hpp external/boost-python-ublas-subset/boost_subset/boost/cstdlib.hpp external/boost-python-ublas-subset/boost_subset/boost/current_function.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time.hpp external/boost-python-ublas-subset/boost_subset/boost/dynamic_bitset.hpp external/boost-python-ublas-subset/boost_subset/boost/dynamic_bitset_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/enable_shared_from_this.hpp external/boost-python-ublas-subset/boost_subset/boost/exception_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/foreach.hpp external/boost-python-ublas-subset/boost_subset/boost/foreach_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/format.hpp external/boost-python-ublas-subset/boost_subset/boost/function.hpp external/boost-python-ublas-subset/boost_subset/boost/function_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/get_pointer.hpp external/boost-python-ublas-subset/boost_subset/boost/implicit_cast.hpp external/boost-python-ublas-subset/boost_subset/boost/indirect_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/integer.hpp external/boost-python-ublas-subset/boost_subset/boost/integer_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/integer_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/io_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/is_placeholder.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/lexical_cast.hpp external/boost-python-ublas-subset/boost_subset/boost/limits.hpp external/boost-python-ublas-subset/boost_subset/boost/make_shared.hpp external/boost-python-ublas-subset/boost_subset/boost/math_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mem_fn.hpp external/boost-python-ublas-subset/boost_subset/boost/memory_order.hpp external/boost-python-ublas-subset/boost_subset/boost/mpi.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index_container.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index_container_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/next_prior.hpp external/boost-python-ublas-subset/boost_subset/boost/non_type.hpp external/boost-python-ublas-subset/boost_subset/boost/noncopyable.hpp external/boost-python-ublas-subset/boost_subset/boost/none.hpp external/boost-python-ublas-subset/boost_subset/boost/none_t.hpp external/boost-python-ublas-subset/boost_subset/boost/operators.hpp external/boost-python-ublas-subset/boost_subset/boost/optional.hpp external/boost-python-ublas-subset/boost_subset/boost/pointee.hpp external/boost-python-ublas-subset/boost_subset/boost/pointer_to_other.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor.hpp external/boost-python-ublas-subset/boost_subset/boost/progress.hpp external/boost-python-ublas-subset/boost_subset/boost/python.hpp external/boost-python-ublas-subset/boost_subset/boost/random.hpp external/boost-python-ublas-subset/boost_subset/boost/range.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio.hpp external/boost-python-ublas-subset/boost_subset/boost/rational.hpp external/boost-python-ublas-subset/boost_subset/boost/ref.hpp external/boost-python-ublas-subset/boost_subset/boost/scoped_array.hpp external/boost-python-ublas-subset/boost_subset/boost/scoped_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/shared_array.hpp external/boost-python-ublas-subset/boost_subset/boost/shared_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/static_assert.hpp external/boost-python-ublas-subset/boost_subset/boost/swap.hpp external/boost-python-ublas-subset/boost_subset/boost/thread.hpp external/boost-python-ublas-subset/boost_subset/boost/throw_exception.hpp external/boost-python-ublas-subset/boost_subset/boost/timer.hpp external/boost-python-ublas-subset/boost_subset/boost/token_functions.hpp external/boost-python-ublas-subset/boost_subset/boost/token_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/tokenizer.hpp external/boost-python-ublas-subset/boost_subset/boost/type.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered_map.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered_set.hpp external/boost-python-ublas-subset/boost_subset/boost/utility.hpp external/boost-python-ublas-subset/boost_subset/boost/version.hpp external/boost-python-ublas-subset/boost_subset/boost/visit_each.hpp external/boost-python-ublas-subset/boost_subset/boost/weak_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/add_facet.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/archive_exception.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/basic_archive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/basic_binary_iarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/basic_binary_iprimitive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/basic_binary_oarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/basic_binary_oprimitive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/basic_streambuf_locale_saver.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/basic_text_iarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/basic_text_iprimitive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/basic_text_oarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/basic_text_oprimitive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/basic_xml_archive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/basic_xml_iarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/basic_xml_oarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/binary_iarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/binary_iarchive_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/binary_oarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/binary_oarchive_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/binary_wiarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/binary_woarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/codecvt_null.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/dinkumware.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/polymorphic_iarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/polymorphic_oarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/shared_ptr_helper.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/text_iarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/text_oarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/text_wiarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/text_woarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/wcslen.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/xml_archive_exception.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/xml_iarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/xml_oarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/xml_wiarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/xml_woarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/abi_prefix.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/abi_suffix.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/archive_serializer_map.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/auto_link_archive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/auto_link_warchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/basic_iarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/basic_iserializer.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/basic_oarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/basic_oserializer.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/basic_pointer_iserializer.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/basic_pointer_oserializer.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/basic_serializer.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/basic_serializer_map.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/check.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/common_iarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/common_oarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/decl.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/interface_iarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/interface_oarchive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/iserializer.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/oserializer.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/register_archive.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/detail/utf8_codecvt_facet.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/archive_serializer_map.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/basic_binary_iarchive.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/basic_binary_iprimitive.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/basic_binary_oarchive.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/basic_binary_oprimitive.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/basic_text_iarchive.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/basic_text_iprimitive.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/basic_text_oarchive.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/basic_text_oprimitive.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/basic_xml_grammar.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/basic_xml_iarchive.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/basic_xml_oarchive.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/text_iarchive_impl.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/text_oarchive_impl.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/text_wiarchive_impl.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/text_woarchive_impl.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/xml_iarchive_impl.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/xml_oarchive_impl.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/xml_wiarchive_impl.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/impl/xml_woarchive_impl.ipp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/base64_from_binary.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/binary_from_base64.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/dataflow_exception.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/escape.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/insert_linebreaks.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/istream_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/mb_from_wchar.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/ostream_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/remove_whitespace.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/transform_width.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/unescape.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/wchar_from_mb.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/xml_escape.hpp external/boost-python-ublas-subset/boost_subset/boost/archive/iterators/xml_unescape.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/atomic.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/base.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/cas128strong.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/cas32strong.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/cas32weak.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/cas64strong.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/config.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/gcc-alpha.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/gcc-armv6plus.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/gcc-atomic.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/gcc-cas.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/gcc-ppc.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/gcc-sparcv9.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/gcc-x86.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/interlocked.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/link.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/linux-arm.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/lockpool.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/platform.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/type-classification.hpp external/boost-python-ublas-subset/boost_subset/boost/atomic/detail/windows.hpp external/boost-python-ublas-subset/boost_subset/boost/bind/arg.hpp external/boost-python-ublas-subset/boost_subset/boost/bind/bind.hpp external/boost-python-ublas-subset/boost_subset/boost/bind/bind_cc.hpp external/boost-python-ublas-subset/boost_subset/boost/bind/bind_mf2_cc.hpp external/boost-python-ublas-subset/boost_subset/boost/bind/bind_mf_cc.hpp external/boost-python-ublas-subset/boost_subset/boost/bind/bind_template.hpp external/boost-python-ublas-subset/boost_subset/boost/bind/mem_fn.hpp external/boost-python-ublas-subset/boost_subset/boost/bind/mem_fn_cc.hpp external/boost-python-ublas-subset/boost_subset/boost/bind/mem_fn_template.hpp external/boost-python-ublas-subset/boost_subset/boost/bind/mem_fn_vw.hpp external/boost-python-ublas-subset/boost_subset/boost/bind/placeholders.hpp external/boost-python-ublas-subset/boost_subset/boost/bind/protect.hpp external/boost-python-ublas-subset/boost_subset/boost/bind/storage.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/ceil.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/chrono.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/chrono_io.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/clock_string.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/config.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/duration.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/floor.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/include.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/process_cpu_clocks.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/round.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/system_clocks.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/thread_clock.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/time_point.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/is_evenly_divisible_by.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/scan_keyword.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/static_assert.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/system.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/inlined/chrono.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/inlined/process_cpu_clocks.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/inlined/thread_clock.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/inlined/mac/chrono.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/inlined/mac/thread_clock.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/inlined/posix/chrono.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/inlined/posix/process_cpu_clocks.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/inlined/posix/thread_clock.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/inlined/win/chrono.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/inlined/win/process_cpu_clocks.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/inlined/win/thread_clock.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/detail/no_warning/signed_unsigned_cmp.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/duration_get.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/duration_io.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/duration_put.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/duration_style.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/duration_units.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/ios_base_state.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/time_point_get.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/time_point_io.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/time_point_put.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/time_point_units.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/timezone.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/utility/ios_base_state_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/utility/manip_base.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io/utility/to_string.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/io_v1/chrono_io.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/typeof/boost/ratio.hpp external/boost-python-ublas-subset/boost_subset/boost/chrono/typeof/boost/chrono/chrono.hpp external/boost-python-ublas-subset/boost_subset/boost/concept/assert.hpp external/boost-python-ublas-subset/boost_subset/boost/concept/usage.hpp external/boost-python-ublas-subset/boost_subset/boost/concept/detail/backward_compatibility.hpp external/boost-python-ublas-subset/boost_subset/boost/concept/detail/borland.hpp external/boost-python-ublas-subset/boost_subset/boost/concept/detail/concept_def.hpp external/boost-python-ublas-subset/boost_subset/boost/concept/detail/concept_undef.hpp external/boost-python-ublas-subset/boost_subset/boost/concept/detail/general.hpp external/boost-python-ublas-subset/boost_subset/boost/concept/detail/has_constraints.hpp external/boost-python-ublas-subset/boost_subset/boost/concept/detail/msvc.hpp external/boost-python-ublas-subset/boost_subset/boost/config/abi_prefix.hpp external/boost-python-ublas-subset/boost_subset/boost/config/abi_suffix.hpp external/boost-python-ublas-subset/boost_subset/boost/config/auto_link.hpp external/boost-python-ublas-subset/boost_subset/boost/config/posix_features.hpp external/boost-python-ublas-subset/boost_subset/boost/config/requires_threads.hpp external/boost-python-ublas-subset/boost_subset/boost/config/select_compiler_config.hpp external/boost-python-ublas-subset/boost_subset/boost/config/select_platform_config.hpp external/boost-python-ublas-subset/boost_subset/boost/config/select_stdlib_config.hpp external/boost-python-ublas-subset/boost_subset/boost/config/suffix.hpp external/boost-python-ublas-subset/boost_subset/boost/config/user.hpp external/boost-python-ublas-subset/boost_subset/boost/config/warning_disable.hpp external/boost-python-ublas-subset/boost_subset/boost/config/abi/borland_prefix.hpp external/boost-python-ublas-subset/boost_subset/boost/config/abi/borland_suffix.hpp external/boost-python-ublas-subset/boost_subset/boost/config/abi/msvc_prefix.hpp external/boost-python-ublas-subset/boost_subset/boost/config/abi/msvc_suffix.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/borland.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/clang.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/codegear.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/comeau.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/common_edg.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/compaq_cxx.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/cray.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/digitalmars.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/gcc.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/gcc_xml.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/greenhills.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/hp_acc.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/intel.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/kai.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/metrowerks.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/mpw.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/nvcc.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/pathscale.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/pgi.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/sgi_mipspro.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/sunpro_cc.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/vacpp.hpp external/boost-python-ublas-subset/boost_subset/boost/config/compiler/visualc.hpp external/boost-python-ublas-subset/boost_subset/boost/config/no_tr1/cmath.hpp external/boost-python-ublas-subset/boost_subset/boost/config/no_tr1/complex.hpp external/boost-python-ublas-subset/boost_subset/boost/config/no_tr1/functional.hpp external/boost-python-ublas-subset/boost_subset/boost/config/no_tr1/memory.hpp external/boost-python-ublas-subset/boost_subset/boost/config/no_tr1/utility.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/aix.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/amigaos.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/beos.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/bsd.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/cray.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/cygwin.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/hpux.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/irix.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/linux.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/macos.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/qnxnto.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/solaris.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/symbian.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/vms.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/vxworks.hpp external/boost-python-ublas-subset/boost_subset/boost/config/platform/win32.hpp external/boost-python-ublas-subset/boost_subset/boost/config/stdlib/dinkumware.hpp external/boost-python-ublas-subset/boost_subset/boost/config/stdlib/libcomo.hpp external/boost-python-ublas-subset/boost_subset/boost/config/stdlib/libcpp.hpp external/boost-python-ublas-subset/boost_subset/boost/config/stdlib/libstdcpp3.hpp external/boost-python-ublas-subset/boost_subset/boost/config/stdlib/modena.hpp external/boost-python-ublas-subset/boost_subset/boost/config/stdlib/msl.hpp external/boost-python-ublas-subset/boost_subset/boost/config/stdlib/roguewave.hpp external/boost-python-ublas-subset/boost_subset/boost/config/stdlib/sgi.hpp external/boost-python-ublas-subset/boost_subset/boost/config/stdlib/stlport.hpp external/boost-python-ublas-subset/boost_subset/boost/config/stdlib/vacpp.hpp external/boost-python-ublas-subset/boost_subset/boost/container/allocator_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/container/container_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/container/deque.hpp external/boost-python-ublas-subset/boost_subset/boost/container/list.hpp external/boost-python-ublas-subset/boost_subset/boost/container/scoped_allocator.hpp external/boost-python-ublas-subset/boost_subset/boost/container/scoped_allocator_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/container/throw_exception.hpp external/boost-python-ublas-subset/boost_subset/boost/container/vector.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/advanced_insert_int.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/algorithms.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/allocation_type.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/allocator_version_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/config_begin.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/config_end.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/destroyers.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/iterators.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/memory_util.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/mpl.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/multiallocation_chain.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/node_alloc_holder.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/pair.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/preprocessor.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/transform_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/type_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/utilities.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/value_init.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/variadic_templates_tools.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/version_type.hpp external/boost-python-ublas-subset/boost_subset/boost/container/detail/workaround.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/adjust_functors.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/c_time.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/compiler_config.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/constrained_value.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_clock_device.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_defs.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_duration.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_duration_types.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_facet.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_format_simple.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_formatting.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_formatting_limited.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_formatting_locales.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_generator_formatter.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_generator_parser.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_generators.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_names_put.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/date_parsing.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/dst_rules.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/dst_transition_generators.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/filetime_functions.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/format_date_parser.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian_calendar.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian_calendar.ipp external/boost-python-ublas-subset/boost_subset/boost/date_time/int_adapter.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/iso_format.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/locale_config.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/microsec_time_clock.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/parse_format_base.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/period.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/period_formatter.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/period_parser.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/special_defs.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/special_values_formatter.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/special_values_parser.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/string_convert.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/string_parse_tree.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/strings_from_facet.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/time.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/time_clock.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/time_defs.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/time_duration.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/time_facet.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/time_formatting_streams.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/time_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/time_parsing.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/time_resolution_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/time_system_counted.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/time_system_split.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/time_zone_base.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/time_zone_names.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/tz_db_base.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/wrapping_int.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/year_month_day.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/conversion.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/formatters.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/formatters_limited.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/greg_calendar.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/greg_date.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/greg_day.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/greg_day_of_year.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/greg_duration.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/greg_duration_types.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/greg_facet.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/greg_month.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/greg_weekday.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/greg_year.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/greg_ymd.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/gregorian.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/gregorian_io.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/gregorian_types.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/gregorian/parsers.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/local_time/conversion.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/local_time/custom_time_zone.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/local_time/date_duration_operators.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/local_time/dst_transition_day_rules.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/local_time/local_date_time.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/local_time/local_time.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/local_time/local_time_io.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/local_time/local_time_types.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/local_time/posix_time_zone.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/local_time/tz_database.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/conversion.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/date_duration_operators.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/posix_time.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/posix_time_config.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/posix_time_duration.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/posix_time_io.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/posix_time_legacy_io.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/posix_time_system.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/posix_time_types.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/ptime.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/time_formatters.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/time_formatters_limited.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/time_parsers.hpp external/boost-python-ublas-subset/boost_subset/boost/date_time/posix_time/time_period.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/allocator_utilities.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/atomic_count.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/atomic_redef_macros.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/atomic_undef_macros.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/binary_search.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/call_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/compressed_pair.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/container_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/dynamic_bitset.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/endian.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/fenv.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/indirect_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/interlocked.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/is_function_ref_tester.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/is_incrementable.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/is_xxx.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/lcast_precision.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/lightweight_mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/lightweight_test.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/no_exceptions_support.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/numeric_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/ob_call_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/ob_compressed_pair.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/quick_allocator.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/reference_content.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/scoped_enum_emulation.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/select_type.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/sp_typeinfo.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/templated_streams.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/utf8_codecvt_facet.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/utf8_codecvt_facet.ipp external/boost-python-ublas-subset/boost_subset/boost/detail/workaround.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/winapi/GetCurrentProcess.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/winapi/GetCurrentThread.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/winapi/GetLastError.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/winapi/GetProcessTimes.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/winapi/GetThreadTimes.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/winapi/basic_types.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/winapi/time.hpp external/boost-python-ublas-subset/boost_subset/boost/detail/winapi/timers.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/current_exception_cast.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/diagnostic_information.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/exception.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/get_error_info.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/info.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/to_string.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/to_string_stub.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/detail/attribute_noreturn.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/detail/clone_current_exception.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/detail/error_info_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/detail/exception_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/detail/is_output_streamable.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/detail/object_hex_dump.hpp external/boost-python-ublas-subset/boost_subset/boost/exception/detail/type_info.hpp external/boost-python-ublas-subset/boost_subset/boost/format/alt_sstream.hpp external/boost-python-ublas-subset/boost_subset/boost/format/alt_sstream_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/format/exceptions.hpp external/boost-python-ublas-subset/boost_subset/boost/format/feed_args.hpp external/boost-python-ublas-subset/boost_subset/boost/format/format_class.hpp external/boost-python-ublas-subset/boost_subset/boost/format/format_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/format/format_implementation.hpp external/boost-python-ublas-subset/boost_subset/boost/format/free_funcs.hpp external/boost-python-ublas-subset/boost_subset/boost/format/group.hpp external/boost-python-ublas-subset/boost_subset/boost/format/internals.hpp external/boost-python-ublas-subset/boost_subset/boost/format/internals_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/format/parsing.hpp external/boost-python-ublas-subset/boost_subset/boost/format/detail/compat_workarounds.hpp external/boost-python-ublas-subset/boost_subset/boost/format/detail/config_macros.hpp external/boost-python-ublas-subset/boost_subset/boost/format/detail/msvc_disambiguater.hpp external/boost-python-ublas-subset/boost_subset/boost/format/detail/unset_macros.hpp external/boost-python-ublas-subset/boost_subset/boost/format/detail/workarounds_gcc-2_95.hpp external/boost-python-ublas-subset/boost_subset/boost/format/detail/workarounds_stlport.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function0.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function1.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function10.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function2.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function3.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function4.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function5.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function6.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function7.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function8.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function9.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function_base.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/function/function_template.hpp external/boost-python-ublas-subset/boost_subset/boost/function/detail/function_iterate.hpp external/boost-python-ublas-subset/boost_subset/boost/function/detail/gen_maybe_include.pl external/boost-python-ublas-subset/boost_subset/boost/function/detail/maybe_include.hpp external/boost-python-ublas-subset/boost_subset/boost/function/detail/prologue.hpp external/boost-python-ublas-subset/boost_subset/boost/functional/hash.hpp external/boost-python-ublas-subset/boost_subset/boost/functional/hash_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/functional/hash/extensions.hpp external/boost-python-ublas-subset/boost_subset/boost/functional/hash/hash.hpp external/boost-python-ublas-subset/boost_subset/boost/functional/hash/hash_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/functional/hash/detail/float_functions.hpp external/boost-python-ublas-subset/boost_subset/boost/functional/hash/detail/hash_float.hpp external/boost-python-ublas-subset/boost_subset/boost/functional/hash/detail/limits.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/mpl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/std_pair.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/mpl/mpl_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/mpl/detail/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/mpl/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/mpl/detail/category_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/mpl/detail/empty_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/mpl/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/mpl/detail/has_key_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/mpl/detail/is_sequence_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/mpl/detail/is_view_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/mpl/detail/size_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/mpl/detail/value_at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/struct/adapt_struct.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/struct/detail/adapt_base.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/struct/detail/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/struct/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/struct/detail/category_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/struct/detail/deref_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/struct/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/struct/detail/extension.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/struct/detail/is_sequence_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/struct/detail/is_view_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/struct/detail/size_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/struct/detail/value_at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/adapted/struct/detail/value_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/accumulate.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/accumulate_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/fold.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/fold_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/for_each.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/for_each_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/iter_fold.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/iter_fold_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/reverse_fold.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/reverse_iter_fold.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/reverse_iter_fold_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/detail/fold.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/detail/for_each.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/detail/preprocessed/iter_fold.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_iter_fold.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/all.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/any.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/count.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/count_if.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/find.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/find_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/find_if.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/find_if_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/none.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/detail/all.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/detail/any.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/detail/count.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/detail/count_if.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/detail/find_if.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/detail/segmented_find.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/query/detail/segmented_find_if.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/clear.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/erase.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/erase_key.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/filter.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/filter_if.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/insert.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/insert_range.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/join.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/pop_back.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/pop_front.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/push_back.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/push_front.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/remove.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/remove_if.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/replace.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/replace_if.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/reverse.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/transform.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/zip.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/detail/replace.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/detail/replace_if.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/detail/preprocessed/zip.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/detail/preprocessed/zip10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/detail/preprocessed/zip20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/detail/preprocessed/zip30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/detail/preprocessed/zip40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/algorithm/transformation/detail/preprocessed/zip50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/back_extended_deque.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/convert.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/deque.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/deque_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/deque_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/front_extended_deque.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/build_deque.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/convert_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/deque_keyed_values.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/is_sequence_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/keyed_element.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/value_at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/as_deque.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/build_deque.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/deque.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/deque_forward_ctor.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/deque_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/deque_initial_size.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/deque_keyed_values.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/deque_keyed_values_call.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/limits.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque10_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque20_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque30_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque40_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque50_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/cons_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/deque_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/ignore.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/list_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/make_cons.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/make_deque.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/make_list.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/make_map.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/make_set.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/make_vector.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/map_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/pair_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/vector_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/pp_deque_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/pp_make_deque.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/pp_make_map.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/pp_map_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/deque_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/deque_tie10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/deque_tie20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/deque_tie30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/deque_tie40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/deque_tie50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/list_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/list_tie10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/list_tie20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/list_tie30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/list_tie40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/list_tie50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_deque.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_deque10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_deque20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_deque30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_deque40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_deque50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_list.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_list10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_list20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_list30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_list40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_list50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_map.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_map10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_map20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_map30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_map40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_map50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_set.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_set10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_set20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_set30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_set40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_set50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_vector.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_vector10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_vector20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_vector30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_vector40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/make_vector50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/map_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/map_tie10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/map_tie20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/map_tie30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/map_tie40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/map_tie50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/vector_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/vector_tie10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/vector_tie20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/vector_tie30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/vector_tie40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/generation/detail/preprocessed/vector_tie50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/cons.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/cons_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/cons_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/convert.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/limits.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/list.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/list_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/build_cons.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/convert_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/deref_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/empty_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/equal_to_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/list_forward_ctor.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/list_to_cons.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/list_to_cons_call.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/next_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/reverse_cons.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/value_at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/value_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list10_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list20_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list30_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list40_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list50_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list_to_cons.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list_to_cons10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list_to_cons20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list_to_cons30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list_to_cons40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/list/detail/preprocessed/list_to_cons50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/convert.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/map.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/map_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/map_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/at_key_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/build_map.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/map_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/value_at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/value_at_key_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/as_map.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/convert.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/convert_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/deref_data_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/deref_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/key_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/limits.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/map.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/map_forward_ctor.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/map_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/value_at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/value_of_data_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/value_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/as_map.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/as_map10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/as_map20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/as_map30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/as_map40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/as_map50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/map.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/map10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/map10_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/map20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/map20_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/map30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/map30_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/map40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/map40_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/map50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/map50_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/map/detail/cpp03/preprocessed/map_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/convert.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/limits.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/set.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/set_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/as_set.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/convert_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/deref_data_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/deref_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/key_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/set_forward_ctor.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/value_of_data_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/value_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/as_set.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/as_set10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/as_set20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/as_set30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/as_set40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/as_set50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/set.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/set10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/set10_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/set20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/set20_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/set30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/set30_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/set40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/set40_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/set50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/set50_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/set/detail/preprocessed/set_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/convert.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/limits.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/vector.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/vector10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/vector10_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/vector20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/vector20_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/vector30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/vector30_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/vector40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/vector40_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/vector50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/vector50_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/vector_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/vector_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/advance_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/as_vector.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/convert_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/deref_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/distance_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/equal_to_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/next_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/prior_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/value_at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/value_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/vector_forward_ctor.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/vector_n.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/vector_n_chooser.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/as_vector.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/as_vector10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/as_vector20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/as_vector30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/as_vector40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/as_vector50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector10_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector20_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector30_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector40_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector50_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector_chooser.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector_chooser10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector_chooser20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector_chooser30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector_chooser40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector_chooser50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vector_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vvector10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vvector10_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vvector20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vvector20_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vvector30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vvector30_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vvector40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vvector40_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vvector50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/container/vector/detail/preprocessed/vvector50_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/functional/adapter/fused.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/functional/adapter/detail/access.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/functional/generation/make_fused.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/functional/generation/detail/gen_make_adapter.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/functional/invocation/invoke.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/functional/invocation/limits.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/functional/invocation/detail/that_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/all.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/any.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/as_list.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/as_vector.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/at.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/at_c.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/begin.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/category_of.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/cons.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/end.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/filter_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/find_if.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/fold.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/for_each.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/front.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/intrinsic.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/is_segmented.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/is_sequence.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/is_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/iterator_base.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/make_fused.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/make_vector.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/mpl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/next.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/pop_front.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/push_back.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/push_front.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/reverse_fold.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/single_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/size.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/std_pair.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/tag_of_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/transform.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/value_at.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/value_of.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/vector.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/include/zip_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/advance.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/basic_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/deref.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/deref_data.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/distance.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/iterator_adapter.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/iterator_facade.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/key_of.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/mpl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/next.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/prior.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/segmented_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/value_of.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/value_of_data.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/detail/adapt_deref_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/detail/adapt_value_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/detail/advance.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/detail/distance.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/detail/segment_sequence.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/detail/segmented_equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/detail/segmented_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/detail/segmented_next_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/mpl/convert_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/iterator/mpl/fusion_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/at.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/back.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/begin.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/clear.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/empty.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/end.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/erase.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/erase_key.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/front.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/has_key.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/insert.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/insert_range.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/pop_back.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/pop_front.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/push_back.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/push_front.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/size.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/mpl/detail/clear.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/convert.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/io.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/sequence_facade.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison/enable_comparison.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison/equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison/greater.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison/greater_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison/less.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison/less_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison/not_equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison/detail/equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison/detail/greater.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison/detail/greater_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison/detail/less.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison/detail/less_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/comparison/detail/not_equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/at.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/at_c.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/at_key.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/back.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/begin.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/empty.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/end.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/front.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/has_key.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/segments.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/size.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/value_at.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/value_at_key.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/detail/segmented_end.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/intrinsic/detail/segmented_size.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/io/in.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/io/out.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/io/detail/in.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/io/detail/manip.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/sequence/io/detail/out.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/as_const.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/category_of.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/is_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/is_segmented.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/is_sequence.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/is_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/iterator_base.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/pair.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/segmented_fold_until.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/sequence_base.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/tag_of.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/tag_of_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/unused.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/void.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/detail/access.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/detail/as_fusion_element.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/detail/category_of.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/detail/is_mpl_sequence.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/detail/is_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/detail/mpl_iterator_category.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/detail/pp_round.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/support/detail/segmented_fold_until_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/make_tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/tuple_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/tuple_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/tuple_expand.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/make_tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/make_tuple10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/make_tuple20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/make_tuple30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/make_tuple40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/make_tuple50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple10_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple20_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple30_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple40_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple50_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple_tie.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple_tie10.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple_tie20.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple_tie30.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple_tie40.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/tuple/detail/preprocessed/tuple_tie50.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/filter_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/iterator_range.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/joint_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/detail/strictest_traversal.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/filter_view/filter_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/filter_view/filter_view_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/filter_view/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/filter_view/detail/deref_data_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/filter_view/detail/deref_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/filter_view/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/filter_view/detail/equal_to_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/filter_view/detail/key_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/filter_view/detail/next_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/filter_view/detail/size_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/filter_view/detail/value_of_data_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/filter_view/detail/value_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/iterator_range/iterator_range.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/iterator_range/detail/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/iterator_range/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/iterator_range/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/iterator_range/detail/is_segmented_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/iterator_range/detail/segmented_iterator_range.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/iterator_range/detail/segments_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/iterator_range/detail/size_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/iterator_range/detail/value_at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/joint_view/joint_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/joint_view/joint_view_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/joint_view/joint_view_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/joint_view/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/joint_view/detail/deref_data_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/joint_view/detail/deref_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/joint_view/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/joint_view/detail/key_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/joint_view/detail/next_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/joint_view/detail/value_of_data_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/joint_view/detail/value_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/reverse_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/reverse_view_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/detail/advance_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/detail/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/detail/deref_data_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/detail/deref_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/detail/distance_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/detail/key_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/detail/next_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/detail/prior_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/detail/value_at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/detail/value_of_data_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/reverse_view/detail/value_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/single_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/single_view_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/detail/advance_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/detail/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/detail/deref_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/detail/distance_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/detail/equal_to_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/detail/next_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/detail/prior_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/detail/size_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/detail/value_at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/single_view/detail/value_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/transform_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/transform_view_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/transform_view_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/detail/advance_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/detail/apply_transform_result.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/detail/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/detail/deref_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/detail/distance_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/detail/equal_to_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/detail/next_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/detail/prior_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/detail/value_at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/transform_view/detail/value_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/zip_view.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/zip_view_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/zip_view_iterator_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/detail/advance_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/detail/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/detail/begin_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/detail/deref_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/detail/distance_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/detail/end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/detail/equal_to_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/detail/next_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/detail/prior_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/detail/size_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/detail/value_at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/fusion/view/zip_view/detail/value_of_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/adjacency_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/adjacency_list.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/breadth_first_search.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/buffer_concepts.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/graph_concepts.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/graph_mutability_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/graph_selectors.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/graph_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/iteration_macros.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/named_function_params.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/named_graph.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/numeric_values.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/overloading.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/properties.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/reverse_graph.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/two_bit_color_map.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/visitors.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/detail/adj_list_edge_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/detail/adjacency_list.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/detail/d_ary_heap.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/detail/edge.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/distributed/breadth_first_search.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/distributed/concepts.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/distributed/queue.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/distributed/two_bit_color_map.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/distributed/unsafe_serialize.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/distributed/detail/filtered_queue.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/distributed/detail/queue.ipp external/boost-python-ublas-subset/boost_subset/boost/graph/parallel/algorithm.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/parallel/basic_reduce.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/parallel/container_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/parallel/process_group.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/parallel/properties.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/parallel/simple_trigger.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/parallel/detail/inplace_all_to_all.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/parallel/detail/untracked_pair.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/property_maps/constant_property_map.hpp external/boost-python-ublas-subset/boost_subset/boost/graph/property_maps/null_property_map.hpp external/boost-python-ublas-subset/boost_subset/boost/integer/integer_mask.hpp external/boost-python-ublas-subset/boost_subset/boost/integer/static_log2.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/circular_list_algorithms.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/circular_slist_algorithms.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/intrusive_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/linear_slist_algorithms.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/link_mode.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/list.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/list_hook.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/options.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/pointer_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/slist.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/slist_hook.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/assert.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/clear_on_destructor_base.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/common_slist_algorithms.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/config_begin.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/config_end.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/ebo_functor_holder.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/function_detector.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/generic_hook.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/has_member_function_callable_with.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/is_stateful_value_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/list_node.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/memory_util.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/mpl.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/parent_from_member.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/preprocessor.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/slist_node.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/utilities.hpp external/boost-python-ublas-subset/boost_subset/boost/intrusive/detail/workaround.hpp external/boost-python-ublas-subset/boost_subset/boost/io/ios_state.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/counting_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/filter_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/interoperable.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/iterator_adaptor.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/iterator_categories.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/iterator_concepts.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/iterator_facade.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/iterator_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/permutation_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/reverse_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/transform_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/zip_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/detail/config_def.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/detail/config_undef.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/detail/enable_if.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/detail/facade_iterator_category.hpp external/boost-python-ublas-subset/boost_subset/boost/iterator/detail/minimum_category.hpp external/boost-python-ublas-subset/boost_subset/boost/math/common_factor_ct.hpp external/boost-python-ublas-subset/boost_subset/boost/math/common_factor_rt.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions.hpp external/boost-python-ublas-subset/boost_subset/boost/math/constants/calculate_constants.hpp external/boost-python-ublas-subset/boost_subset/boost/math/constants/constants.hpp external/boost-python-ublas-subset/boost_subset/boost/math/policies/error_handling.hpp external/boost-python-ublas-subset/boost_subset/boost/math/policies/policy.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/acosh.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/airy.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/asinh.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/atanh.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/bessel.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/beta.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/binomial.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/cbrt.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/cos_pi.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/digamma.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/ellint_1.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/ellint_2.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/ellint_3.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/ellint_rc.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/ellint_rd.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/ellint_rf.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/ellint_rj.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/erf.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/expint.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/expm1.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/factorials.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/fpclassify.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/gamma.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/hankel.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/hermite.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/hypot.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/jacobi_elliptic.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/laguerre.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/lanczos.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/legendre.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/log1p.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/math_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/modf.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/next.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/owens_t.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/pow.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/powm1.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/round.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/sign.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/sin_pi.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/sinc.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/sinhc.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/spherical_harmonic.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/sqrt1pm1.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/trunc.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/zeta.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/airy_ai_bi_zero.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_i0.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_i1.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_ik.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_j0.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_j1.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_jn.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_jy.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_jy_asym.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_jy_series.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_jy_zero.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_k0.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_k1.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_kn.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_y0.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_y1.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/bessel_yn.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/erf_inv.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/fp_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/gamma_inva.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/ibeta_inv_ab.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/ibeta_inverse.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/iconv.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/igamma_inverse.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/igamma_large.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/lanczos_sse2.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/lgamma_small.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/round_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/t_distribution_inv.hpp external/boost-python-ublas-subset/boost_subset/boost/math/special_functions/detail/unchecked_factorial.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/big_constant.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/config.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/fraction.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/precision.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/promotion.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/rational.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/real_cast.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/roots.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/series.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/toms748_solve.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/user.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/workaround.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_10.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_11.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_12.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_13.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_14.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_15.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_16.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_17.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_18.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_19.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_2.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_20.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_3.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_4.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_5.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_6.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_7.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_8.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner1_9.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_10.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_11.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_12.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_13.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_14.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_15.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_16.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_17.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_18.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_19.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_2.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_20.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_3.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_4.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_5.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_6.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_7.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_8.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner2_9.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_10.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_11.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_12.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_13.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_14.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_15.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_16.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_17.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_18.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_19.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_2.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_20.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_3.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_4.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_5.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_6.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_7.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_8.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/polynomial_horner3_9.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_10.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_11.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_12.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_13.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_14.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_15.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_16.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_17.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_18.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_19.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_2.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_20.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_3.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_4.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_5.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_6.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_7.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_8.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner1_9.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_10.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_11.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_12.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_13.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_14.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_15.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_16.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_17.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_18.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_19.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_2.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_20.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_3.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_4.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_5.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_6.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_7.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_8.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner2_9.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_10.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_11.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_12.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_13.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_14.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_15.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_16.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_17.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_18.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_19.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_2.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_20.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_3.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_4.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_5.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_6.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_7.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_8.hpp external/boost-python-ublas-subset/boost_subset/boost/math/tools/detail/rational_horner3_9.hpp external/boost-python-ublas-subset/boost_subset/boost/move/algorithm.hpp external/boost-python-ublas-subset/boost_subset/boost/move/core.hpp external/boost-python-ublas-subset/boost_subset/boost/move/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/move/move.hpp external/boost-python-ublas-subset/boost_subset/boost/move/traits.hpp external/boost-python-ublas-subset/boost_subset/boost/move/utility.hpp external/boost-python-ublas-subset/boost_subset/boost/move/detail/config_begin.hpp external/boost-python-ublas-subset/boost_subset/boost/move/detail/config_end.hpp external/boost-python-ublas-subset/boost_subset/boost/move/detail/meta_utils.hpp external/boost-python-ublas-subset/boost_subset/boost/move/detail/move_helpers.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/O1_size.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/O1_size_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/advance.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/advance_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/alias.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/always.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/and.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/apply.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/apply_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/apply_wrap.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/arg.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/arg_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/arithmetic.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/assert.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/at.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/at_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/back.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/back_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/back_inserter.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/base.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/begin.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/begin_end.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/begin_end_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/bind.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/bind_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/bitand.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/bitxor.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/bool.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/bool_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/clear.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/clear_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/comparison.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/contains.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/contains_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/copy.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/deref.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/distance.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/distance_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/divides.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/empty.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/empty_base.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/empty_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/empty_sequence.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/end.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/erase.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/erase_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/erase_key.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/erase_key_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/eval_if.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/find.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/find_if.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/fold.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/for_each.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/front.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/front_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/front_inserter.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/greater.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/greater_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/has_key.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/has_key_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/has_xxx.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/identity.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/if.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/inherit.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/inherit_linearly.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/insert.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/insert_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/insert_range.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/insert_range_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/inserter.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/int.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/int_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/integral_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/integral_c_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/integral_c_tag.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/is_placeholder.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/is_sequence.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/iter_fold.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/iter_fold_if.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/iterator_category.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/iterator_range.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/iterator_tags.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/joint_view.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/key_type_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/lambda.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/lambda_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/less.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/less_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/logical.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/long.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/long_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/min.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/min_max.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/minus.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/modulus.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/multiplies.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/negate.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/next.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/next_prior.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/not.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/not_equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/numeric_cast.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/or.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/order_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/pair.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/pair_view.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/partition.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/placeholders.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/plus.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/pop_back.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/pop_back_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/pop_front.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/pop_front_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/print.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/prior.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/protect.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/push_back.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/push_back_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/push_front.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/push_front_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/quote.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/range_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/remove.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/remove_if.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/reverse_fold.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/reverse_iter_fold.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/same_as.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/sequence_tag.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/sequence_tag_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/single_view.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/size.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/size_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/size_t.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/size_t_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/sort.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/stable_partition.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/tag.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/times.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/transform.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/transform_view.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/unpack_args.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/value_type_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/void.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/void_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/zip_view.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/O1_size_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/adl_barrier.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/advance_backward.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/advance_forward.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/arg_typedef.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/arithmetic_op.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/arity.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/arity_spec.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/back_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/begin_end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/clear_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/common_name_wknd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/comparison_op.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/contains_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/count_args.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/empty_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/erase_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/erase_key_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/find_if_pred.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/fold_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/fold_impl_body.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/front_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/full_lambda.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/has_apply.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/has_begin.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/has_key_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/has_rebind.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/has_size.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/has_tag.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/has_type.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/include_preprocessed.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/insert_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/insert_range_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/inserter_algorithm.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/integral_wrapper.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/is_msvc_eti_arg.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/iter_apply.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/iter_fold_if_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/iter_fold_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/iter_push_front.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/joint_iter.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/lambda_arity_param.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/lambda_no_ctps.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/lambda_spec.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/lambda_support.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/largest_int.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/logical_op.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/msvc_dtw.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/msvc_eti_base.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/msvc_is_class.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/msvc_never_true.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/msvc_type.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/na.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/na_assert.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/na_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/na_spec.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/nested_type_wknd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/nttp_decl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/numeric_cast_utils.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/numeric_op.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/order_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/overload_names.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/partition_op.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/pop_back_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/pop_front_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/ptr_to_ref.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/push_back_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/push_front_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/reverse_fold_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/reverse_fold_impl_body.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/reverse_iter_fold_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/sequence_wrapper.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/single_element_iter.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/size_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/sort_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/static_cast.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/template_arity.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/template_arity_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/traits_lambda_spec.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/transform_iter.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/type_wrapper.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/unwrap.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/value_wknd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/yes_no.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/adl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/arrays.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/bcc.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/bind.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/compiler.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/ctps.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/dependent_nttp.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/dtp.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/eti.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/forwarding.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/gcc.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/has_apply.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/has_xxx.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/integral.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/intel.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/lambda.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/msvc.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/msvc_typename.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/nttp.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/operators.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/overload_resolution.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/pp_counter.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/preprocessor.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/static_constant.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/ttp.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/typeof.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/use_preprocessed.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/config/workaround.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/and.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/apply.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/arg.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/basic_bind.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/bind.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/bitand.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/bitor.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/bitxor.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/deque.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/divides.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/greater.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/inherit.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/lambda_no_ctps.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/less.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/list.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/list_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/map.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/minus.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/modulus.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/or.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/plus.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/quote.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/set.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/set_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/shift_left.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/shift_right.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/times.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/unpack_args.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/vector.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/gcc/vector_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/advance_backward.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/advance_forward.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/and.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/apply.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/apply_wrap.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/arg.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/basic_bind.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/bind.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/bitand.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/bitor.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/bitxor.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/deque.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/divides.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/fold_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/full_lambda.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/greater.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/greater_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/inherit.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/iter_fold_if_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/iter_fold_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/lambda_no_ctps.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/less.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/less_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/list.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/list_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/map.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/minus.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/modulus.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/not_equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/or.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/placeholders.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/plus.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/quote.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/reverse_fold_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/reverse_iter_fold_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/set.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/set_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/shift_left.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/shift_right.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/template_arity.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/times.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/unpack_args.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/vector.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessed/plain/vector_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessor/add.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessor/def_params_tail.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessor/default_params.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessor/enum.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessor/ext_params.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessor/filter_params.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessor/params.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessor/partial_spec_params.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessor/range.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessor/repeat.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessor/sub.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/preprocessor/tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/range_c/O1_size.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/range_c/back.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/range_c/empty.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/range_c/front.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/range_c/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/range_c/size.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/aux_/range_c/tag.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/limits/arity.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/limits/list.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/limits/map.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/limits/set.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/limits/unrolling.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/limits/vector.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/list0.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/list0_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/list10.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/list10_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/list20.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/list20_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/list30.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/list30_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/list40.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/list40_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/list50.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/list50_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/O1_size.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/begin_end.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/clear.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/empty.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/front.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/include_preprocessed.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/item.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/numbered.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/numbered_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/pop_front.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/push_back.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/push_front.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/size.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/tag.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/preprocessed/plain/list10.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/preprocessed/plain/list10_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/preprocessed/plain/list20.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/preprocessed/plain/list20_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/preprocessed/plain/list30.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/preprocessed/plain/list30_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/preprocessed/plain/list40.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/preprocessed/plain/list40_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/preprocessed/plain/list50.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/list/aux_/preprocessed/plain/list50_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/map0.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/map10.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/map20.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/map30.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/map40.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/map50.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/begin_end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/clear_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/contains_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/empty_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/erase_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/erase_key_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/has_key_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/include_preprocessed.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/insert_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/item.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/key_type_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/map0.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/numbered.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/size_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/tag.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/value_type_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/no_ctps/map10.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/no_ctps/map20.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/no_ctps/map30.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/no_ctps/map40.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/no_ctps/map50.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/plain/map10.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/plain/map20.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/plain/map30.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/plain/map40.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/plain/map50.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/typeof_based/map10.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/typeof_based/map20.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/typeof_based/map30.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/typeof_based/map40.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/map/aux_/preprocessed/typeof_based/map50.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/set0.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/set0_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/set10.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/set10_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/set20.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/set20_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/set30.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/set30_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/set40.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/set40_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/set50.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/set50_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/at_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/begin_end_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/clear_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/empty_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/erase_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/erase_key_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/has_key_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/include_preprocessed.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/insert_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/item.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/key_type_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/numbered.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/numbered_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/set0.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/size_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/tag.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/value_type_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/preprocessed/plain/set10.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/preprocessed/plain/set10_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/preprocessed/plain/set20.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/preprocessed/plain/set20_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/preprocessed/plain/set30.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/preprocessed/plain/set30_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/preprocessed/plain/set40.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/preprocessed/plain/set40_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/preprocessed/plain/set50.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/set/aux_/preprocessed/plain/set50_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/vector0.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/vector0_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/vector10.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/vector10_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/vector20.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/vector20_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/vector30.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/vector30_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/vector40.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/vector40_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/vector50.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/vector50_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/O1_size.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/at.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/back.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/begin_end.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/clear.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/empty.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/front.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/include_preprocessed.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/item.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/numbered.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/numbered_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/pop_back.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/pop_front.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/push_back.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/push_front.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/size.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/tag.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/vector0.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/plain/vector10.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/plain/vector10_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/plain/vector20.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/plain/vector20_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/plain/vector30.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/plain/vector30_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/plain/vector40.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/plain/vector40_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/plain/vector50.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/plain/vector50_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40_c.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50.hpp external/boost-python-ublas-subset/boost_subset/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50_c.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/hashed_index.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/hashed_index_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/identity.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/identity_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/indexed_by.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/member.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/ordered_index_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/safe_mode_errors.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/sequenced_index.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/sequenced_index_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/tag.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/access_specifier.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/adl_swap.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/archive_constructed.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/auto_space.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/base_type.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/bidir_node_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/bucket_array.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/converter.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/copy_map.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/do_not_copy_elements_tag.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/has_tag.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/hash_index_args.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/hash_index_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/hash_index_node.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/header_holder.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/index_base.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/index_loader.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/index_matcher.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/index_node_base.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/index_saver.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/invariant_assert.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/is_index_list.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/iter_adaptor.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/modify_key_adaptor.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/msvc_index_specifier.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/no_duplicate_tags.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/node_type.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/ord_index_args.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/prevent_eti.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/safe_ctr_proxy.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/safe_mode.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/scope_guard.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/seq_index_node.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/seq_index_ops.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/serialization_version.hpp external/boost-python-ublas-subset/boost_subset/boost/multi_index/detail/vartempl_support.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/interval.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/odeint.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/bounds.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/cast.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/conversion_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/converter.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/converter_policies.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/int_float_mixture.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/int_float_mixture_enum.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/is_subranged.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/numeric_cast_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/sign_mixture.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/sign_mixture_enum.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/udt_builtin_mixture.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/udt_builtin_mixture_enum.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/detail/bounds.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/detail/conversion_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/detail/converter.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/detail/int_float_mixture.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/detail/is_subranged.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/detail/meta.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/detail/numeric_cast_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/detail/old_numeric_cast.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/detail/sign_mixture.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/detail/udt_builtin_mixture.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_long_long.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/assignment.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/banded.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/blas.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/doxydoc.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/exception.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/expression_types.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/functional.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/hermitian.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/io.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/lu.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/matrix.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/matrix_expression.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/matrix_proxy.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/matrix_sparse.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/operation.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/operation_blocked.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/operation_sparse.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/operations.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/storage.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/storage_sparse.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/symmetric.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/tags.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/traits.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/triangular.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/vector.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/vector_expression.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/vector_of_vector.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/vector_proxy.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/vector_sparse.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/detail/concepts.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/detail/config.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/detail/definitions.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/detail/documentation.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/detail/duff.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/detail/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/detail/matrix_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/detail/raw.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/detail/returntype_deduction.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/detail/temporary.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/detail/vector_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/experimental/sparse_view.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/operation/begin.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/operation/c_array.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/operation/end.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/operation/num_columns.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/operation/num_rows.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/operation/size.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/traits/c_array.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/traits/const_iterator_type.hpp external/boost-python-ublas-subset/boost_subset/boost/numeric/ublas/traits/iterator_type.hpp external/boost-python-ublas-subset/boost_subset/boost/optional/optional.hpp external/boost-python-ublas-subset/boost_subset/boost/optional/optional_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/binding.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/config.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/keyword.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/name.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/parameters.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/value_type.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/aux_/arg_list.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/aux_/default.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/aux_/is_maybe.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/aux_/overloads.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/aux_/parameter_requirements.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/aux_/result_of0.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/aux_/set.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/aux_/tag.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/aux_/tagged_argument.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/aux_/template_keyword.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/aux_/unwrap_cv_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/aux_/void.hpp external/boost-python-ublas-subset/boost_subset/boost/parameter/aux_/yesno.hpp external/boost-python-ublas-subset/boost_subset/boost/pending/container_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/pending/cstddef.hpp external/boost-python-ublas-subset/boost_subset/boost/pending/integer_log2.hpp external/boost-python-ublas-subset/boost_subset/boost/pending/lowest_bit.hpp external/boost-python-ublas-subset/boost_subset/boost/pending/property.hpp external/boost-python-ublas-subset/boost_subset/boost/pending/queue.hpp external/boost-python-ublas-subset/boost_subset/boost/pending/detail/property.hpp external/boost-python-ublas-subset/boost_subset/boost/predef/architecture.h external/boost-python-ublas-subset/boost_subset/boost/predef/make.h external/boost-python-ublas-subset/boost_subset/boost/predef/version_number.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/alpha.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/arm.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/blackfin.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/convex.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/ia64.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/m68k.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/mips.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/parisc.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/ppc.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/pyramid.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/rs6k.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/sparc.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/superh.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/sys370.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/sys390.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/x86.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/z.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/x86/32.h external/boost-python-ublas-subset/boost_subset/boost/predef/architecture/x86/64.h external/boost-python-ublas-subset/boost_subset/boost/predef/detail/_cassert.h external/boost-python-ublas-subset/boost_subset/boost/predef/detail/endian_compat.h external/boost-python-ublas-subset/boost_subset/boost/predef/detail/os_detected.h external/boost-python-ublas-subset/boost_subset/boost/predef/detail/test.h external/boost-python-ublas-subset/boost_subset/boost/predef/library/c/_prefix.h external/boost-python-ublas-subset/boost_subset/boost/predef/library/c/gnu.h external/boost-python-ublas-subset/boost_subset/boost/predef/os/bsd.h external/boost-python-ublas-subset/boost_subset/boost/predef/os/macos.h external/boost-python-ublas-subset/boost_subset/boost/predef/os/windows.h external/boost-python-ublas-subset/boost_subset/boost/predef/os/bsd/bsdi.h external/boost-python-ublas-subset/boost_subset/boost/predef/os/bsd/dragonfly.h external/boost-python-ublas-subset/boost_subset/boost/predef/os/bsd/free.h external/boost-python-ublas-subset/boost_subset/boost/predef/os/bsd/net.h external/boost-python-ublas-subset/boost_subset/boost/predef/os/bsd/open.h external/boost-python-ublas-subset/boost_subset/boost/predef/other/endian.h external/boost-python-ublas-subset/boost_subset/boost/preprocessor/arithmetic.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/cat.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/comma_if.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/comparison.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/control.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/debug.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/dec.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/empty.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/enum.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/enum_params.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/enum_params_with_a_default.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/enum_params_with_defaults.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/enum_shifted_params.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/expand.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/expr_if.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/facilities.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/identity.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/if.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/inc.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iterate.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/library.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/logical.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/punctuation.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repeat.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repeat_2nd.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repeat_from_to.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/selection.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/slot.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/stringize.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/variadic.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/arithmetic/add.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/arithmetic/dec.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/arithmetic/div.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/arithmetic/inc.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/arithmetic/mod.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/arithmetic/mul.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/arithmetic/sub.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/arithmetic/detail/div_base.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/data.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/elem.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/enum.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/insert.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/pop_back.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/pop_front.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/push_back.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/push_front.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/remove.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/replace.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/reverse.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/size.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/to_list.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/to_seq.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/array/to_tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/comparison/equal.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/comparison/greater.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/comparison/greater_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/comparison/less.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/comparison/less_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/comparison/not_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/config/config.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/config/limits.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/control/deduce_d.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/control/expr_if.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/control/expr_iif.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/control/if.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/control/iif.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/control/while.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/control/detail/while.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/control/detail/dmc/while.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/control/detail/edg/while.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/control/detail/msvc/while.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/debug/assert.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/debug/error.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/debug/line.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/detail/auto_rec.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/detail/check.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/detail/is_binary.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/detail/is_unary.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/detail/split.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/detail/dmc/auto_rec.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/facilities/apply.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/facilities/empty.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/facilities/expand.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/facilities/identity.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/facilities/intercept.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/facilities/overload.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/iterate.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/local.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/self.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/finish.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/local.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/rlocal.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/self.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/start.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/bounds/lower1.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/bounds/lower2.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/bounds/lower3.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/bounds/lower4.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/bounds/lower5.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/bounds/upper1.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/bounds/upper2.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/bounds/upper3.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/bounds/upper4.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/bounds/upper5.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/iter/forward1.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/iter/forward2.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/iter/forward3.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/iter/forward4.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/iter/forward5.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/iter/reverse1.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/iter/reverse2.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/iter/reverse3.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/iter/reverse4.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/iteration/detail/iter/reverse5.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/adt.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/append.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/at.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/cat.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/enum.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/filter.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/first_n.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/fold_left.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/fold_right.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/for_each.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/for_each_i.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/for_each_product.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/rest_n.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/reverse.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/size.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/to_array.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/to_seq.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/to_tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/transform.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/detail/fold_left.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/detail/fold_right.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/detail/dmc/fold_left.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/detail/edg/fold_left.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/list/detail/edg/fold_right.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/logical/and.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/logical/bitand.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/logical/bitnor.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/logical/bitor.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/logical/bitxor.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/logical/bool.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/logical/compl.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/logical/nor.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/logical/not.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/logical/or.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/logical/xor.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/punctuation/comma.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/punctuation/comma_if.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/punctuation/paren.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/punctuation/paren_if.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/deduce_r.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/deduce_z.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/enum.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/enum_binary_params.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/enum_params.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/enum_params_with_a_default.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/enum_params_with_defaults.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/enum_shifted.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/enum_shifted_binary_params.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/enum_shifted_params.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/enum_trailing.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/enum_trailing_binary_params.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/enum_trailing_params.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/for.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/repeat.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/repeat_from_to.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/detail/for.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/detail/dmc/for.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/detail/edg/for.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/repetition/detail/msvc/for.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/selection/max.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/selection/min.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/cat.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/elem.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/enum.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/filter.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/first_n.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/fold_left.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/fold_right.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/for_each.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/for_each_i.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/for_each_product.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/insert.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/pop_back.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/pop_front.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/push_back.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/push_front.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/remove.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/replace.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/rest_n.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/reverse.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/seq.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/size.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/subseq.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/to_array.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/to_list.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/to_tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/transform.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/detail/binary_transform.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/seq/detail/split.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/slot/counter.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/slot/slot.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/slot/detail/counter.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/slot/detail/def.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/slot/detail/shared.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/slot/detail/slot1.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/slot/detail/slot2.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/slot/detail/slot3.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/slot/detail/slot4.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/slot/detail/slot5.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/tuple/eat.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/tuple/elem.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/tuple/enum.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/tuple/rem.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/tuple/reverse.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/tuple/size.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/tuple/to_array.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/tuple/to_list.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/tuple/to_seq.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/variadic/elem.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/variadic/size.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/variadic/to_array.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/variadic/to_list.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/variadic/to_seq.hpp external/boost-python-ublas-subset/boost_subset/boost/preprocessor/variadic/to_tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/property_map/property_map.hpp external/boost-python-ublas-subset/boost_subset/boost/property_map/shared_array_property_map.hpp external/boost-python-ublas-subset/boost_subset/boost/property_map/vector_property_map.hpp external/boost-python-ublas-subset/boost_subset/boost/property_map/parallel/distributed_property_map.hpp external/boost-python-ublas-subset/boost_subset/boost/property_map/parallel/local_property_map.hpp external/boost-python-ublas-subset/boost_subset/boost/property_map/parallel/impl/distributed_property_map.ipp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/clone_allocator.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/exception.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/indirect_fun.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/nullable.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_array.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_circular_buffer.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_container.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_deque.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_inserter.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_list.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_map.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_map_adapter.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_sequence_adapter.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_set.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_set_adapter.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_unordered_map.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_unordered_set.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/ptr_vector.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/serialize_ptr_array.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/serialize_ptr_circular_buffer.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/serialize_ptr_container.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/serialize_ptr_deque.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/serialize_ptr_list.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/serialize_ptr_map.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/serialize_ptr_set.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/serialize_ptr_unordered_map.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/serialize_ptr_unordered_set.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/serialize_ptr_vector.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/associative_ptr_container.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/default_deleter.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/is_convertible.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/map_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/meta_functions.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/move.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/reversible_ptr_container.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/scoped_deleter.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/serialize_ptr_map_adapter.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/serialize_reversible_cont.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/serialize_xml_names.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/static_move_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/throw_exception.hpp external/boost-python-ublas-subset/boost_subset/boost/ptr_container/detail/void_ptr_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/python/arg_from_python.hpp external/boost-python-ublas-subset/boost_subset/boost/python/args.hpp external/boost-python-ublas-subset/boost_subset/boost/python/args_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/python/back_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/python/base_type_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/python/bases.hpp external/boost-python-ublas-subset/boost_subset/boost/python/borrowed.hpp external/boost-python-ublas-subset/boost_subset/boost/python/call.hpp external/boost-python-ublas-subset/boost_subset/boost/python/call_method.hpp external/boost-python-ublas-subset/boost_subset/boost/python/cast.hpp external/boost-python-ublas-subset/boost_subset/boost/python/class.hpp external/boost-python-ublas-subset/boost_subset/boost/python/class_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/python/copy_const_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/python/copy_non_const_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/python/data_members.hpp external/boost-python-ublas-subset/boost_subset/boost/python/def.hpp external/boost-python-ublas-subset/boost_subset/boost/python/def_visitor.hpp external/boost-python-ublas-subset/boost_subset/boost/python/default_call_policies.hpp external/boost-python-ublas-subset/boost_subset/boost/python/dict.hpp external/boost-python-ublas-subset/boost_subset/boost/python/docstring_options.hpp external/boost-python-ublas-subset/boost_subset/boost/python/enum.hpp external/boost-python-ublas-subset/boost_subset/boost/python/errors.hpp external/boost-python-ublas-subset/boost_subset/boost/python/exception_translator.hpp external/boost-python-ublas-subset/boost_subset/boost/python/exec.hpp external/boost-python-ublas-subset/boost_subset/boost/python/extract.hpp external/boost-python-ublas-subset/boost_subset/boost/python/handle.hpp external/boost-python-ublas-subset/boost_subset/boost/python/handle_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/python/has_back_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/python/implicit.hpp external/boost-python-ublas-subset/boost_subset/boost/python/import.hpp external/boost-python-ublas-subset/boost_subset/boost/python/init.hpp external/boost-python-ublas-subset/boost_subset/boost/python/instance_holder.hpp external/boost-python-ublas-subset/boost_subset/boost/python/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/python/list.hpp external/boost-python-ublas-subset/boost_subset/boost/python/long.hpp external/boost-python-ublas-subset/boost_subset/boost/python/lvalue_from_pytype.hpp external/boost-python-ublas-subset/boost_subset/boost/python/make_constructor.hpp external/boost-python-ublas-subset/boost_subset/boost/python/make_function.hpp external/boost-python-ublas-subset/boost_subset/boost/python/manage_new_object.hpp external/boost-python-ublas-subset/boost_subset/boost/python/module.hpp external/boost-python-ublas-subset/boost_subset/boost/python/module_init.hpp external/boost-python-ublas-subset/boost_subset/boost/python/numeric.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object_attributes.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object_call.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object_core.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object_items.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object_operators.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object_protocol.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object_protocol_core.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object_slices.hpp external/boost-python-ublas-subset/boost_subset/boost/python/opaque_pointer_converter.hpp external/boost-python-ublas-subset/boost_subset/boost/python/operators.hpp external/boost-python-ublas-subset/boost_subset/boost/python/other.hpp external/boost-python-ublas-subset/boost_subset/boost/python/overloads.hpp external/boost-python-ublas-subset/boost_subset/boost/python/override.hpp external/boost-python-ublas-subset/boost_subset/boost/python/pointee.hpp external/boost-python-ublas-subset/boost_subset/boost/python/proxy.hpp external/boost-python-ublas-subset/boost_subset/boost/python/ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/python/pure_virtual.hpp external/boost-python-ublas-subset/boost_subset/boost/python/raw_function.hpp external/boost-python-ublas-subset/boost_subset/boost/python/refcount.hpp external/boost-python-ublas-subset/boost_subset/boost/python/reference_existing_object.hpp external/boost-python-ublas-subset/boost_subset/boost/python/register_ptr_to_python.hpp external/boost-python-ublas-subset/boost_subset/boost/python/return_arg.hpp external/boost-python-ublas-subset/boost_subset/boost/python/return_by_value.hpp external/boost-python-ublas-subset/boost_subset/boost/python/return_internal_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/python/return_opaque_pointer.hpp external/boost-python-ublas-subset/boost_subset/boost/python/return_value_policy.hpp external/boost-python-ublas-subset/boost_subset/boost/python/scope.hpp external/boost-python-ublas-subset/boost_subset/boost/python/self.hpp external/boost-python-ublas-subset/boost_subset/boost/python/signature.hpp external/boost-python-ublas-subset/boost_subset/boost/python/slice.hpp external/boost-python-ublas-subset/boost_subset/boost/python/slice_nil.hpp external/boost-python-ublas-subset/boost_subset/boost/python/ssize_t.hpp external/boost-python-ublas-subset/boost_subset/boost/python/stl_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/python/str.hpp external/boost-python-ublas-subset/boost_subset/boost/python/tag.hpp external/boost-python-ublas-subset/boost_subset/boost/python/to_python_converter.hpp external/boost-python-ublas-subset/boost_subset/boost/python/to_python_indirect.hpp external/boost-python-ublas-subset/boost_subset/boost/python/to_python_value.hpp external/boost-python-ublas-subset/boost_subset/boost/python/tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/python/type_id.hpp external/boost-python-ublas-subset/boost_subset/boost/python/with_custodian_and_ward.hpp external/boost-python-ublas-subset/boost_subset/boost/python/wrapper.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/arg_from_python.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/arg_to_python.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/arg_to_python_base.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/as_to_python_function.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/builtin_converters.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/constructor_function.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/context_result_converter.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/convertible_function.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/from_python.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/implicit.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/obj_mgr_arg_from_python.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/object_manager.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/pointer_type_id.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/pyobject_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/pyobject_type.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/pytype_function.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/pytype_object_mgr_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/registered.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/registered_pointee.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/registrations.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/registry.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/return_from_python.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/rvalue_from_python_data.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/shared_ptr_deleter.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/shared_ptr_from_python.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/shared_ptr_to_python.hpp external/boost-python-ublas-subset/boost_subset/boost/python/converter/to_python_function_type.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/aix_init_module.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/api_placeholder.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/borrowed_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/caller.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/config.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/construct.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/convertible.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/copy_ctor_mutates_rhs.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/cv_category.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/dealloc.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/decorated_type_id.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/decref_guard.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/def_helper.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/def_helper_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/defaults_def.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/defaults_gen.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/dependent.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/destroy.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/enable_if.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/exception_handler.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/force_instantiate.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/if_else.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/indirect_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/invoke.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/is_auto_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/is_shared_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/is_wrapper.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/is_xxx.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/make_keyword_range_fn.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/make_tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/map_entry.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/mpl_lambda.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/msvc_typeinfo.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/none.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/not_specified.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/nullary_function_adaptor.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/operator_id.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/overloads_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/pointee.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/prefix.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/preprocessor.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/python22_fixed.h external/boost-python-ublas-subset/boost_subset/boost/python/detail/python_type.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/raw_pyobject.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/referent_storage.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/result.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/scope.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/sfinae.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/signature.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/string_literal.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/target.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/translate_exception.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/type_list.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/type_list_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/type_list_impl_no_pts.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/unwind_type.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/unwrap_type_id.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/unwrap_wrapper.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/value_arg.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/value_is_shared_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/value_is_xxx.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/void_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/void_return.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/wrap_python.hpp external/boost-python-ublas-subset/boost_subset/boost/python/detail/wrapper_base.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/add_to_namespace.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/class.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/class_detail.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/class_metadata.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/class_wrapper.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/enum_base.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/find_instance.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/forward.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/function.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/function_doc_signature.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/function_handle.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/function_object.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/inheritance.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/inheritance_query.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/instance.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/iterator_core.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/life_support.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/make_holder.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/make_instance.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/make_ptr_instance.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/pickle_support.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/pointer_holder.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/py_function.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/stl_iterator_core.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/value_holder.hpp external/boost-python-ublas-subset/boost_subset/boost/python/object/value_holder_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/python/suite/indexing/container_utils.hpp external/boost-python-ublas-subset/boost_subset/boost/python/suite/indexing/indexing_suite.hpp external/boost-python-ublas-subset/boost_subset/boost/python/suite/indexing/map_indexing_suite.hpp external/boost-python-ublas-subset/boost_subset/boost/python/suite/indexing/vector_indexing_suite.hpp external/boost-python-ublas-subset/boost_subset/boost/python/suite/indexing/detail/indexing_suite_detail.hpp external/boost-python-ublas-subset/boost_subset/boost/random/additive_combine.hpp external/boost-python-ublas-subset/boost_subset/boost/random/bernoulli_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/binomial_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/cauchy_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/chi_squared_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/discard_block.hpp external/boost-python-ublas-subset/boost_subset/boost/random/discrete_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/exponential_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/extreme_value_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/fisher_f_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/gamma_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/generate_canonical.hpp external/boost-python-ublas-subset/boost_subset/boost/random/geometric_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/independent_bits.hpp external/boost-python-ublas-subset/boost_subset/boost/random/inversive_congruential.hpp external/boost-python-ublas-subset/boost_subset/boost/random/lagged_fibonacci.hpp external/boost-python-ublas-subset/boost_subset/boost/random/linear_congruential.hpp external/boost-python-ublas-subset/boost_subset/boost/random/linear_feedback_shift.hpp external/boost-python-ublas-subset/boost_subset/boost/random/lognormal_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/mersenne_twister.hpp external/boost-python-ublas-subset/boost_subset/boost/random/negative_binomial_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/normal_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/piecewise_constant_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/piecewise_linear_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/poisson_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/random_number_generator.hpp external/boost-python-ublas-subset/boost_subset/boost/random/ranlux.hpp external/boost-python-ublas-subset/boost_subset/boost/random/seed_seq.hpp external/boost-python-ublas-subset/boost_subset/boost/random/shuffle_order.hpp external/boost-python-ublas-subset/boost_subset/boost/random/shuffle_output.hpp external/boost-python-ublas-subset/boost_subset/boost/random/student_t_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/subtract_with_carry.hpp external/boost-python-ublas-subset/boost_subset/boost/random/taus88.hpp external/boost-python-ublas-subset/boost_subset/boost/random/triangle_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/uniform_01.hpp external/boost-python-ublas-subset/boost_subset/boost/random/uniform_int.hpp external/boost-python-ublas-subset/boost_subset/boost/random/uniform_int_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/uniform_on_sphere.hpp external/boost-python-ublas-subset/boost_subset/boost/random/uniform_real.hpp external/boost-python-ublas-subset/boost_subset/boost/random/uniform_real_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/uniform_smallint.hpp external/boost-python-ublas-subset/boost_subset/boost/random/variate_generator.hpp external/boost-python-ublas-subset/boost_subset/boost/random/weibull_distribution.hpp external/boost-python-ublas-subset/boost_subset/boost/random/xor_combine.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/config.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/const_mod.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/disable_warnings.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/enable_warnings.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/generator_bits.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/generator_seed_seq.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/integer_log2.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/large_arithmetic.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/operators.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/ptr_helper.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/seed.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/seed_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/signed_unsigned_tools.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/uniform_int_float.hpp external/boost-python-ublas-subset/boost_subset/boost/random/detail/vector_io.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm.hpp external/boost-python-ublas-subset/boost_subset/boost/range/as_literal.hpp external/boost-python-ublas-subset/boost_subset/boost/range/begin.hpp external/boost-python-ublas-subset/boost_subset/boost/range/category.hpp external/boost-python-ublas-subset/boost_subset/boost/range/concepts.hpp external/boost-python-ublas-subset/boost_subset/boost/range/config.hpp external/boost-python-ublas-subset/boost_subset/boost/range/const_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/range/const_reverse_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/range/difference_type.hpp external/boost-python-ublas-subset/boost_subset/boost/range/distance.hpp external/boost-python-ublas-subset/boost_subset/boost/range/empty.hpp external/boost-python-ublas-subset/boost_subset/boost/range/end.hpp external/boost-python-ublas-subset/boost_subset/boost/range/functions.hpp external/boost-python-ublas-subset/boost_subset/boost/range/has_range_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/range/irange.hpp external/boost-python-ublas-subset/boost_subset/boost/range/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/range/iterator_range.hpp external/boost-python-ublas-subset/boost_subset/boost/range/iterator_range_core.hpp external/boost-python-ublas-subset/boost_subset/boost/range/iterator_range_io.hpp external/boost-python-ublas-subset/boost_subset/boost/range/metafunctions.hpp external/boost-python-ublas-subset/boost_subset/boost/range/mutable_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/range/numeric.hpp external/boost-python-ublas-subset/boost_subset/boost/range/pointer.hpp external/boost-python-ublas-subset/boost_subset/boost/range/rbegin.hpp external/boost-python-ublas-subset/boost_subset/boost/range/reference.hpp external/boost-python-ublas-subset/boost_subset/boost/range/rend.hpp external/boost-python-ublas-subset/boost_subset/boost/range/result_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/range/reverse_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/range/reverse_result_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/range/size.hpp external/boost-python-ublas-subset/boost_subset/boost/range/size_type.hpp external/boost-python-ublas-subset/boost_subset/boost/range/sub_range.hpp external/boost-python-ublas-subset/boost_subset/boost/range/value_type.hpp external/boost-python-ublas-subset/boost_subset/boost/range/adaptor/argument_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/range/adaptor/filtered.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/adjacent_find.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/binary_search.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/copy.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/copy_backward.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/count.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/count_if.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/equal.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/equal_range.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/fill.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/fill_n.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/find.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/find_end.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/find_first_of.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/find_if.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/for_each.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/generate.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/heap_algorithm.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/inplace_merge.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/lexicographical_compare.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/lower_bound.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/max_element.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/merge.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/min_element.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/mismatch.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/nth_element.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/partial_sort.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/partial_sort_copy.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/partition.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/permutation.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/random_shuffle.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/remove.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/remove_copy.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/remove_copy_if.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/remove_if.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/replace.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/replace_copy.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/replace_copy_if.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/replace_if.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/reverse.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/reverse_copy.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/rotate.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/rotate_copy.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/search.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/search_n.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/set_algorithm.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/sort.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/stable_partition.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/stable_sort.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/transform.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/unique.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/unique_copy.hpp external/boost-python-ublas-subset/boost_subset/boost/range/algorithm/upper_bound.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/as_literal.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/begin.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/collection_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/collection_traits_detail.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/common.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/const_iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/detail_str.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/end.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/extract_optional_type.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/implementation_help.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/iterator.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/misc_concept.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/range_return.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/remove_extent.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/safe_bool.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/sfinae.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/size_type.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/str_types.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/value_type.hpp external/boost-python-ublas-subset/boost_subset/boost/range/detail/vc6/end.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/config.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/include.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/ratio.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/ratio_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/ratio_io.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/ratio_static_string.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/detail/overflow_helpers.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/detail/ratio_io.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/detail/mpl/abs.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/detail/mpl/gcd.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/detail/mpl/lcm.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/detail/mpl/sign.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/abs.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/arithmetic.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/comparison.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/divides.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/gcd.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/greater.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/greater_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/lcm.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/less.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/less_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/minus.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/negate.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/not_equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/numeric_cast.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/plus.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/rational_c_tag.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/rational_constant.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/sign.hpp external/boost-python-ublas-subset/boost_subset/boost/ratio/mpl/times.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/access.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/array.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/assume_abstract.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/base_object.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/collection_size_type.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/collection_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/collections_load_imp.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/collections_save_imp.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/config.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/export.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/extended_type_info.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/extended_type_info_no_rtti.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/extended_type_info_typeid.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/factory.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/force_include.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/is_bitwise_serializable.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/item_version_type.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/level.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/level_enum.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/map.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/nvp.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/pfto.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/serialization.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/shared_ptr_132.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/singleton.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/smart_cast.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/split_free.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/split_member.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/state_saver.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/static_warning.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/string.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/strong_typedef.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/throw_exception.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/tracking.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/tracking_enum.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/traits.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/type_info_implementation.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/utility.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/vector.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/version.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/void_cast.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/void_cast_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/wrapper.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/detail/get_data.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/detail/shared_count_132.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/detail/shared_ptr_132.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/detail/shared_ptr_nmt_132.hpp external/boost-python-ublas-subset/boost_subset/boost/serialization/detail/stack_constructor.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/allocate_shared_array.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/bad_weak_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/enable_shared_from_this.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/intrusive_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/make_shared.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/make_shared_array.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/make_shared_object.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/scoped_array.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/scoped_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/shared_array.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/shared_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/weak_ptr.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/allocate_array_helper.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/array_deleter.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/array_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/array_utility.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/atomic_count.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/atomic_count_gcc.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/atomic_count_pthreads.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/atomic_count_sync.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/atomic_count_win32.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/lightweight_mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/lwm_nop.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/lwm_pthreads.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/lwm_win32_cs.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/make_array_helper.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/operator_bool.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/quick_allocator.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/shared_array_nmt.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/shared_count.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/shared_ptr_nmt.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_convertible.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_aix.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_nt.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_pt.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_spin.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_sync.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_vacpp_ppc.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_base_w32.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_counted_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_forward.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_has_sync.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_if_array.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/sp_nullptr_t.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/spinlock.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/spinlock_gcc_arm.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/spinlock_nt.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/spinlock_pool.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/spinlock_pt.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/spinlock_sync.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/spinlock_w32.hpp external/boost-python-ublas-subset/boost_subset/boost/smart_ptr/detail/yield_k.hpp external/boost-python-ublas-subset/boost_subset/boost/system/api_config.hpp external/boost-python-ublas-subset/boost_subset/boost/system/config.hpp external/boost-python-ublas-subset/boost_subset/boost/system/error_code.hpp external/boost-python-ublas-subset/boost_subset/boost/system/system_error.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/barrier.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/completion_latch.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/condition.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/condition_variable.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/cv_status.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/exceptions.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/externally_locked.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/externally_locked_stream.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/future.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/future_error_code.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/is_locked_by_this_thread.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/latch.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/lock_algorithms.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/lock_concepts.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/lock_factories.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/lock_guard.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/lock_options.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/lock_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/lock_types.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/lockable_adapter.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/lockable_concepts.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/lockable_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/locks.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/null_mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/once.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/poly_lockable.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/poly_lockable_adapter.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/poly_shared_lockable.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/poly_shared_lockable_adapter.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/recursive_mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/reverse_lock.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/scoped_thread.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/shared_lock_guard.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/shared_mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/strict_lock.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/sync_bounded_queue.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/sync_queue.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/synchronized_value.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/testable_mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/thread.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/thread_functors.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/thread_guard.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/thread_only.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/thread_time.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/tss.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/xtime.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/async_func.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/config.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/counter.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/delete.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/force_cast.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/invoke.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/is_convertible.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/lockable_wrapper.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/log.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/make_tuple_indices.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/memory.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/move.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/platform.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/singleton.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/thread.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/thread_group.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/thread_heap_alloc.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/thread_interruption.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/detail/tss_hooks.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/pthread/condition_variable.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/pthread/condition_variable_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/pthread/mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/pthread/once.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/pthread/once_atomic.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/pthread/pthread_mutex_scoped_lock.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/pthread/recursive_mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/pthread/shared_mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/pthread/shared_mutex_assert.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/pthread/thread_data.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/pthread/thread_heap_alloc.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/pthread/timespec.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/v2/shared_mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/v2/thread.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/win32/basic_recursive_mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/win32/basic_timed_mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/win32/condition_variable.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/win32/interlocked_read.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/win32/mfc_thread_init.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/win32/mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/win32/once.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/win32/recursive_mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/win32/shared_mutex.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/win32/thread_data.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/win32/thread_heap_alloc.hpp external/boost-python-ublas-subset/boost_subset/boost/thread/win32/thread_primitives.hpp external/boost-python-ublas-subset/boost_subset/boost/tr1/tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/tr1/detail/config.hpp external/boost-python-ublas-subset/boost_subset/boost/tr1/detail/config_all.hpp external/boost-python-ublas-subset/boost_subset/boost/tuple/tuple.hpp external/boost-python-ublas-subset/boost_subset/boost/tuple/tuple_comparison.hpp external/boost-python-ublas-subset/boost_subset/boost/tuple/detail/tuple_basic.hpp external/boost-python-ublas-subset/boost_subset/boost/tuple/detail/tuple_basic_no_partial_spec.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/add_const.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/add_cv.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/add_lvalue_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/add_pointer.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/add_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/add_rvalue_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/add_volatile.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/aligned_storage.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/alignment_of.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/alignment_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/arithmetic_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/array_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/broken_compiler_spec.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/common_type.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/composite_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/conditional.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/config.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/conversion_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/cv_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/decay.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/extent.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/floating_point_promotion.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/function_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_bit_and.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_bit_and_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_bit_or.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_bit_or_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_bit_xor.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_bit_xor_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_complement.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_dereference.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_divides.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_divides_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_greater.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_greater_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_left_shift.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_left_shift_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_less.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_less_equal.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_logical_and.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_logical_not.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_logical_or.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_minus.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_minus_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_modulus.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_modulus_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_multiplies.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_multiplies_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_negate.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_new_operator.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_not_equal_to.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_nothrow_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_nothrow_constructor.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_nothrow_copy.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_nothrow_destructor.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_operator.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_plus.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_plus_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_post_decrement.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_post_increment.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_pre_decrement.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_pre_increment.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_right_shift.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_right_shift_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_trivial_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_trivial_constructor.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_trivial_copy.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_trivial_destructor.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_trivial_move_assign.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_trivial_move_constructor.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_unary_minus.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_unary_plus.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/has_virtual_destructor.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/ice.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/integral_constant.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/integral_promotion.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/intrinsics.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_abstract.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_arithmetic.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_array.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_base_and_derived.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_base_of.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_class.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_complex.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_compound.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_const.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_convertible.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_copy_constructible.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_empty.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_enum.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_float.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_floating_point.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_function.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_fundamental.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_integral.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_lvalue_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_member_function_pointer.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_member_object_pointer.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_member_pointer.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_nothrow_move_assignable.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_nothrow_move_constructible.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_object.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_pod.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_pointer.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_polymorphic.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_rvalue_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_same.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_scalar.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_signed.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_stateless.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_union.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_unsigned.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_virtual_base_of.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_void.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/is_volatile.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/make_signed.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/make_unsigned.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/object_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/promote.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/rank.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/remove_all_extents.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/remove_bounds.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/remove_const.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/remove_cv.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/remove_extent.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/remove_pointer.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/remove_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/remove_volatile.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/same_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/transform_traits.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/type_with_alignment.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/bool_trait_def.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/bool_trait_undef.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/common_type_imp.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/cv_traits_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/false_result.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/has_binary_operator.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/has_postfix_operator.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/has_prefix_operator.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/ice_and.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/ice_eq.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/ice_not.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/ice_or.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/is_function_ptr_helper.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/is_function_ptr_tester.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/size_t_trait_def.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/size_t_trait_undef.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/template_arity_spec.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/type_trait_def.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/type_trait_undef.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/wrap.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/detail/yes_no_type.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/msvc/remove_all_extents.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/msvc/remove_bounds.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/msvc/remove_const.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/msvc/remove_cv.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/msvc/remove_extent.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/msvc/remove_pointer.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/msvc/remove_reference.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/msvc/remove_volatile.hpp external/boost-python-ublas-subset/boost_subset/boost/type_traits/msvc/typeof.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/encode_decode.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/encode_decode_params.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/incr_registration_group.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/int_encoding.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/integral_template_param.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/message.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/modifiers.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/native.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/pointers_data_members.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/register_functions.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/register_functions_iterate.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/register_fundamental.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/register_mem_functions.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/template_encoding.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/template_template_param.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/type_encoding.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/type_template_param.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/typeof.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/typeof_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/unsupported.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/vector.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/vector50.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/dmc/typeof_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/msvc/typeof_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/std/complex.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/std/memory.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/std/valarray.hpp external/boost-python-ublas-subset/boost_subset/boost/typeof/std/vector.hpp external/boost-python-ublas-subset/boost_subset/boost/units/base_dimension.hpp external/boost-python-ublas-subset/boost_subset/boost/units/base_unit.hpp external/boost-python-ublas-subset/boost_subset/boost/units/config.hpp external/boost-python-ublas-subset/boost_subset/boost/units/conversion.hpp external/boost-python-ublas-subset/boost_subset/boost/units/derived_dimension.hpp external/boost-python-ublas-subset/boost_subset/boost/units/dim.hpp external/boost-python-ublas-subset/boost_subset/boost/units/dimension.hpp external/boost-python-ublas-subset/boost_subset/boost/units/dimensionless_type.hpp external/boost-python-ublas-subset/boost_subset/boost/units/get_dimension.hpp external/boost-python-ublas-subset/boost_subset/boost/units/get_system.hpp external/boost-python-ublas-subset/boost_subset/boost/units/heterogeneous_system.hpp external/boost-python-ublas-subset/boost_subset/boost/units/homogeneous_system.hpp external/boost-python-ublas-subset/boost_subset/boost/units/io.hpp external/boost-python-ublas-subset/boost_subset/boost/units/is_dimension_list.hpp external/boost-python-ublas-subset/boost_subset/boost/units/make_scaled_unit.hpp external/boost-python-ublas-subset/boost_subset/boost/units/make_system.hpp external/boost-python-ublas-subset/boost_subset/boost/units/operators.hpp external/boost-python-ublas-subset/boost_subset/boost/units/quantity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/reduce_unit.hpp external/boost-python-ublas-subset/boost_subset/boost/units/scale.hpp external/boost-python-ublas-subset/boost_subset/boost/units/scaled_base_unit.hpp external/boost-python-ublas-subset/boost_subset/boost/units/static_constant.hpp external/boost-python-ublas-subset/boost_subset/boost/units/static_rational.hpp external/boost-python-ublas-subset/boost_subset/boost/units/unit.hpp external/boost-python-ublas-subset/boost_subset/boost/units/units_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/units/base_units/angle/radian.hpp external/boost-python-ublas-subset/boost_subset/boost/units/base_units/angle/steradian.hpp external/boost-python-ublas-subset/boost_subset/boost/units/base_units/cgs/gram.hpp external/boost-python-ublas-subset/boost_subset/boost/units/base_units/si/ampere.hpp external/boost-python-ublas-subset/boost_subset/boost/units/base_units/si/candela.hpp external/boost-python-ublas-subset/boost_subset/boost/units/base_units/si/kelvin.hpp external/boost-python-ublas-subset/boost_subset/boost/units/base_units/si/kilogram.hpp external/boost-python-ublas-subset/boost_subset/boost/units/base_units/si/meter.hpp external/boost-python-ublas-subset/boost_subset/boost/units/base_units/si/mole.hpp external/boost-python-ublas-subset/boost_subset/boost/units/base_units/si/second.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/conversion_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/dim_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/dimension_impl.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/dimension_list.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/dimensionless_unit.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/heterogeneous_conversion.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/linear_algebra.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/one.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/ordinal.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/prevent_redefinition.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/push_front_if.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/push_front_or_add.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/sort.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/static_rational_power.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/unscale.hpp external/boost-python-ublas-subset/boost_subset/boost/units/detail/utility.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/absorbed_dose.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/acceleration.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/action.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/activity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/amount.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/angular_acceleration.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/angular_momentum.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/angular_velocity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/area.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/capacitance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/conductance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/conductivity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/current.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/dose_equivalent.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/dynamic_viscosity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/electric_charge.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/electric_potential.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/energy.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/force.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/frequency.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/illuminance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/impedance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/inductance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/kinematic_viscosity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/length.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/luminous_flux.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/luminous_intensity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/magnetic_field_intensity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/magnetic_flux.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/magnetic_flux_density.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/mass.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/mass_density.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/moment_of_inertia.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/momentum.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/permeability.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/permittivity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/plane_angle.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/power.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/pressure.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/reluctance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/resistance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/resistivity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/solid_angle.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/surface_density.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/surface_tension.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/temperature.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/time.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/torque.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/velocity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/volume.hpp external/boost-python-ublas-subset/boost_subset/boost/units/physical_dimensions/wavenumber.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/absorbed_dose.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/acceleration.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/action.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/activity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/amount.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/angular_acceleration.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/angular_momentum.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/angular_velocity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/area.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/base.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/capacitance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/catalytic_activity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/conductance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/conductivity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/current.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/dimensionless.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/dose_equivalent.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/dynamic_viscosity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/electric_charge.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/electric_potential.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/energy.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/force.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/frequency.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/illuminance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/impedance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/inductance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/io.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/kinematic_viscosity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/length.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/luminous_flux.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/luminous_intensity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/magnetic_field_intensity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/magnetic_flux.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/magnetic_flux_density.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/mass.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/mass_density.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/moment_of_inertia.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/momentum.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/permeability.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/permittivity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/plane_angle.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/power.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/pressure.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/reluctance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/resistance.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/resistivity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/solid_angle.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/surface_density.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/surface_tension.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/temperature.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/time.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/torque.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/velocity.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/volume.hpp external/boost-python-ublas-subset/boost_subset/boost/units/systems/si/wavenumber.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered/unordered_map.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered/unordered_map_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered/unordered_set.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered/unordered_set_fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered/detail/allocate.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered/detail/buckets.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered/detail/equivalent.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered/detail/extract_key.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered/detail/fwd.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered/detail/table.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered/detail/unique.hpp external/boost-python-ublas-subset/boost_subset/boost/unordered/detail/util.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/addressof.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/base_from_member.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/binary.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/compare_pointees.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/declval.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/enable_if.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/identity_type.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/in_place_factory.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/result_of.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/swap.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/value_init.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/detail/in_place_factory_prefix.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/detail/in_place_factory_suffix.hpp external/boost-python-ublas-subset/boost_subset/boost/utility/detail/result_of_iterate.hpp external/boost-python-ublas-subset/boost_subset/libs/python/index.html external/boost-python-ublas-subset/boost_subset/libs/python/release_notes.txt external/boost-python-ublas-subset/boost_subset/libs/python/todo.html external/boost-python-ublas-subset/boost_subset/libs/python/todo.txt external/boost-python-ublas-subset/boost_subset/libs/python/src/dict.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/errors.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/exec.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/import.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/list.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/long.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/module.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/numeric.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/object_operators.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/object_protocol.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/slice.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/str.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/tuple.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/wrapper.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/converter/arg_to_python_base.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/converter/builtin_converters.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/converter/from_python.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/converter/registry.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/converter/type_id.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/object/class.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/object/enum.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/object/function.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/object/function_doc_signature.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/object/inheritance.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/object/iterator.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/object/life_support.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/object/pickle_support.cpp external/boost-python-ublas-subset/boost_subset/libs/python/src/object/stl_iterator.cpp external/boost-python-ublas-subset/boost_subset/libs/smart_ptr/src/sp_collector.cpp external/boost-python-ublas-subset/boost_subset/libs/smart_ptr/src/sp_debug_hooks.cpp external/boost-python-ublas-subset/boost_subset/libs/system/src/error_code.cpp external/boost-python-ublas-subset/boost_subset/libs/system/src/local_free_on_destruction.hpp external/boost-python-ublas-subset/boost_subset/libs/thread/index.html external/boost-python-ublas-subset/boost_subset/libs/thread/src/future.cpp external/boost-python-ublas-subset/boost_subset/libs/thread/src/tss_null.cpp external/boost-python-ublas-subset/boost_subset/libs/thread/src/pthread/once.cpp external/boost-python-ublas-subset/boost_subset/libs/thread/src/pthread/once_atomic.cpp external/boost-python-ublas-subset/boost_subset/libs/thread/src/pthread/thread.cpp external/boost-python-ublas-subset/boost_subset/libs/thread/src/pthread/timeconv.inl external/boost-python-ublas-subset/boost_subset/libs/thread/src/win32/thread.cpp external/boost-python-ublas-subset/boost_subset/libs/thread/src/win32/timeconv.inl external/boost-python-ublas-subset/boost_subset/libs/thread/src/win32/tss_dll.cpp external/boost-python-ublas-subset/boost_subset/libs/thread/src/win32/tss_pe.cpp external/boost_numpy/boost/numpy.hpp external/boost_numpy/boost/numpy/dtype.hpp external/boost_numpy/boost/numpy/internal.hpp external/boost_numpy/boost/numpy/invoke_matching.hpp external/boost_numpy/boost/numpy/matrix.hpp external/boost_numpy/boost/numpy/ndarray.hpp external/boost_numpy/boost/numpy/numpy_object_mgr_traits.hpp external/boost_numpy/boost/numpy/scalars.hpp external/boost_numpy/boost/numpy/ufunc.hpp external/boost_numpy/libs/numpy/cmake/README.txt external/boost_numpy/libs/numpy/doc/CMakeLists.txt external/boost_numpy/libs/numpy/doc/_templates/layout.html external/boost_numpy/libs/numpy/example/CMakeLists.txt external/boost_numpy/libs/numpy/example/dtype.cpp external/boost_numpy/libs/numpy/example/fromdata.cpp external/boost_numpy/libs/numpy/example/gaussian.cpp external/boost_numpy/libs/numpy/example/ndarray.cpp external/boost_numpy/libs/numpy/example/simple.cpp external/boost_numpy/libs/numpy/example/ufunc.cpp external/boost_numpy/libs/numpy/example/wrap.cpp external/boost_numpy/libs/numpy/src/CMakeLists.txt external/boost_numpy/libs/numpy/src/dtype.cpp external/boost_numpy/libs/numpy/src/matrix.cpp external/boost_numpy/libs/numpy/src/ndarray.cpp external/boost_numpy/libs/numpy/src/numpy.cpp external/boost_numpy/libs/numpy/src/scalars.cpp external/boost_numpy/libs/numpy/src/ufunc.cpp external/boost_numpy/libs/numpy/test/CMakeLists.txt external/boost_numpy/libs/numpy/test/dtype_mod.cpp external/boost_numpy/libs/numpy/test/indexing_mod.cpp external/boost_numpy/libs/numpy/test/ndarray_mod.cpp external/boost_numpy/libs/numpy/test/shapes_mod.cpp external/boost_numpy/libs/numpy/test/templates_mod.cpp external/boost_numpy/libs/numpy/test/ufunc_mod.cpp external/viennacl-dev/CL/cl.h external/viennacl-dev/CL/cl.hpp external/viennacl-dev/CL/cl_d3d10.h external/viennacl-dev/CL/cl_ext.h external/viennacl-dev/CL/cl_gl.h external/viennacl-dev/CL/cl_gl_ext.h external/viennacl-dev/CL/cl_platform.h external/viennacl-dev/CL/opencl.h external/viennacl-dev/viennacl/circulant_matrix.hpp external/viennacl-dev/viennacl/compressed_compressed_matrix.hpp external/viennacl-dev/viennacl/compressed_matrix.hpp external/viennacl-dev/viennacl/context.hpp external/viennacl-dev/viennacl/coordinate_matrix.hpp external/viennacl-dev/viennacl/ell_matrix.hpp external/viennacl-dev/viennacl/fft.hpp external/viennacl-dev/viennacl/forwards.h external/viennacl-dev/viennacl/hankel_matrix.hpp external/viennacl-dev/viennacl/hyb_matrix.hpp external/viennacl-dev/viennacl/matrix.hpp external/viennacl-dev/viennacl/matrix_proxy.hpp external/viennacl-dev/viennacl/range.hpp external/viennacl-dev/viennacl/scalar.hpp external/viennacl-dev/viennacl/slice.hpp external/viennacl-dev/viennacl/toeplitz_matrix.hpp external/viennacl-dev/viennacl/vandermonde_matrix.hpp external/viennacl-dev/viennacl/vector.hpp external/viennacl-dev/viennacl/vector_proxy.hpp external/viennacl-dev/viennacl/backend/cpu_ram.hpp external/viennacl-dev/viennacl/backend/cuda.hpp external/viennacl-dev/viennacl/backend/mem_handle.hpp external/viennacl-dev/viennacl/backend/memory.hpp external/viennacl-dev/viennacl/backend/opencl.hpp external/viennacl-dev/viennacl/backend/util.hpp external/viennacl-dev/viennacl/generator/autotune.hpp external/viennacl-dev/viennacl/generator/forwards.h external/viennacl-dev/viennacl/generator/generate.hpp external/viennacl-dev/viennacl/generator/helpers.hpp external/viennacl-dev/viennacl/generator/map_functor.hpp external/viennacl-dev/viennacl/generator/mapped_objects.hpp external/viennacl-dev/viennacl/generator/matrix_product.hpp external/viennacl-dev/viennacl/generator/profile_base.hpp external/viennacl-dev/viennacl/generator/profiles.hpp external/viennacl-dev/viennacl/generator/saxpy.hpp external/viennacl-dev/viennacl/generator/scalar_reduction.hpp external/viennacl-dev/viennacl/generator/set_arguments_functor.hpp external/viennacl-dev/viennacl/generator/statement_representation_functor.hpp external/viennacl-dev/viennacl/generator/utils.hpp external/viennacl-dev/viennacl/generator/vector_reduction.hpp external/viennacl-dev/viennacl/io/matrix_market.hpp external/viennacl-dev/viennacl/linalg/amg.hpp external/viennacl-dev/viennacl/linalg/bicgstab.hpp external/viennacl-dev/viennacl/linalg/bisect.hpp external/viennacl-dev/viennacl/linalg/cg.hpp external/viennacl-dev/viennacl/linalg/circulant_matrix_operations.hpp external/viennacl-dev/viennacl/linalg/direct_solve.hpp external/viennacl-dev/viennacl/linalg/eig.hpp external/viennacl-dev/viennacl/linalg/gmres.hpp external/viennacl-dev/viennacl/linalg/hankel_matrix_operations.hpp external/viennacl-dev/viennacl/linalg/ichol.hpp external/viennacl-dev/viennacl/linalg/ilu.hpp external/viennacl-dev/viennacl/linalg/inner_prod.hpp external/viennacl-dev/viennacl/linalg/jacobi_precond.hpp external/viennacl-dev/viennacl/linalg/lanczos.hpp external/viennacl-dev/viennacl/linalg/lu.hpp external/viennacl-dev/viennacl/linalg/matrix_operations.hpp external/viennacl-dev/viennacl/linalg/misc_operations.hpp external/viennacl-dev/viennacl/linalg/mixed_precision_cg.hpp external/viennacl-dev/viennacl/linalg/nmf.hpp external/viennacl-dev/viennacl/linalg/norm_1.hpp external/viennacl-dev/viennacl/linalg/norm_2.hpp external/viennacl-dev/viennacl/linalg/norm_frobenius.hpp external/viennacl-dev/viennacl/linalg/norm_inf.hpp external/viennacl-dev/viennacl/linalg/power_iter.hpp external/viennacl-dev/viennacl/linalg/prod.hpp external/viennacl-dev/viennacl/linalg/qr-method-common.hpp external/viennacl-dev/viennacl/linalg/qr-method.hpp external/viennacl-dev/viennacl/linalg/qr.hpp external/viennacl-dev/viennacl/linalg/row_scaling.hpp external/viennacl-dev/viennacl/linalg/scalar_operations.hpp external/viennacl-dev/viennacl/linalg/spai.hpp external/viennacl-dev/viennacl/linalg/sparse_matrix_operations.hpp external/viennacl-dev/viennacl/linalg/svd.hpp external/viennacl-dev/viennacl/linalg/toeplitz_matrix_operations.hpp external/viennacl-dev/viennacl/linalg/tred2.hpp external/viennacl-dev/viennacl/linalg/vandermonde_matrix_operations.hpp external/viennacl-dev/viennacl/linalg/vector_operations.hpp external/viennacl-dev/viennacl/linalg/cuda/common.hpp external/viennacl-dev/viennacl/linalg/cuda/direct_solve.hpp external/viennacl-dev/viennacl/linalg/cuda/matrix_operations.hpp external/viennacl-dev/viennacl/linalg/cuda/matrix_operations_col.hpp external/viennacl-dev/viennacl/linalg/cuda/matrix_operations_prod.hpp external/viennacl-dev/viennacl/linalg/cuda/matrix_operations_row.hpp external/viennacl-dev/viennacl/linalg/cuda/misc_operations.hpp external/viennacl-dev/viennacl/linalg/cuda/scalar_operations.hpp external/viennacl-dev/viennacl/linalg/cuda/sparse_matrix_operations.hpp external/viennacl-dev/viennacl/linalg/cuda/sparse_matrix_operations_solve.hpp external/viennacl-dev/viennacl/linalg/cuda/vector_operations.hpp external/viennacl-dev/viennacl/linalg/detail/op_applier.hpp external/viennacl-dev/viennacl/linalg/detail/op_executor.hpp external/viennacl-dev/viennacl/linalg/detail/amg/amg_base.hpp external/viennacl-dev/viennacl/linalg/detail/amg/amg_coarse.hpp external/viennacl-dev/viennacl/linalg/detail/amg/amg_debug.hpp external/viennacl-dev/viennacl/linalg/detail/amg/amg_interpol.hpp external/viennacl-dev/viennacl/linalg/detail/ilu/block_ilu.hpp external/viennacl-dev/viennacl/linalg/detail/ilu/common.hpp external/viennacl-dev/viennacl/linalg/detail/ilu/ilu0.hpp external/viennacl-dev/viennacl/linalg/detail/ilu/ilut.hpp external/viennacl-dev/viennacl/linalg/detail/spai/block_matrix.hpp external/viennacl-dev/viennacl/linalg/detail/spai/block_vector.hpp external/viennacl-dev/viennacl/linalg/detail/spai/fspai.hpp external/viennacl-dev/viennacl/linalg/detail/spai/qr.hpp external/viennacl-dev/viennacl/linalg/detail/spai/small_matrix.hpp external/viennacl-dev/viennacl/linalg/detail/spai/spai-dynamic.hpp external/viennacl-dev/viennacl/linalg/detail/spai/spai-static.hpp external/viennacl-dev/viennacl/linalg/detail/spai/spai.hpp external/viennacl-dev/viennacl/linalg/detail/spai/spai_tag.hpp external/viennacl-dev/viennacl/linalg/detail/spai/sparse_vector.hpp external/viennacl-dev/viennacl/linalg/host_based/common.hpp external/viennacl-dev/viennacl/linalg/host_based/direct_solve.hpp external/viennacl-dev/viennacl/linalg/host_based/matrix_operations.hpp external/viennacl-dev/viennacl/linalg/host_based/misc_operations.hpp external/viennacl-dev/viennacl/linalg/host_based/scalar_operations.hpp external/viennacl-dev/viennacl/linalg/host_based/sparse_matrix_operations.hpp external/viennacl-dev/viennacl/linalg/host_based/sse_blas.hpp external/viennacl-dev/viennacl/linalg/host_based/sse_kernels.hpp external/viennacl-dev/viennacl/linalg/host_based/vector_operations.hpp external/viennacl-dev/viennacl/linalg/opencl/common.hpp external/viennacl-dev/viennacl/linalg/opencl/direct_solve.hpp external/viennacl-dev/viennacl/linalg/opencl/matrix_operations.hpp external/viennacl-dev/viennacl/linalg/opencl/misc_operations.hpp external/viennacl-dev/viennacl/linalg/opencl/scalar_operations.hpp external/viennacl-dev/viennacl/linalg/opencl/sparse_matrix_operations.hpp external/viennacl-dev/viennacl/linalg/opencl/vandermonde_matrix_operations.hpp external/viennacl-dev/viennacl/linalg/opencl/vector_operations.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/compressed_compressed_matrix.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/compressed_matrix.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/coordinate_matrix.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/ell_matrix.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/fft.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/hyb_matrix.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/ilu.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/matrix.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/matrix_element.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/matrix_prod.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/matrix_solve.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/nmf.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/scalar.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/spai.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/svd.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/vector.hpp external/viennacl-dev/viennacl/linalg/opencl/kernels/vector_element.hpp external/viennacl-dev/viennacl/meta/enable_if.hpp external/viennacl-dev/viennacl/meta/predicate.hpp external/viennacl-dev/viennacl/meta/result_of.hpp external/viennacl-dev/viennacl/meta/tag_of.hpp external/viennacl-dev/viennacl/misc/bandwidth_reduction.hpp external/viennacl-dev/viennacl/misc/cuthill_mckee.hpp external/viennacl-dev/viennacl/misc/gibbs_poole_stockmeyer.hpp external/viennacl-dev/viennacl/ocl/backend.hpp external/viennacl-dev/viennacl/ocl/command_queue.hpp external/viennacl-dev/viennacl/ocl/context.hpp external/viennacl-dev/viennacl/ocl/device.hpp external/viennacl-dev/viennacl/ocl/device_utils.hpp external/viennacl-dev/viennacl/ocl/enqueue.hpp external/viennacl-dev/viennacl/ocl/error.hpp external/viennacl-dev/viennacl/ocl/forwards.h external/viennacl-dev/viennacl/ocl/handle.hpp external/viennacl-dev/viennacl/ocl/infos.hpp external/viennacl-dev/viennacl/ocl/kernel.hpp external/viennacl-dev/viennacl/ocl/local_mem.hpp external/viennacl-dev/viennacl/ocl/platform.hpp external/viennacl-dev/viennacl/ocl/program.hpp external/viennacl-dev/viennacl/ocl/utils.hpp external/viennacl-dev/viennacl/rand/gaussian.hpp external/viennacl-dev/viennacl/rand/uniform.hpp external/viennacl-dev/viennacl/rand/utils.hpp external/viennacl-dev/viennacl/scheduler/execute.hpp external/viennacl-dev/viennacl/scheduler/execute_axbx.hpp external/viennacl-dev/viennacl/scheduler/execute_elementwise.hpp external/viennacl-dev/viennacl/scheduler/execute_generic_dispatcher.hpp external/viennacl-dev/viennacl/scheduler/execute_matrix_dispatcher.hpp external/viennacl-dev/viennacl/scheduler/execute_matrix_prod.hpp external/viennacl-dev/viennacl/scheduler/execute_scalar_assign.hpp external/viennacl-dev/viennacl/scheduler/execute_scalar_dispatcher.hpp external/viennacl-dev/viennacl/scheduler/execute_util.hpp external/viennacl-dev/viennacl/scheduler/execute_vector_dispatcher.hpp external/viennacl-dev/viennacl/scheduler/forwards.h external/viennacl-dev/viennacl/scheduler/io.hpp external/viennacl-dev/viennacl/tools/adapter.hpp external/viennacl-dev/viennacl/tools/entry_proxy.hpp external/viennacl-dev/viennacl/tools/matrix_size_deducer.hpp external/viennacl-dev/viennacl/tools/shared_ptr.hpp external/viennacl-dev/viennacl/tools/timer.hpp external/viennacl-dev/viennacl/tools/tools.hpp external/viennacl-dev/viennacl/traits/clear.hpp external/viennacl-dev/viennacl/traits/context.hpp external/viennacl-dev/viennacl/traits/fill.hpp external/viennacl-dev/viennacl/traits/handle.hpp external/viennacl-dev/viennacl/traits/size.hpp external/viennacl-dev/viennacl/traits/start.hpp external/viennacl-dev/viennacl/traits/stride.hpp pyviennacl/__init__.py pyviennacl/linalg.py pyviennacl/pycore.py pyviennacl/util.py pyviennacl/vclmath.py pyviennacl/version.py pyviennacl.egg-info/PKG-INFO pyviennacl.egg-info/SOURCES.txt pyviennacl.egg-info/dependency_links.txt pyviennacl.egg-info/top_level.txt src/_viennacl/compressed_matrix.cpp src/_viennacl/compressed_matrix.hpp src/_viennacl/coordinate_matrix.cpp src/_viennacl/coordinate_matrix.hpp src/_viennacl/core.cpp src/_viennacl/dense_matrix.h src/_viennacl/dense_matrix_double.cpp src/_viennacl/dense_matrix_float.cpp src/_viennacl/dense_matrix_int.cpp src/_viennacl/dense_matrix_long.cpp src/_viennacl/dense_matrix_uint.cpp src/_viennacl/dense_matrix_ulong.cpp src/_viennacl/direct_solvers.cpp src/_viennacl/direct_solvers.hpp src/_viennacl/eig.cpp src/_viennacl/ell_matrix.cpp src/_viennacl/ell_matrix.hpp src/_viennacl/entry_proxy.hpp src/_viennacl/extra_functions.cpp src/_viennacl/hyb_matrix.cpp src/_viennacl/hyb_matrix.hpp src/_viennacl/iterative_solvers.cpp src/_viennacl/iterative_solvers.hpp src/_viennacl/opencl_support.cpp src/_viennacl/scheduler.cpp src/_viennacl/scheduler.h src/_viennacl/solve_op_func.hpp src/_viennacl/sparse_matrix.h src/_viennacl/vector.h src/_viennacl/vector_double.cpp src/_viennacl/vector_float.cpp src/_viennacl/vector_int.cpp src/_viennacl/vector_long.cpp src/_viennacl/vector_uint.cpp src/_viennacl/vector_ulong.cpp src/_viennacl/viennacl.h tests/blas3_prod.py tests/blas3_solve.py tests/matrix_operations.py tests/scalar_operations.py tests/test_common.py tests/vector_operations.pypyviennacl-1.0.2+dfsg.orig/pyviennacl.egg-info/PKG-INFO0000644000000000000000000002552412332260013021175 0ustar rootrootMetadata-Version: 1.1 Name: pyviennacl Version: 1.0.2 Summary: Sparse/dense linear algebra on GPUs and CPUs using OpenCL Home-page: http://viennacl.sourceforge.net/pyviennacl.html Author: Toby St Clere Smithe Author-email: pyviennacl@tsmithe.net License: UNKNOWN Description: ***************** PyViennaCL Readme ***************** PyViennaCL around the web ========================= * `Home page `_ * `Documentation `_ * `GitHub `_ (`Issue tracker `_) About PyViennaCL ================ *PyViennaCL* aims to make fast, powerful GPGPU and heterogeneous scientific computing really transparently easy, especially for users already using NumPy for representing matrices. PyViennaCL does this by harnessing the `ViennaCL `_ linear algebra and numerical computation library for GPGPU and heterogeneous systems, thereby making available to Python programmers ViennaCL’s fast *OpenCL* and *CUDA* algorithms. PyViennaCL does this in a way that is idiomatic and compatible with the Python community’s most popular scientific packages, *NumPy* and *SciPy*. PyViennaCL exposes the following functionality: * sparse (compressed, co-ordinate, ELL, and hybrid) and dense (row-major and column-major) matrices, vectors and scalars on your compute device using OpenCL; * standard arithmetic operations and mathematical functions; * fast matrix products for sparse and dense matrices, and inner and outer products for vectors; * direct solvers for dense triangular systems; * iterative solvers for sparse and dense systems, using the BiCGStab, CG, and GMRES algorithms; * iterative algorithms for eigenvalue estimation problems. Requirements ============ PyViennaCL requires the following build dependencies: * a C++ compiler; * *Python* (2.7+) with *setuptools* [see below]; * *NumPy* (1.7+); * *Sphinx* (1.0+) [if you want to build HTML documentation]. It is also highly recommended to have an available *OpenCL* implementation, since PyViennaCL was designed for this case. If you do not have OpenCL available, then PyViennaCL will still build and function, but will not perform to full effect. If you have a Boost installation on your system, then PyViennaCL can also optionally use that, rather than the Boost subset shipped with the PyViennaCL sources. setuptools ---------- PyViennaCL uses the Python package `setuptools `_ for installation. Unless you are using **Python 3.4**, which comes with the required pieces, you may need to install setuptools. The **best way to do so**, which will also ensure you have the Python package manager *pip* installed, is to follow `the instructions here `_. OpenCL ------ By default, you will need an OpenCL implementation. PyViennaCL can still build and function without one, but will not perform to full effect. For information on how to get an OpenCL implementation on Linux, see this `howto `_. See also the installation section in the `ViennaCL Manual `_ on installation hints for Windows. If you have an OpenCL installation that you installed and is not managed by your system's package manager, then it is likely you will need to use the '--cl-lib-dir' configure option. If you do not wish to use OpenCL, then follow the *Custom installation* instructions below, and use the '--no-use-opencl' configure option. Extra requirements for building from source on Windows systems -------------------------------------------------------------- In addition to the components required above, Windows builds require the use of the Windows SDK version specific to the version of your Python installation. For instance, when you run Python, if you see the following:: Python 2.7.6 (default, Nov 10 2013, 19:24:18) [MSC v.1500 32 bit (Intel)] on win32 then you are using a release of Python 2.7 and you are building for a 32-bit installation of that version. You must therefore choose the SDK version and set the build environment accordingly. If you are building for a standard distribution (such as described in the example above) of Python 2.6, 2.7, 3.0, 3.1 or 3.2 (either 32- or 64-bit), you will need the `Microsoft Windows SDK v7.0 for Windows 7 and .NET Framework 3.5 SP1 `_. If you are building for a standard distribution of Python 3.3 (32- or 64-bit), you will need the `Microsoft Windows SDK v7.1 for Windows 7 and .NET Framework 4 `_. Having installed the correct SDK version, you will need to open an SDK command prompt and issue the following commands, according the architecture of your Python installation. If you are building for a 32-bit Python installation, use:: $> set DISTUTILS_USE_SDK=1 $> setenv /x86 /release If you are building for a 64-bit Python installation, use:: $> set DISTUTILS_USE_SDK=1 $> setenv /x64 /release At this point, you will be able to follow the instructions detailed below under *Installation*. Issue all commands from within the SDK command window. You might also be interested in the `Python Tools for Visual Studio `_, though these are not required either for building or using PyViennaCL. Installation ============ Please note that the commands below assume that the various programs invoked are available in your system PATH; if they are not, please provide the full path to the executable on invocation. This is especially relevant on Windows systems, where Python is not by default installed into the path. So, in this case, you might have to run something like:: $> C:\Python2.7\python -m pip install pyviennacl instead of just:: $> pip install pyviennacl Quick installation using pip ---------------------------- The following command should usually be enough to install PyViennaCL, as long as you have setuptools and pip installed (see above):: $> pip install pyviennacl If you have a recent installation of Python (2.7 or 3.3+), and a recent installation of pip (1.4+), then this should be painless. Note that this command assumes you have OpenCL available, and if you are on Linux, an OpenCL SDK. If this does not succeed, follow the instructions below. Custom installation ------------------- These instructions assume a UNIX-like platform (such as a Linux distribution or Mac OS X), but will work on a well-configured Windows system with little modification. If you are building from the release package, move on to the next paragraph. If you are building from git, then before doing anything else, navigate to your PyViennaCL folder and get the external submodules with:: $> git submodule update --init (On Windows you usually want to use the git bash for this) If you are in a hurry, then the following should just work:: $> python setup.py build $> sudo python setup.py install Otherwise, read the configuration options, configure, build and install:: $> ./configure.py --help $> ./configure.py --some-options $> python setup.py build $> sudo python setup.py install To build the HTML documentation using Sphinx, first install PyViennaCL as above, and then run:: $> cd doc $> make html after which HTML documentation will be in doc/_build/html. Or you can just access the documentation from within the Python interpreter after installation:: >>> import pyviennacl >>> help(pyviennacl) Authors and Contact =================== PyViennaCL was developed during the 2013 *Google Summer of Code* by `Toby St Clere Smithe `_. ViennaCL was developed under the aegis of the *Institute for Microelectronics* at the *Vienna University of Technology*. For any technical questions related to ViennaCL, please use `our mailing list `_. Licence ======= (Py)ViennaCL is distributed under the MIT (X11) License. See the file LICENSE in the source root directory. Platform: UNKNOWN Classifier: Environment :: Console Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: Intended Audience :: Other Audience Classifier: Intended Audience :: Science/Research Classifier: License :: OSI Approved :: MIT License Classifier: Natural Language :: English Classifier: Programming Language :: C++ Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.2 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Topic :: Scientific/Engineering Classifier: Topic :: Scientific/Engineering :: Mathematics Classifier: Topic :: Scientific/Engineering :: Physics pyviennacl-1.0.2+dfsg.orig/pyviennacl.egg-info/dependency_links.txt0000644000000000000000000000000112332260013024136 0ustar rootroot pyviennacl-1.0.2+dfsg.orig/Makefile.in0000644000000000000000000000045412307335633016313 0ustar rootroot.PHONY : all install clean dist-clean tags all: tags ${PYTHON_EXE} setup.py build install: all tags ${PYTHON_EXE} setup.py install clean: ${PYTHON_EXE} setup.py clean rm -Rf build rm -f tags dist-clean: clean rm siteconf.py Makefile rm *pyc rm -R __pycache__ tags: ctags -R src || true pyviennacl-1.0.2+dfsg.orig/setup.cfg0000644000000000000000000000020612332260016016050 0ustar rootroot[flake8] ignore = E126,E127,E128,E123,E226,E241,E242 max-line-length = 85 [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 pyviennacl-1.0.2+dfsg.orig/ChangeLog0000644000000000000000000000076612332116536016023 0ustar rootroot2014-05-06 Toby St Clere Smithe * Release 1.0.2. * Re-enable Lanczos algorithm for eigenvalues (issue #11). [cbfb41fca3fb1f3db42fd7b3ccb8332b701d1e20] * Enable eigenvalue computations for compressed and coordinate matrices. [8ecee3b200a92ae99b72653a823c1f60e62f75dd] * Fix matrix-vector product for non-square matrices (issue #13). [bf3aa2bf91339df72b6f7561afaf8b12aad57cda] * Link against rt on Linux (issue #12). [d5784b62b353ebbfd78fe1335fd96971b5089f53]