- 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 ?).
- examples split from the rst file using a python script (split_code).
- Final result for the doc is unchanged.
- examples are compiled and tested with the other tests.
- examples' code have been clang-formatted, with triqs style.
- doc compiles much faster, and with the same options as the rest of the
test.
- examples are added as tests, so they are run by make test, as simple C
tests.
- done for the tutorials and the reference.
- autocompile removed (changed into triqs_example directive).
- add triqs_example :
- make a literal include of the source code.
- runs the compiled example
- add, as before, the result to the source code in the doc.
- added the script split_code, used to make the changes automatically,
maybe for later reuse. (in _tools)
- clean the c_name.
- add more refined signature (with c_name optionally in it).
- add some autodoc.
- clean code : move class in nested, remove useless dict call, etc...
- operator2 : move unary - and unit in algebra in general wrapper.
- various name change to make private function start with _, for
autodoc.
- 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.
- a module can use the converters used by another
with the use_module('A') command.
In which case :
- the generate converter header for A will be included.
- the header, at the top, now contains a simple list of all
wrapped types, which is then included in the wrapped_types
of the module for proper code generation.
- simplify the code generation : just generate_code.
- all arguments are analyzed from sys.argv at the import of the
wrap_generator module. In any case, the xx_desc.py will be called from the corresponding
cmake command, hence with the right arguments.
- Added a dependencies in my_module_B of wrap_test to show how to make
the dependencies in the cmake file, if needed.
- 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
- 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
- The kind() method of mesh should return a char,
like the parameter of the constructor of mesh,
not the C++ corresponding int.
- otherwise, the reduction - construction is broken
and by extension all pickling and then all mpi constructions.
- to choose mpi4py over boost.python.mpi, pass -DPython_use_mpi4py=ON
- boost.mpi stays the default for python, but
adding the possibility of using mpi4py instead.
- Due to numerous pbs on recent OS X + brew installation.
boost.mpi does not work (crash in openmpi ??), mpi4py does
- the pytriqs/utility/mpi.py is now configured by the cmake (like
version.py) to prepare one of the two possibilities.
- TODO: not tested carefully : to be done in other machines.
When an object with __hdf_write__ was written in an archive, the
corresponding key was not cached. Therefore, one could not access
the object which had just been written.
