mirror of
https://github.com/triqs/dft_tools
synced 2024-12-27 06:43:40 +01:00
121 lines
6.5 KiB
ReStructuredText
121 lines
6.5 KiB
ReStructuredText
|
.. highlight:: c
|
||
|
|
|
||
|
|
array and array_view : the general cuboid n-dimensional array
|
||
|
|
====================================================================================================================
|
||
|
|
|
||
|
|
array and array_view :
|
||
|
|
|
||
|
|
* are the standard d-dimensional cuboid array and the corresponding view.
|
||
|
|
* allow **custom memory ordering** at compile time.
|
||
|
|
* model the :ref:`HasImmutableArrayInterface` concept.
|
||
|
|
|
||
|
|
Template parameters
|
||
|
|
----------------------------
|
||
|
|
|
||
|
|
* The classes have three template parameters.
|
||
|
|
|
||
|
|
.. code-block:: c
|
||
|
|
|
||
|
|
template <typename ValueType, int Rank, typename Opt= Option::Default > class array_view;
|
||
|
|
template <typename ValueType, int Rank, typename Opt= Option::Default > class array;
|
||
|
|
|
||
|
|
|
||
|
|
============================ ================================== ========================== ====================================================================
|
||
|
|
Template parameter Accepted type Access in the class Meaning
|
||
|
|
============================ ================================== ========================== ====================================================================
|
||
|
|
ValueType normally a scalar, but any default value_type The type of the element of the array
|
||
|
|
constructible type (?).
|
||
|
|
Rank int rank The rank of the array
|
||
|
|
Opt Option::options< ...> opt_type Compile time options, see below.
|
||
|
|
============================ ================================== ========================== ====================================================================
|
||
|
|
|
||
|
|
Options template parameters are described :ref:`here <option_template>`.
|
||
|
|
|
||
|
|
.. _array_constructors:
|
||
|
|
|
||
|
|
Constructors of array
|
||
|
|
---------------------------
|
||
|
|
|
||
|
|
* Intentionally, array and array_view have only a few constructors :
|
||
|
|
|
||
|
|
========================================== ===========================================================================================
|
||
|
|
Constructors of array Comments
|
||
|
|
========================================== ===========================================================================================
|
||
|
|
array() - Empty array of size 0
|
||
|
|
array(size_t, ...., size_t) - From the dimensions [number of parameters checked at compile time].
|
||
|
|
Does **NOT** initialize the array elements to 0 ! (see compile time option)
|
||
|
|
Use my_array() =0 to do it explicitely.
|
||
|
|
array(cuboid_domain<rank> const &) - New array with the corresponding domain
|
||
|
|
array(const array &) - Copy construction
|
||
|
|
array(PyObject * X) - Construct a new array from the Python object X.
|
||
|
|
NB : X is a borrowed reference, array does affect its counting reference.
|
||
|
|
- it takes a **copy** of the data of X (or of numpy(X)) into C++.
|
||
|
|
- X is first transformed into a numpy by the python numpy lib itself
|
||
|
|
(as if you call numpy.array(X)) if X is not a numpy array or an array of the wrong type
|
||
|
|
(e.g. you construct an array<double,2> from a numpy of int....), and
|
||
|
|
copied into the array.
|
||
|
|
array(const T & X) - Type T models the :ref:`HasImmutableArrayInterface` concept.
|
||
|
|
- X must have the appropriate domain (checked at compile time).
|
||
|
|
- Constructs a new array of domain X.domain() and fills it with evaluation of X.
|
||
|
|
========================================== ===========================================================================================
|
||
|
|
|
||
|
|
.. warning::
|
||
|
|
The constructor from the dimensions does **NOT** initialize the matrix to 0
|
||
|
|
(because it may not be optimal).
|
||
|
|
If needed, do it explicitely by (a if the array) `a()=0`;
|
||
|
|
|
||
|
|
|
||
|
|
* Examples ::
|
||
|
|
|
||
|
|
array<int,2> A(10,2);
|
||
|
|
A()=0; // init the array to 0
|
||
|
|
array<int,2, Option::Fortran> Af (2,2);
|
||
|
|
|
||
|
|
//Higher dim, custom order :
|
||
|
|
array<long, 3, Option::options<Option::memory_order <2,1,0> > > A0 (2,3,4);
|
||
|
|
array<long, 3, Option::options<Option::memory_order <0,1,2> > > A1 (2,3,4);
|
||
|
|
array<long, 3, Option::options<Option::memory_order <1,0,2> > > A2 (2,3,4);
|
||
|
|
array<long, 3 > A3 (2,3,4);
|
||
|
|
array<long, 3, Option::Fortran > A4 (2,3,4);
|
||
|
|
|
||
|
|
// if Obj is boost::python object
|
||
|
|
array<double,2> A (Obj.ptr());
|
||
|
|
|
||
|
|
|
||
|
|
.. _array_constructors:
|
||
|
|
|
||
|
|
Constructors of array_views
|
||
|
|
----------------------------------------------
|
||
|
|
|
||
|
|
Automatic construction
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
|
||
|
|
array_view are normally automatically constructed by making (partial) views, ref:`Slicing`, e.g. ::
|
||
|
|
|
||
|
|
array<int,2> A(2,2);
|
||
|
|
A(range(),2) ; // --> this makes a view...
|
||
|
|
A() ; // --> this makes a view over the full array
|
||
|
|
|
||
|
|
Explicit construction
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
|
||
|
|
To explicitly make a view of an array, use make_view or the ()::
|
||
|
|
|
||
|
|
array<int,2> A(2,2);
|
||
|
|
make_view(A); //-> a view...
|
||
|
|
make_view(A) = 13 ; // to assign e.g.
|
||
|
|
A() = 13; // same thing...
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
====================================================================== =====================================================================================================
|
||
|
|
Constructors of array_view Comments
|
||
|
|
====================================================================== =====================================================================================================
|
||
|
|
array_view(const array_view &) - Copy construction (shallow copy)
|
||
|
|
array_view(const T & X) - `[Advanced]` T is any type such that X.indexmap() and X.storage() can be used to construct a view.
|
||
|
|
array_view(indexmap_type const & I, S_type const &) - `[Advanced]` From a couple of indexmap I and storage of type S_type.
|
||
|
|
====================================================================== =====================================================================================================
|
||
|
|
|
||
|
|
|