- 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.)
- for all functions, except when GIL option (not implemented) is here
we use a triqs::py_stream, which redirect the stream
to python sys.write
- so that a simple C++ code with a std::cout
print its output in the notebook...
- NB : it only works for the code within the cell.
If it calls another function on the lib which uses cout,
print is not redirected.
Designed for simple tests....
- cerr not (yet) redirected. (useful ?).
- Add to the wrapper generator (add_method) the release_GIL_and_enable_signal option which :
- release the GIL
- save the python signal handler
- enable the C++ triqs signal handler instead.
- undo all of this after the code runs, or in a case of exception.
- used python include, ceval.h, line 72 comments and below.
- reworked the triqs::signal_handler.
simple C like function, no object (no need).
start, stop, received, cf header file.
- clean the call_back.cpp : only place using the signal directly
(qmc uses the callback).
in particular, remove the old BOOST CHRONO, since
the std::chrono works fine on platforms we use now.
- change the constructor wrapper.
- in the new method, leave the pointer _c to NULL.
- in the init, allocate it.
- It seems ok to leave the object in this non initialized state,
but that is not so clear from the doc.
Added check for this pointer == NULL in converters.
- Use a new buffered_function to replace the complicated generator code from ALPS.
- Clean the implementation of the random_generator
- update the documentation
- update to the new python wrapper (could not be done with the previous
version, because of lack of move constructor).
- implement transposed_view for arrays.
- .transpose method for gf
- wrapped to python
- add call op. for GfImTime, using C++
- Added ChangeLog
- rm matrix_stack
- start cleaning old code
- an include missing on OS X
- change serialization in the general case where hdf5 can be used,
(version of hdf5 high enough) to use only one buffer,
not a buffer per field.
- put back the mpi_param example.
- parameters : clean, add back serialization. Clean whitespace
- serialization : depending on the version of the hdf5 lib,
uses h5 or boost.
- TODO : test it on a machine with new hdf5.
- new parameter class :
parameters are viewed as form, built in C++, and filled in C++/python.
Each field of the form as a precise C++ type (erased using standard techniques).
First tests ok, to be reread/checked.
TODO : serialization is commented. Lead to long compilation time & large code
due to boost::serialization. Use h5 when possible.
- wrapper :
- separated the converters of the wrapped type in the TRIQS library
- necessary for parameters (it used outside an .so) and potentially
other codes, outside an .so module
When constructing the last unit vector in 2D, the sanity check was wrong because of usage of abs instead of std::abs.
Added method energy_on_bz_path_2 that returns the energy *matrix* at each k point on a given path instead of the eigenvalues of this matrix. The name of the function should be changed (to energy_matrix_on_bz_path?)
Renaming energies_on_bz_path_2 to energy_matrix_on_bz_path
- h5/make_h5.... only used in parameters.
- old boost includes before C++11
- remove boost serialization, make macro TRIQS_MAKE_NVP temporarely
- remove boost::is_complex (can be written in 2 lines...)
- move some lib in cpp
- fold was not correct in e.g. passing an int as init instead of a
double (was leading to narrowing in return).
- better return type deduction.
- there was an error in the doc (order of argument in the lambda !)
- add a more complex example (Frobenius norm of matrices).
- when the ratio returned by an attempt of a move is infinite,
previous code was just throwing TRIQS_RUNTIME_ERROR.
- Now when the ratio is infinite, it is replaced by a large number
(>1 is enough for metropolis), and the sign is properly updated
using std::signbit.
- NB :
- a double/float in C++ can be : normal/ zero/ nan/ infinite / subnormal.
Here, the code will recover only from infinite case.
- std::signbit works for infinite (according to standard).
Changed operator()(int, int...) && for array, and views.
- For const_view and regular type, returns value_type (i.e. a copy).
NB : does make a copy, not a move. Ok for scalar type. TODO: think for complicated types.
This allows codes like :
f(x)(0,0) where f : x-> matrix or const_view
to be correct in clef expression evaluation.
- For _view : return a value_type &, as before to allow :
A(....)(0,0) = rhs;
It is not possible to detect dangling refs in that case at compile time.
Added a security in TRIQS_ARRAYS_DEBUG mode to detect a dangling ref at run time,
i.e. the case where the view is "unique" (ref count ==1).
This would be a quite bad design anyway ...
- also :
- clean operator[] for vector (old workaround for old gcc...)
- add IsView flag in ISP impl class, for the impl. of operator() &&
mesh_pt should NOT be done directly by (),
it should be casted to matsubara_freq.
Removed an old line of code which we forgot to clean
when introducing matsubara_freq
A(i_)(om_) << ...
for A an array of gf was not working.
Modified the auto_assign of arrays to handle the case when the object
in the array is itself autoassigned.
Using the model of std::vector adapter for clef, which works.
Also fixed the gf for a little details (gf_impl is usually in the expression tree, not gf).
- bool at_end() for a mesh point means AFTER the last point ,
as end in STL. It was not correct ( +1 missing).
- also the at_end was not computed in the mesh product.
- it slightly changes the test_fit_tail --> just changed the output.
--> did this bug affect other functions/codes ?
- correct previous commit (for scalar gf, the new check was not compiling)
- correct windowing of linear mesh (left point corrected as right point for rounding error
-> code was previously assuming mesh with only positive, fermionic matsubara freqs
-> changed wn_min to n_min (was misleading, since it was an index, not a frequency) / same for <-> max
-> changed doc accordingly
-> Previously, calculation was implicitly assuming a mesh with only positive matsubara frequencies.
-> Added corresponding test
-> Also added test of density calculation with or without correct tail.
- add c14 include
- the C++14 is lot more readable (due to generic lambda).
- for mesh/product.hpp -> now 2 versions (C++14 and C++11 for temporary
backward compatibility).
Pb :
M() = rhs; // rhs of type RHS
Currenlty does :
M(i,j) = (i==j ? rhs : RHS{})
Changed to
M(i,j) = (i==j ? rhs : RHS{0*rhs})
If RHS is a double, int ... Same result.
If RHS is a matrix, gf, currently the offdiag elements
are default constructed (i.e. of 0 size !).
Which can break operations later (matrix<matrix<double>>)
After change : all elements have the same size !
- use alias
- rename a few things, simplify
- some clang format
- add eval to ref wrapper
- correct evaluator general (return const &, no copy)
- correct declaration order of struct and operator OP
