- Simplify group_indices
- Only for C ordered, remove complex compile time.
- Could be generalized to non C ordered, but no need.
- Fix slice for custom orders.
- Generalize the group_indices for the custom order.
- Add c_ordered_transposed_view (useful ?)
- Improve slice, special for ellipsis (quicker).
- Simplify TraversalOrder
- Assignement. Specialize one case for speed.
- use FORCEINLINE in foreach, according to speed test for clang
- add one speed test
- Modify iterators for better speed.
- along the lines decided for the foreach
- update doc.
- change the underlying data : do not flatten the linear indices of the
mesh into a single index, keep a higher dim array.
- easier for various places, and necessary for g(nu,nu').
- work on several 2 part. containers.
- add default target (may not be always matrix_valued)
- Implement the basic structure of the mpi lib
and specialization for arrays, basic types, std::vector
- adapted the array class for the lazy mpi mechanism
- pass tests on arrays :
- scatter, gather on array<long,2> array<complex,2>, etc...
- broadcast
- several files for readibility
- the std::vector coded but not tested.
- generic mecanism implemented and tested (mpi_generic test)
- added several tests for the mpi lib.
- TODO : more tests, doc...
The c++ version of the tail fit is wrapped to python. I also changed
slightly the code so that when replace_by_fit is true the data is
changed all the way to the end of the Matsubara axis not only on the
interval where the fit was done.
- the flag is really enforce_copy and should force a copy
- for a view : it is false, no change
- for a regular type : it is true, and now this will enforce the
copy in the call of numpy. numpy does it for us.
- The problematic case was when we construct a regular type
from a complicated view in python, which is an array
but is not C contiguous.
(hence the PyArray_Check was false, and the C_Contiguous flag was not set)
Now it is fine, since we ask numpy to systematically copy the data for us
and build a C contigous array.
--> the constructor from python does not support custom memory layout
because numpy only support C and Fortran
Conflicts:
triqs/arrays/impl/indexmap_storage_pair.hpp
- The issue comes from the fact that the default generated
+= and co by the Python API is the one for immutable types, like int.
- Indeed, in python, for an int :
x=1
id(x)
140266967205832
x+=1
id(x)
140266967205808
- For a mutable type, like a gf, it is necessary to
add explicitly the xxx_inplace_add functions.
- Added :
- the generation of the inplace_xxx functions
- a method in class_ in the wrapper generator that
deduce all += operator from the + operators.
- this assumes that the +=, ... are defined in C++.
- The generation of such operators are optional, with option
with_inplace_operators in the arithmetic flag.
- Also, added the overload g += M and g -= M for
g : GfImfreq, M a complex matrix.
Mainly for legacy Python codes.
- Cleaned of the eigensystems computations (worker is simpler, decision
at runtime, etc..).
- Fix#119 : When the matrix is in C order, the fortran lapack
sees in fact its conjugate, so we need to conjugate the eigenvectors at the end.
NB : not true if the storage order of the matrix is already fortran of course.
- Pb was that indices for gf where empty when constructed
with default args from C++.
- changed into : make indices from the shape in the default
case.
- also added more, simpler construction, for the indices
to easy C++ construction.
- the wrapper will now add date and time
at the boundary between C++ and Python.
- using C lib, not C++ (lack of support of C++ chrono functions in gcc).
- hdfarchive : transform the key to string with str
because they can be unicode and C wrapper does not convert python unicode strings.
- gf : Correct the scheme for BlockGf : not very clean, to be improved ?
I also added a test to make sure the time mesh is twice as
long as the frequency mesh. Obviously now some tests don't
pass... I will fix them in the next commit.
- For users : only change is :
H5::H5File in apps. to be replaced by triqs::h5::file, same API.
- using only the C API because :
- it is cleaner, better documented, more examples.
- it is the native hdf5 interface.
- simplify the installation e.g. on mac. Indeed, hdf5 is
usually installed without C++ interface, which is optional.
E.g. EPD et al., brew by default.
Also the infamous mpi+ hdf5_cpp bug, for which we have no clean solution.
- clean the notion of parent of a group. Not needed, better iterate function in C LT API.
- modified doc : no need for C++ bindings any more.
- modified cmake to avoid requiring CPP bindings.
- import arrays in extensions (mako file).
- put import_arrays in converter,
along the lines of our own objects (numpy and triqs uses
the same capsule technique, i.e. the standard technique from python
doc.)
