LCPQ/dft_tools
3
0
Fork 0
mirror of https://github.com/triqs/dft_tools synced 2024-10-31 19:23:45 +01:00
Code Issues Releases Wiki Activity

implement array_const_view

Browse Source
This commit is contained in:
Olivier Parcollet 2013-10-06 22:10:42 +02:00
parent 6a140d2950
commit 9002c1e456
19 changed files with 149 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
test/triqs/arrays/alias_const_view.cpp
View File

@ -1,47 +0,0 @@
/*******************************************************************************
*
* TRIQS: a Toolbox for Research in Interacting Quantum Systems
*
* Copyright (C) 2013 by O. Parcollet
*
* TRIQS is free software: you can redistribute it and/or modify it under the
* terms of the GNU General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later
* version.
*
* TRIQS is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* TRIQS. If not, see <http://www.gnu.org/licenses/>.
*
******************************************************************************/
#include "./common.hpp"
#include "./src/array.hpp"
#include <iostream>
//using std::cout; using std::endl;
using namespace triqs::arrays;
#include <type_traits>
template<typename U, ull_t opt, ull_t to, bool B>
void f (array_const_view<U,2,opt,to,B> const & a) {
std::cout << a << std::endl ;
}
int main(int argc, char **argv) {
array<long,2 > A (2,3);
A() =3;
f(A());
}

2
test/triqs/arrays/array_cache2.cpp
View File

@ -28,7 +28,7 @@
using namespace triqs::arrays; using namespace triqs::arrays;
void f( array_view<long,2> & A, long u) { void f( array_view<long,2> A, long u) {
A(0,0) = u; A(0,0) = u;
} }

33
test/triqs/arrays/const_view.cpp
View File

@ -24,18 +24,37 @@
using namespace triqs::arrays; using namespace triqs::arrays;
template <typename U, ull_t opt, ull_t to, bool B> void f(array_view<U, 2, opt, to, B, true> const &a) {
std::cout << a << std::endl;
}
void f2(array_const_view<long, 2> const &a) { std::cout << a << std::endl; }
int main(int argc, char **argv) { int main(int argc, char **argv) {
{
array<long, 2> A(2, 3);
A() = 3;
auto const &AA = A;
f2(A());
array_const_view<long,2> Vc = A();
//array_view<long,2> V = Vc;
}
//#define SHOULD_NOT_COMPILE
#ifdef SHOULD_NOT_COMPILE
{
const array<long, 1> A = {1, 2, 3, 4}; const array<long, 1> A = {1, 2, 3, 4};
std::cerr << A.opt_flags<<std::endl;
std::cerr << A().opt_flags<<std::endl;
// None of this should compile // None of this should compile
//A(0) = 2; A(0) = 2;
//A()(0) = 2; A()(0) = 2;
//A(range(0,2))(0) = 10; A(range(0,2))(0) = 10;
}
#endif
return 0; return 0;
} }

2
test/triqs/arrays/temp_slice.cpp
View File

@ -28,7 +28,7 @@ auto bad (array<long,1> const & a) DECL_AND_RETURN (a(range(0,3)));
auto bad2 (array<long,1> const & a) DECL_AND_RETURN (a(0)); auto bad2 (array<long,1> const & a) DECL_AND_RETURN (a(0));
array_view<long,1> good(array<long,1> const & a) {return a(range(0,3));} array_const_view<long,1> good(array<long,1> const & a) {return a(range(0,3));}
int main(int argc, char **argv) { int main(int argc, char **argv) {

2
test/triqs/gfs/gf_scalar.cpp
View File

@ -15,7 +15,7 @@ int main() {
// test hdf5 // test hdf5
H5::H5File file("gf_scalar.h5", H5F_ACC_TRUNC); H5::H5File file("gf_scalar.h5", H5F_ACC_TRUNC);
h5_write(file, "g", G); h5_write(file, "g", G);
h5_write(file, "gm", reinterpret_scalar_valued_gf_as_matrix_valued(G)); h5_write(file, "gm", reinterpret_scalar_valued_gf_as_matrix_valued(G()));
} }
TRIQS_CATCH_AND_ABORT; TRIQS_CATCH_AND_ABORT;

2
test/triqs/gfs/gfv2.cpp
View File

@ -29,7 +29,7 @@ int main() {
TEST( G( 0) ) ; TEST( G( 0) ) ;
Gv.on_mesh(0) = 0; Gv.on_mesh(0) = 0;
auto Gv2 = slice_target(G,range(0,1),range(0,1)); auto Gv2 = slice_target(G(),range(0,1),range(0,1));
TEST( Gv2( 0) ) ; TEST( Gv2( 0) ) ;
Gv2.on_mesh(0) = 10; Gv2.on_mesh(0) = 10;
TEST( Gv2( 0) ) ; TEST( Gv2( 0) ) ;

25
triqs/arrays/array.hpp
View File

@ -28,15 +28,15 @@
#include "impl/flags.hpp" #include "impl/flags.hpp"
namespace triqs { namespace arrays { namespace triqs { namespace arrays {
template <typename ValueType, int Rank, ull_t Opt=0, ull_t TraversalOrder= 0, bool Borrowed=false > class array_view; template <typename ValueType, int Rank, ull_t Opt=0, ull_t TraversalOrder= 0, bool Borrowed=false, bool IsConst=false > class array_view;
template <typename ValueType, int Rank, ull_t Opt=0, ull_t TraversalOrder= 0> class array; template <typename ValueType, int Rank, ull_t Opt=0, ull_t TraversalOrder= 0> class array;
// ---------------------- array_view -------------------------------- // ---------------------- array_view --------------------------------
#define IMPL_TYPE indexmap_storage_pair< indexmaps::cuboid::map<Rank,Opt,TraversalOrder>, \ #define IMPL_TYPE indexmap_storage_pair< indexmaps::cuboid::map<Rank,Opt,TraversalOrder>, \
storages::shared_block<ValueType, Borrowed>, Opt, TraversalOrder, Tag::array_view > storages::shared_block<ValueType, Borrowed>, Opt, TraversalOrder, IsConst, Tag::array_view >
template <typename ValueType, int Rank, ull_t Opt, ull_t TraversalOrder, bool Borrowed> template <typename ValueType, int Rank, ull_t Opt, ull_t TraversalOrder, bool Borrowed, bool IsConst>
class array_view: Tag::array_view, TRIQS_CONCEPT_TAG_NAME(MutableArray), public IMPL_TYPE { class array_view: Tag::array_view, TRIQS_CONCEPT_TAG_NAME(MutableArray), public IMPL_TYPE {
static_assert( Rank>0, " Rank must be >0"); static_assert( Rank>0, " Rank must be >0");
public: public:
@ -44,6 +44,7 @@ namespace triqs { namespace arrays {
typedef typename IMPL_TYPE::storage_type storage_type; typedef typename IMPL_TYPE::storage_type storage_type;
typedef array <ValueType,Rank,Opt,TraversalOrder> regular_type; typedef array <ValueType,Rank,Opt,TraversalOrder> regular_type;
typedef array_view<ValueType,Rank,Opt,TraversalOrder> view_type; typedef array_view<ValueType,Rank,Opt,TraversalOrder> view_type;
typedef array_view<ValueType, Rank, Opt, TraversalOrder, false, true> const_view_type;
typedef array_view<ValueType,Rank,Opt,TraversalOrder,true> weak_view_type; typedef array_view<ValueType,Rank,Opt,TraversalOrder,true> weak_view_type;
/// Build from an IndexMap and a storage /// Build from an IndexMap and a storage
@ -53,7 +54,10 @@ namespace triqs { namespace arrays {
array_view(array_view const & X): IMPL_TYPE(X.indexmap(),X.storage()) {} array_view(array_view const & X): IMPL_TYPE(X.indexmap(),X.storage()) {}
/// Build from anything that has an indexmap and a storage compatible with this class /// Build from anything that has an indexmap and a storage compatible with this class
template<typename ISP> array_view(const ISP & X): IMPL_TYPE(X.indexmap(),X.storage()) {} template<typename ISP> array_view(const ISP & X): IMPL_TYPE(X.indexmap(),X.storage()) {
// to be activated
static_assert(IsConst || (!ISP::is_const), "Can not construct a non const view from a const one !");
}
#ifdef TRIQS_WITH_PYTHON_SUPPORT #ifdef TRIQS_WITH_PYTHON_SUPPORT
/// Build from a numpy.array (X is a borrowed reference) : throws if X is not a numpy.array /// Build from a numpy.array (X is a borrowed reference) : throws if X is not a numpy.array
@ -88,12 +92,12 @@ namespace triqs { namespace arrays {
#undef IMPL_TYPE #undef IMPL_TYPE
template <typename ValueType, int Rank, ull_t Opt=0, ull_t TraversalOrder=0, bool Borrowed=false> template <typename ValueType, int Rank, ull_t Opt=0, ull_t TraversalOrder=0, bool Borrowed=false>
using array_const_view = array_view<ValueType, Rank, Opt, TraversalOrder, Borrowed>; using array_const_view = array_view<ValueType, Rank, Opt, TraversalOrder, Borrowed, true>;
//------------------------------- array --------------------------------------------------- //------------------------------- array ---------------------------------------------------
#define IMPL_TYPE indexmap_storage_pair< indexmaps::cuboid::map<Rank,Opt,TraversalOrder>, \ #define IMPL_TYPE indexmap_storage_pair< indexmaps::cuboid::map<Rank,Opt,TraversalOrder>, \
storages::shared_block<ValueType>, Opt, TraversalOrder, Tag::array_view > storages::shared_block<ValueType>, Opt, TraversalOrder, false, Tag::array_view >
template <typename ValueType, int Rank, ull_t Opt, ull_t TraversalOrder> template <typename ValueType, int Rank, ull_t Opt, ull_t TraversalOrder>
class array: Tag::array, TRIQS_CONCEPT_TAG_NAME(MutableArray), public IMPL_TYPE { class array: Tag::array, TRIQS_CONCEPT_TAG_NAME(MutableArray), public IMPL_TYPE {
@ -103,6 +107,7 @@ namespace triqs { namespace arrays {
typedef typename IMPL_TYPE::indexmap_type indexmap_type; typedef typename IMPL_TYPE::indexmap_type indexmap_type;
typedef array<ValueType, Rank, Opt, TraversalOrder> regular_type; typedef array<ValueType, Rank, Opt, TraversalOrder> regular_type;
typedef array_view<ValueType, Rank, Opt, TraversalOrder> view_type; typedef array_view<ValueType, Rank, Opt, TraversalOrder> view_type;
typedef array_view<ValueType, Rank, Opt, TraversalOrder, false, true> const_view_type;
typedef array_view<ValueType, Rank, Opt, TraversalOrder, true> weak_view_type; typedef array_view<ValueType, Rank, Opt, TraversalOrder, true> weak_view_type;
/// Empty array. /// Empty array.
@ -206,16 +211,16 @@ namespace triqs { namespace arrays {
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// how to build the view type .... // how to build the view type ....
template < class V, int R, ull_t Opt, ull_t TraversalOrder, bool Borrowed > template < class V, int R, ull_t Opt, ull_t TraversalOrder, bool Borrowed, bool IsConst >
struct ISPViewType< V, R, Opt, TraversalOrder,Tag::array_view, Borrowed> { typedef array_view<V,R,Opt,TraversalOrder, Borrowed> type; }; struct ISPViewType< V, R, Opt, TraversalOrder,Tag::array_view, Borrowed,IsConst> { typedef array_view<V,R,Opt,TraversalOrder, Borrowed,IsConst> type; };
}}//namespace triqs::arrays }}//namespace triqs::arrays
// The std::swap is WRONG for a view because of the copy/move semantics of view. // The std::swap is WRONG for a view because of the copy/move semantics of view.
// Use swap instead (the correct one, found by ADL). // Use swap instead (the correct one, found by ADL).
namespace std { namespace std {
template <typename V, int R, triqs::ull_t Opt, triqs::ull_t To, bool B1, bool B2> template <typename V, int R, triqs::ull_t Opt, triqs::ull_t To, bool B1, bool B2, bool C1, bool C2>
void swap( triqs::arrays::array_view<V,R,Opt,To,B1> & a , triqs::arrays::array_view<V,R,Opt,To,B2> & b)= delete; void swap( triqs::arrays::array_view<V,R,Opt,To,B1,C1> & a , triqs::arrays::array_view<V,R,Opt,To,B2,C2> & b)= delete;
} }
#include "./expression_template/array_algebra.hpp" #include "./expression_template/array_algebra.hpp"

45
triqs/arrays/cache.hpp
View File

@ -45,20 +45,19 @@ namespace triqs { namespace arrays {
template<typename A1, typename A2, typename Enable =void > struct need_copy_ct : mpl::true_{}; template<typename A1, typename A2, typename Enable =void > struct need_copy_ct : mpl::true_{};
template<typename A1, typename A2> struct need_copy_ct<A1,A2, ENABLE_IF(is_amv_value_or_view_class<A1>)> : template<typename A1, typename A2> struct need_copy_ct<A1,A2, ENABLE_IF(is_amv_value_or_view_class<A1>)> :
mpl::not_<std::is_same< typename A1::value_type, typename A2::value_type> > {}; mpl::not_<std::is_same< typename A1::value_type, typename A2::value_type> > {};
//mpl::not_<indexmaps::IndexOrder::same_order<typename A1::indexmap_type::index_order_type, typename A2::indexmap_type::index_order_type> >{};
template<typename DataType, typename CacheType> class const_cache { template<typename DataType, typename CacheType, bool IsConst> class cache_impl {
protected: protected:
typedef memory_layout< DataType::domain_type::rank> ml_t; typedef memory_layout< DataType::domain_type::rank> ml_t;
const ml_t ml; const ml_t ml;
typename view_type_if_exists_else_type<DataType>::type keeper; typename std::conditional<IsConst, typename const_view_type_if_exists_else_type<DataType>::type, typename view_type_if_exists_else_type<DataType>::type>::type keeper;
static const bool CT_need_copy = need_copy_ct<DataType,CacheType>::value; static const bool CT_need_copy = need_copy_ct<DataType,CacheType>::value;
const bool need_copy; const bool need_copy;
typedef typename CacheType::view_type exposed_view_type; typedef typename std::conditional<IsConst, typename CacheType::const_view_type, typename CacheType::view_type>::type exposed_view_type;
struct internal_data { struct internal_data {
CacheType copy; CacheType copy;
exposed_view_type view; exposed_view_type view;
internal_data(const_cache const & P,ml_t ml) : copy(CacheType(P.keeper,ml)), view(copy) { internal_data(cache_impl const & P,ml_t ml) : copy(CacheType(P.keeper,ml)), view(copy) {
#ifdef TRIQS_ARRAYS_CACHE_COPY_VERBOSE #ifdef TRIQS_ARRAYS_CACHE_COPY_VERBOSE
std::cerr<< " Cache : copy made "<< std::endl<< " -- TRACE = --" << std::endl << triqs::utility::stack_trace() << std::endl; std::cerr<< " Cache : copy made "<< std::endl<< " -- TRACE = --" << std::endl << triqs::utility::stack_trace() << std::endl;
#endif #endif
@ -68,18 +67,10 @@ namespace triqs { namespace arrays {
mutable std::shared_ptr<internal_data> _id; mutable std::shared_ptr<internal_data> _id;
internal_data & id() const { if (!_id) _id= std::make_shared<internal_data>(*this,ml); return *_id;} internal_data & id() const { if (!_id) _id= std::make_shared<internal_data>(*this,ml); return *_id;}
//exposed_view_type & view2 () { if (need_copy) return id().view; else return keeper;}
//exposed_view_type const & view2 () const { if (need_copy) return id().view; else return keeper;}
// avoid compiling the transformation keeper-> exposed_view_type when it does not make sense // avoid compiling the transformation keeper-> exposed_view_type when it does not make sense
exposed_view_type & view1 (mpl::false_) { if (need_copy) return id().view; else return keeper; } exposed_view_type view1 (mpl::false_) const { if (need_copy) return id().view; else return keeper;}
exposed_view_type const & view1 (mpl::false_) const { if (need_copy) return id().view; else return keeper;} exposed_view_type view1 (mpl::true_) const { return id().view; }
exposed_view_type view2 () const { return view1(mpl::bool_<CT_need_copy>());}
exposed_view_type & view1 (mpl::true_) { return id().view; }
exposed_view_type const & view1 (mpl::true_) const { return id().view; }
exposed_view_type & view2 () { return view1(mpl::bool_<CT_need_copy>());}
exposed_view_type const & view2 () const { return view1(mpl::bool_<CT_need_copy>());}
template<typename D> template<typename D>
typename std::enable_if< ! is_amv_value_or_view_class<D>::value, bool>::type typename std::enable_if< ! is_amv_value_or_view_class<D>::value, bool>::type
@ -90,27 +81,31 @@ namespace triqs { namespace arrays {
need_copy_dynamic ( D const & x) const { return (x.indexmap().memory_indices_layout() != ml );} need_copy_dynamic ( D const & x) const { return (x.indexmap().memory_indices_layout() != ml );}
public : public :
const_cache (DataType const & x, ml_t ml_ = ml_t()): cache_impl (DataType const & x, ml_t ml_ = ml_t()):
ml(ml_),keeper (x), ml(ml_),keeper (x),
need_copy ( CT_need_copy || need_copy_dynamic(x) || (!has_contiguous_data(x)) ) {} need_copy ( CT_need_copy || need_copy_dynamic(x) || (!has_contiguous_data(x)) ) {}
void update() { if (need_copy && _id) id().view = keeper;} void update() { if (need_copy && _id) id().view = keeper;}
exposed_view_type const & view () const { return view2();} exposed_view_type view () const { return view2();}
operator exposed_view_type const & () const { return view2();} operator exposed_view_type () const { return view2();}
};
// Const case : just add the back copy in the destructor
template<typename DataType, typename CacheType> class const_cache : public cache_impl<DataType,CacheType,true> {
typedef cache_impl<DataType,CacheType,true> B;
typedef typename B::ml_t ml_t;
public :
const_cache (DataType const & x, ml_t ml = ml_t() ): B(x,ml) {}
}; };
// Non const case : just add the back copy in the destructor // Non const case : just add the back copy in the destructor
template<typename DataType, typename CacheType> class cache : const_cache<DataType,CacheType> { template<typename DataType, typename CacheType> class cache : public cache_impl<DataType,CacheType,false> {
static_assert( is_amv_value_or_view_class<DataType>::value, "non const cache only for regular classes and views, not expressions"); static_assert( is_amv_value_or_view_class<DataType>::value, "non const cache only for regular classes and views, not expressions");
typedef const_cache<DataType,CacheType> B; typedef cache_impl<DataType,CacheType,false> B;
typedef typename B::ml_t ml_t; typedef typename B::ml_t ml_t;
public : public :
cache (DataType const & x, ml_t ml = ml_t() ): B(x,ml) {} cache (DataType const & x, ml_t ml = ml_t() ): B(x,ml) {}
~cache() { back_update(); } ~cache() { back_update(); }
void back_update() { if (this->need_copy) this->keeper = this->id().view;} void back_update() { if (this->need_copy) this->keeper = this->id().view;}
typename B::exposed_view_type & view () {return B::view2();}
typename B::exposed_view_type const & view () const {return B::view2();}
operator typename B::exposed_view_type & () {return B::view2();}
operator typename B::exposed_view_type const & () const {return B::view2();}
}; };
}}//namespace triqs::arrays }}//namespace triqs::arrays
#endif #endif

18
triqs/arrays/h5/simple_read_write.hpp
View File

@ -28,6 +28,7 @@
namespace triqs { namespace arrays { namespace triqs { namespace arrays {
namespace h5_impl { namespace h5_impl {
template <typename T, int R> const void * get_array_data_cptr ( array_const_view<T,R> const & A) { return h5::get_data_ptr(&(A.storage()[0]));}
template <typename T, int R> const void * get_array_data_cptr ( array_view<T,R> const & A) { return h5::get_data_ptr(&(A.storage()[0]));} template <typename T, int R> const void * get_array_data_cptr ( array_view<T,R> const & A) { return h5::get_data_ptr(&(A.storage()[0]));}
template <typename T, int R> const void * get_array_data_cptr ( array<T,R> const & A) { return h5::get_data_ptr(&(A.storage()[0]));} template <typename T, int R> const void * get_array_data_cptr ( array<T,R> const & A) { return h5::get_data_ptr(&(A.storage()[0]));}
//template <typename T, int R> void * get_array_data_ptr ( array_view<T,R> & A) { return h5::get_data_ptr(&(A.storage()[0]));} //template <typename T, int R> void * get_array_data_ptr ( array_view<T,R> & A) { return h5::get_data_ptr(&(A.storage()[0]));}
@ -76,7 +77,7 @@ namespace triqs { namespace arrays {
* \exception The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with a full stackstrace, cf triqs doc). * \exception The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with a full stackstrace, cf triqs doc).
*/ */
template <typename T, int R> template <typename T, int R>
void write_array (h5::group g, std::string const & name, array_view <T,R> const & A, bool C_reorder = true) { void write_array (h5::group g, std::string const & name, array_const_view <T,R> const & A, bool C_reorder = true) {
static_assert( !std::is_base_of<std::string, T>::value, " Not implemented");// 1d is below static_assert( !std::is_base_of<std::string, T>::value, " Not implemented");// 1d is below
if (C_reorder) { write_array(g,name, make_const_cache(A).view(),false); return; } if (C_reorder) { write_array(g,name, make_const_cache(A).view(),false); return; }
try { try {
@ -90,6 +91,8 @@ namespace triqs { namespace arrays {
template <typename T, int R> template <typename T, int R>
void write_array (h5::group g, std::string const & name, array <T,R> const & A, bool C_reorder = true) { write_array(g,name,A(),C_reorder);} void write_array (h5::group g, std::string const & name, array <T,R> const & A, bool C_reorder = true) { write_array(g,name,A(),C_reorder);}
template <typename T, int R>
void write_array (h5::group g, std::string const & name, array_view <T,R> const & A, bool C_reorder = true) { write_array(g,name,A(),C_reorder);}
/*********************************** READ array ****************************************************************/ /*********************************** READ array ****************************************************************/
/** /**
@ -102,8 +105,9 @@ namespace triqs { namespace arrays {
* cache of the data to reorder them in memory. If false, the array is stored as it [if you know what you are doing] * cache of the data to reorder them in memory. If false, the array is stored as it [if you know what you are doing]
* \exception The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with a full stackstrace, cf triqs doc). * \exception The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with a full stackstrace, cf triqs doc).
*/ */
template <typename ArrayType> template <typename ArrayType1>
void read_array (h5::group g, std::string const & name, ArrayType & A, bool C_reorder = true) { void read_array (h5::group g, std::string const & name, ArrayType1 && A, bool C_reorder = true) {
typedef typename std::remove_reference<ArrayType1>::type ArrayType;
static_assert( !std::is_base_of<std::string, typename ArrayType::value_type>::value, " Not implemented");// 1d is below static_assert( !std::is_base_of<std::string, typename ArrayType::value_type>::value, " Not implemented");// 1d is below
typedef typename ArrayType::value_type V; typedef typename ArrayType::value_type V;
try { try {
@ -127,12 +131,12 @@ namespace triqs { namespace arrays {
} }
// overload : special treatment for arrays of strings (one dimension only). // overload : special treatment for arrays of strings (one dimension only).
inline void write_array (h5::group f, std::string const & name, vector_view<std::string> const & V) { inline void write_array (h5::group f, std::string const & name, vector_const_view<std::string> V) {
h5::detail::write_1darray_vector_of_string_impl(f,name,V); h5::detail::write_1darray_vector_of_string_impl(f,name,V);
} }
inline void write_array (h5::group f, std::string const & name, array_view<std::string,1> const & V) { inline void write_array (h5::group f, std::string const & name, array_const_view<std::string,1> V) {
write_array(f,name,vector_view<std::string>(V)); write_array(f,name,vector_const_view<std::string>(V));
} }
inline void read_array (h5::group f, std::string const & name, arrays::vector<std::string> & V) { inline void read_array (h5::group f, std::string const & name, arrays::vector<std::string> & V) {
@ -187,7 +191,7 @@ namespace triqs { namespace arrays {
template <typename ArrayType> template <typename ArrayType>
//ENABLE_IF(is_amv_value_or_view_class<ArrayType>) //ENABLE_IF(is_amv_value_or_view_class<ArrayType>)
ENABLE_IFC(is_amv_value_or_view_class<ArrayType>::value && has_scalar_or_string_value_type<ArrayType>::value) ENABLE_IFC(is_amv_value_or_view_class<ArrayType>::value && has_scalar_or_string_value_type<ArrayType>::value)
h5_write (h5::group fg, std::string const & name, ArrayType const & A) { h5_impl::write_array(fg,name, array_view<typename ArrayType::value_type, ArrayType::rank>(A));} h5_write (h5::group fg, std::string const & name, ArrayType const & A) { h5_impl::write_array(fg,name, array_const_view<typename ArrayType::value_type, ArrayType::rank>(A));}
}} }}
#endif #endif

3
triqs/arrays/impl/flags.hpp
View File

@ -36,7 +36,6 @@ namespace triqs { namespace arrays {
// 3 -> Init the array // 3 -> Init the array
// 5 -> Boundcheck // 5 -> Boundcheck
constexpr ull_t ConstView = 1ull << 0;
constexpr ull_t TraversalOrderC = 1ull << 1; constexpr ull_t TraversalOrderC = 1ull << 1;
constexpr ull_t TraversalOrderFortran = 1ull << 2; constexpr ull_t TraversalOrderFortran = 1ull << 2;
constexpr ull_t DefaultInit = 1ull << 3; constexpr ull_t DefaultInit = 1ull << 3;
@ -55,8 +54,6 @@ namespace triqs { namespace arrays {
constexpr ull_t get(ull_t f, ull_t a) { return ((f & (1ull<<a)) >> a);} constexpr ull_t get(ull_t f, ull_t a) { return ((f & (1ull<<a)) >> a);}
constexpr ull_t get2(ull_t f, ull_t a) { return ((f & ((1ull<<a) + (1ull<< (a+1ull)))) >> a);} constexpr ull_t get2(ull_t f, ull_t a) { return ((f & ((1ull<<a) + (1ull<< (a+1ull)))) >> a);}
constexpr bool is_const (ull_t f) { return get (f,0) !=0;}
#ifdef TRIQS_ARRAYS_ENFORCE_BOUNDCHECK #ifdef TRIQS_ARRAYS_ENFORCE_BOUNDCHECK
constexpr bool bound_check (ull_t f) { return true;} constexpr bool bound_check (ull_t f) { return true;}
#else #else

28
triqs/arrays/impl/indexmap_storage_pair.hpp
View File

@ -50,9 +50,9 @@ namespace triqs { namespace arrays {
template <bool Const, typename IndexMapIterator, typename StorageType > class iterator_adapter; template <bool Const, typename IndexMapIterator, typename StorageType > class iterator_adapter;
template <class V, int R, ull_t OptionFlags, ull_t TraversalOrder, class ViewTag, bool Borrowed > struct ISPViewType; template <class V, int R, ull_t OptionFlags, ull_t TraversalOrder, class ViewTag, bool Borrowed, bool IsConst> struct ISPViewType;
template <typename IndexMapType, typename StorageType, ull_t OptionFlags, ull_t TraversalOrder, typename ViewTag > template <typename IndexMapType, typename StorageType, ull_t OptionFlags, ull_t TraversalOrder, bool IsConst, typename ViewTag>
class indexmap_storage_pair : Tag::indexmap_storage_pair, TRIQS_CONCEPT_TAG_NAME(MutableCuboidArray) { class indexmap_storage_pair : Tag::indexmap_storage_pair, TRIQS_CONCEPT_TAG_NAME(MutableCuboidArray) {
public : public :
@ -64,6 +64,7 @@ namespace triqs { namespace arrays {
static constexpr unsigned int rank = IndexMapType::domain_type::rank; static constexpr unsigned int rank = IndexMapType::domain_type::rank;
static constexpr ull_t opt_flags = OptionFlags; static constexpr ull_t opt_flags = OptionFlags;
static constexpr ull_t traversal_order = TraversalOrder; static constexpr ull_t traversal_order = TraversalOrder;
static constexpr bool is_const = IsConst;
protected: protected:
@ -170,13 +171,13 @@ namespace triqs { namespace arrays {
// ------------------------------- operator () -------------------------------------------- // ------------------------------- operator () --------------------------------------------
typedef typename ISPViewType<value_type,domain_type::rank, OptionFlags, TraversalOrder, ViewTag,false >::type view_type; typedef typename ISPViewType<value_type,domain_type::rank, OptionFlags, TraversalOrder, ViewTag,false, IsConst >::type view_type;
typedef typename ISPViewType<value_type,domain_type::rank, OptionFlags, TraversalOrder, ViewTag,true >::type weak_view_type; typedef typename ISPViewType<value_type,domain_type::rank, OptionFlags, TraversalOrder, ViewTag,true , IsConst>::type weak_view_type;
// Evaluation and slices // Evaluation and slices
template<typename... Args> template<typename... Args>
typename std::enable_if< typename std::enable_if<
(!clef::is_any_lazy<Args...>::value) && (indexmaps::slicer<indexmap_type,Args...>::r_type::domain_type::rank==0) && !flags::is_const(OptionFlags) (!clef::is_any_lazy<Args...>::value) && (indexmaps::slicer<indexmap_type,Args...>::r_type::domain_type::rank==0) && (!IsConst)
, value_type &>::type , value_type &>::type
operator()(Args const & ... args) { return storage_[indexmap_(args...)]; } operator()(Args const & ... args) { return storage_[indexmap_(args...)]; }
@ -191,17 +192,18 @@ namespace triqs { namespace arrays {
//typedef typename std::conditional<is_const, typename std::add_const<value_type>::type, value_type>::type V2; //typedef typename std::conditional<is_const, typename std::add_const<value_type>::type, value_type>::type V2;
typedef value_type V2; typedef value_type V2;
static_assert(IM2::domain_type::rank !=0, "Internal error"); static_assert(IM2::domain_type::rank !=0, "Internal error");
static constexpr ull_t optmodif = (is_const ? ConstView : 0ull); typedef typename ISPViewType<V2,IM2::domain_type::rank, OptionFlags, IM2::traversal_order_in_template, ViewTag, ForceBorrowed || StorageType::is_weak, is_const >::type type;
typedef typename ISPViewType<V2,IM2::domain_type::rank, OptionFlags|optmodif, IM2::traversal_order_in_template, ViewTag, ForceBorrowed || StorageType::is_weak >::type type;
}; };
// simplify this ?
#ifndef TRIQS_ARRAYS_SLICE_DEFAUT_IS_SHARED #ifndef TRIQS_ARRAYS_SLICE_DEFAUT_IS_SHARED
template<typename... Args> // non const version template<typename... Args> // non const version
typename boost::lazy_enable_if_c< typename boost::lazy_enable_if_c<
(!clef::is_any_lazy<Args...>::value) && (indexmaps::slicer<indexmap_type,Args...>::r_type::domain_type::rank!=0) && !flags::is_const(OptionFlags) (!clef::is_any_lazy<Args...>::value) && (indexmaps::slicer<indexmap_type,Args...>::r_type::domain_type::rank!=0) && (!IsConst)
, result_of_call_as_view<false,true,Args...> , result_of_call_as_view<false,true,Args...>
>::type // enable_if >::type // enable_if
operator()(Args const & ... args) & { operator()(Args const & ... args) & {
// simplify
return typename result_of_call_as_view<false,true,Args...>::type ( indexmaps::slicer<indexmap_type,Args...>::invoke(indexmap_,args...), storage()); } return typename result_of_call_as_view<false,true,Args...>::type ( indexmaps::slicer<indexmap_type,Args...>::invoke(indexmap_,args...), storage()); }
template<typename... Args> // const version template<typename... Args> // const version
@ -215,21 +217,21 @@ namespace triqs { namespace arrays {
template<typename... Args> // rvalue version : same value of weak as this template<typename... Args> // rvalue version : same value of weak as this
typename boost::lazy_enable_if_c< typename boost::lazy_enable_if_c<
(!clef::is_any_lazy<Args...>::value) && (indexmaps::slicer<indexmap_type,Args...>::r_type::domain_type::rank!=0) (!clef::is_any_lazy<Args...>::value) && (indexmaps::slicer<indexmap_type,Args...>::r_type::domain_type::rank!=0)
, result_of_call_as_view<true,false,Args...> , result_of_call_as_view<false,false,Args...>
>::type // enable_if >::type // enable_if
operator()(Args const & ... args) && { operator()(Args const & ... args) && {
//std::cerr << "slicing a temporary"<< this->storage().is_weak<< result_of_call_as_view<true,true,Args...>::type::storage_type::is_weak << std::endl; //std::cerr << "slicing a temporary"<< this->storage().is_weak<< result_of_call_as_view<true,true,Args...>::type::storage_type::is_weak << std::endl;
return typename result_of_call_as_view<true,false,Args...>::type ( indexmaps::slicer<indexmap_type,Args...>::invoke(indexmap_,args...), std::move(storage())); return typename result_of_call_as_view<false,false,Args...>::type ( indexmaps::slicer<indexmap_type,Args...>::invoke(indexmap_,args...), std::move(storage()));
} }
/// Equivalent to make_view /// Equivalent to make_view
typename ISPViewType<value_type,domain_type::rank, OptionFlags | ConstView, TraversalOrder, ViewTag, true >::type typename ISPViewType<value_type,domain_type::rank, OptionFlags, TraversalOrder, ViewTag, true, true >::type
operator()() const & { return *this; } operator()() const & { return *this; }
typename ISPViewType<value_type,domain_type::rank, OptionFlags, TraversalOrder, ViewTag, true >::type typename ISPViewType<value_type,domain_type::rank, OptionFlags, TraversalOrder, ViewTag, true, IsConst >::type
operator()() & { return *this; } operator()() & { return *this; }
typename ISPViewType<value_type,domain_type::rank, OptionFlags, TraversalOrder, ViewTag, StorageType::is_weak >::type typename ISPViewType<value_type,domain_type::rank, OptionFlags, TraversalOrder, ViewTag, StorageType::is_weak,IsConst >::type
operator()() && { return *this; } operator()() && { return *this; }
// Interaction with the CLEF library : calling with any clef expression as argument build a new clef expression // Interaction with the CLEF library : calling with any clef expression as argument build a new clef expression

24
triqs/arrays/matrix.hpp
View File

@ -27,7 +27,7 @@
#include "vector.hpp" #include "vector.hpp"
namespace triqs { namespace arrays { namespace triqs { namespace arrays {
template <typename ValueType, ull_t Opt=0, ull_t TraversalOrder= 0, bool Borrowed = false> class matrix_view; template <typename ValueType, ull_t Opt=0, ull_t TraversalOrder= 0, bool Borrowed = false, bool IsConst=false> class matrix_view;
template <typename ValueType, ull_t Opt=0, ull_t TraversalOrder= 0> class matrix; template <typename ValueType, ull_t Opt=0, ull_t TraversalOrder= 0> class matrix;
// ---------------------- matrix -------------------------------- // ---------------------- matrix --------------------------------
@ -44,13 +44,14 @@ namespace triqs { namespace arrays {
bool memory_layout_is_fortran() const { return this->indexmap().strides()[0] < this->indexmap().strides()[1]; } bool memory_layout_is_fortran() const { return this->indexmap().strides()[0] < this->indexmap().strides()[1]; }
#define IMPL_TYPE indexmap_storage_pair < indexmaps::cuboid::map<2,Opt,TraversalOrder>, \ #define IMPL_TYPE indexmap_storage_pair < indexmaps::cuboid::map<2,Opt,TraversalOrder>, \
storages::shared_block<ValueType,Borrowed>, Opt, TraversalOrder, Tag::matrix_view > storages::shared_block<ValueType,Borrowed>, Opt, TraversalOrder, IsConst, Tag::matrix_view >
template <typename ValueType, ull_t Opt, ull_t TraversalOrder, bool Borrowed> template <typename ValueType, ull_t Opt, ull_t TraversalOrder, bool Borrowed, bool IsConst>
class matrix_view : Tag::matrix_view, TRIQS_CONCEPT_TAG_NAME(MutableMatrix), public IMPL_TYPE { class matrix_view : Tag::matrix_view, TRIQS_CONCEPT_TAG_NAME(MutableMatrix), public IMPL_TYPE {
public : public :
typedef matrix <ValueType,Opt,TraversalOrder> regular_type; typedef matrix <ValueType,Opt,TraversalOrder> regular_type;
typedef matrix_view<ValueType,Opt,TraversalOrder> view_type; typedef matrix_view<ValueType,Opt,TraversalOrder> view_type;
typedef matrix_view<ValueType, Opt, TraversalOrder, false, true> const_view_type;
typedef matrix_view<ValueType,Opt,TraversalOrder,true> weak_view_type; typedef matrix_view<ValueType,Opt,TraversalOrder,true> weak_view_type;
typedef typename IMPL_TYPE::indexmap_type indexmap_type; typedef typename IMPL_TYPE::indexmap_type indexmap_type;
@ -94,15 +95,19 @@ namespace triqs { namespace arrays {
//--------------------------------------------------------------------- //---------------------------------------------------------------------
// this traits is used by indexmap_storage_pair, when slicing to find the correct view type. // this traits is used by indexmap_storage_pair, when slicing to find the correct view type.
template < class V, int R, ull_t OptionFlags, ull_t To, bool Borrowed > template < class V, int R, ull_t OptionFlags, ull_t To, bool Borrowed, bool IsConst>
struct ISPViewType< V, R, OptionFlags, To, Tag::matrix_view, Borrowed> { struct ISPViewType< V, R, OptionFlags, To, Tag::matrix_view, Borrowed,IsConst> {
typedef typename std::conditional <R == 1, vector_view<V,OptionFlags,Borrowed >, matrix_view<V,OptionFlags, To, Borrowed > >::type type; typedef typename std::conditional<R == 1, vector_view<V, OptionFlags, Borrowed, IsConst>,
matrix_view<V, OptionFlags, To, Borrowed, IsConst>>::type type;
}; };
#undef IMPL_TYPE #undef IMPL_TYPE
template <typename ValueType, ull_t Opt = 0, ull_t TraversalOrder = 0, bool Borrowed = false>
using matrix_const_view = matrix_view<ValueType, Opt, TraversalOrder, Borrowed, true>;
// ---------------------- matrix -------------------------------- // ---------------------- matrix --------------------------------
#define IMPL_TYPE indexmap_storage_pair < indexmaps::cuboid::map<2,Opt,TraversalOrder>, \ #define IMPL_TYPE indexmap_storage_pair < indexmaps::cuboid::map<2,Opt,TraversalOrder>, \
storages::shared_block<ValueType>, Opt, TraversalOrder, Tag::matrix_view > storages::shared_block<ValueType>, Opt, TraversalOrder, false, Tag::matrix_view >
template <typename ValueType, ull_t Opt, ull_t TraversalOrder > template <typename ValueType, ull_t Opt, ull_t TraversalOrder >
class matrix: Tag::matrix, TRIQS_CONCEPT_TAG_NAME(MutableMatrix), public IMPL_TYPE { class matrix: Tag::matrix, TRIQS_CONCEPT_TAG_NAME(MutableMatrix), public IMPL_TYPE {
@ -112,6 +117,7 @@ namespace triqs { namespace arrays {
typedef typename IMPL_TYPE::indexmap_type indexmap_type; typedef typename IMPL_TYPE::indexmap_type indexmap_type;
typedef matrix <ValueType,Opt,TraversalOrder> regular_type; typedef matrix <ValueType,Opt,TraversalOrder> regular_type;
typedef matrix_view<ValueType,Opt,TraversalOrder> view_type; typedef matrix_view<ValueType,Opt,TraversalOrder> view_type;
typedef matrix_view<ValueType, Opt, TraversalOrder, false, true> const_view_type;
typedef matrix_view<ValueType,Opt,TraversalOrder,true> weak_view_type; typedef matrix_view<ValueType,Opt,TraversalOrder,true> weak_view_type;
/// Empty matrix. /// Empty matrix.
@ -215,8 +221,8 @@ namespace triqs { namespace arrays {
// The std::swap is WRONG for a view because of the copy/move semantics of view. // The std::swap is WRONG for a view because of the copy/move semantics of view.
// Use swap instead (the correct one, found by ADL). // Use swap instead (the correct one, found by ADL).
namespace std { namespace std {
template <typename V, triqs::ull_t Opt, triqs::ull_t To, bool B1, bool B2> template <typename V, triqs::ull_t Opt, triqs::ull_t To, bool B1, bool B2, bool C1, bool C2>
void swap( triqs::arrays::matrix_view<V,Opt,To,B1> & a , triqs::arrays::matrix_view<V,Opt,To,B2> & b)= delete; void swap( triqs::arrays::matrix_view<V,Opt,To,B1,C1> & a , triqs::arrays::matrix_view<V,Opt,To,B2,C2> & b)= delete;
} }
#include "./expression_template/matrix_algebra.hpp" #include "./expression_template/matrix_algebra.hpp"
#endif #endif

8
triqs/arrays/matrix_tensor_proxy.hpp
View File

@ -38,6 +38,8 @@ namespace arrays {
TRIQS_CONCEPT_TAG_NAME(ImmutableCuboidArray)>::type { TRIQS_CONCEPT_TAG_NAME(ImmutableCuboidArray)>::type {
typedef typename std::remove_reference<A>::type A_t; typedef typename std::remove_reference<A>::type A_t;
static constexpr bool is_const = true;
A a; A a;
long n; long n;
@ -45,8 +47,8 @@ namespace arrays {
typedef indexmaps::slicer<typename A_t::indexmap_type, long, ellipsis> slicer_t; typedef indexmaps::slicer<typename A_t::indexmap_type, long, ellipsis> slicer_t;
typedef typename slicer_t::r_type indexmap_type; typedef typename slicer_t::r_type indexmap_type;
typedef typename indexmap_type::domain_type domain_type; typedef typename indexmap_type::domain_type domain_type;
typedef typename std::conditional<IsMatrix, matrix_view<value_type>, typedef typename std::conditional<IsMatrix, matrix_const_view<value_type>,
array_view<value_type, domain_type::rank>>::type view_type; array_const_view<value_type, domain_type::rank>>::type view_type;
template <typename AA> const_matrix_tensor_proxy(AA &&a_, long n_) : a(std::forward<AA>(a_)), n(n_) {} template <typename AA> const_matrix_tensor_proxy(AA &&a_, long n_) : a(std::forward<AA>(a_)), n(n_) {}
@ -83,6 +85,8 @@ namespace arrays {
TRIQS_CONCEPT_TAG_NAME(MutableCuboidArray)>::type { TRIQS_CONCEPT_TAG_NAME(MutableCuboidArray)>::type {
typedef typename std::remove_reference<A>::type A_t; typedef typename std::remove_reference<A>::type A_t;
static constexpr bool is_const = false;
A a; A a;
long n; long n;

21
triqs/arrays/vector.hpp
View File

@ -29,19 +29,20 @@
namespace triqs { namespace arrays { namespace triqs { namespace arrays {
template <typename ValueType, ull_t Opt=0, bool Borrowed =false> class vector_view; template <typename ValueType, ull_t Opt=0, bool Borrowed =false, bool IsConst=false> class vector_view;
template <typename ValueType, ull_t Opt=0> class vector; template <typename ValueType, ull_t Opt=0> class vector;
// ---------------------- vector_view -------------------------------- // ---------------------- vector_view --------------------------------
#define IMPL_TYPE indexmap_storage_pair< indexmaps::cuboid::map<1,Opt,0> , storages::shared_block<ValueType,Borrowed>, Opt, 0, Tag::vector_view > #define IMPL_TYPE indexmap_storage_pair< indexmaps::cuboid::map<1,Opt,0> , storages::shared_block<ValueType,Borrowed>, Opt, 0, IsConst, Tag::vector_view >
/** */ /** */
template <typename ValueType, ull_t Opt, bool Borrowed> template <typename ValueType, ull_t Opt, bool Borrowed, bool IsConst>
class vector_view : Tag::vector_view, TRIQS_CONCEPT_TAG_NAME(MutableVector), public IMPL_TYPE { class vector_view : Tag::vector_view, TRIQS_CONCEPT_TAG_NAME(MutableVector), public IMPL_TYPE {
public : public :
typedef vector <ValueType,Opt> regular_type; typedef vector <ValueType,Opt> regular_type;
typedef vector_view<ValueType,Opt,false> view_type; typedef vector_view<ValueType,Opt,false> view_type;
typedef vector_view<ValueType, Opt, false, true> const_view_type;
typedef vector_view<ValueType,Opt,true> weak_view_type; typedef vector_view<ValueType,Opt,true> weak_view_type;
typedef typename IMPL_TYPE::indexmap_type indexmap_type; typedef typename IMPL_TYPE::indexmap_type indexmap_type;
@ -95,10 +96,14 @@ namespace triqs { namespace arrays {
}; };
#undef IMPL_TYPE #undef IMPL_TYPE
template < class V, int R, ull_t OptionFlags, ull_t To, bool Borrowed > template < class V, int R, ull_t OptionFlags, ull_t To, bool Borrowed, bool IsConst>
struct ISPViewType< V, R,OptionFlags,To, Tag::vector_view, Borrowed> { typedef vector_view<V,OptionFlags,Borrowed> type; }; struct ISPViewType< V, R,OptionFlags,To, Tag::vector_view, Borrowed, IsConst> { typedef vector_view<V,OptionFlags,Borrowed,IsConst> type; };
template <typename ValueType, ull_t Opt = 0, bool Borrowed = false>
using vector_const_view = vector_view<ValueType, Opt, Borrowed, true>;
// ---------------------- vector-------------------------------- // ---------------------- vector--------------------------------
#define IMPL_TYPE indexmap_storage_pair< indexmaps::cuboid::map<1,Opt,0> , storages::shared_block<ValueType>, Opt, 0, Tag::vector_view > #define IMPL_TYPE indexmap_storage_pair< indexmaps::cuboid::map<1,Opt,0> , storages::shared_block<ValueType>, Opt, 0, false,Tag::vector_view >
template <typename ValueType, ull_t Opt> template <typename ValueType, ull_t Opt>
class vector: Tag::vector, TRIQS_CONCEPT_TAG_NAME(MutableVector), public IMPL_TYPE { class vector: Tag::vector, TRIQS_CONCEPT_TAG_NAME(MutableVector), public IMPL_TYPE {
@ -108,6 +113,7 @@ namespace triqs { namespace arrays {
typedef typename IMPL_TYPE::indexmap_type indexmap_type; typedef typename IMPL_TYPE::indexmap_type indexmap_type;
typedef vector<ValueType, Opt> regular_type; typedef vector<ValueType, Opt> regular_type;
typedef vector_view<ValueType, Opt> view_type; typedef vector_view<ValueType, Opt> view_type;
typedef vector_view<ValueType, Opt, false, true> const_view_type;
typedef vector_view<ValueType, Opt, true> weak_view_type; typedef vector_view<ValueType, Opt, true> weak_view_type;
/// Empty vector. /// Empty vector.
@ -293,7 +299,8 @@ namespace triqs { namespace arrays {
// The std::swap is WRONG for a view because of the copy/move semantics of view. // The std::swap is WRONG for a view because of the copy/move semantics of view.
// Use swap instead (the correct one, found by ADL). // Use swap instead (the correct one, found by ADL).
namespace std { namespace std {
template <typename V, triqs::ull_t S, bool B1, bool B2> void swap( triqs::arrays::vector_view<V,S,B1> & a , triqs::arrays::vector_view<V,S,B2> & b)= delete; template <typename V, triqs::ull_t S, bool B1, bool B2, bool C1, bool C2>
void swap(triqs::arrays::vector_view<V, S, B1, C1>& a, triqs::arrays::vector_view<V, S, B2,C2>& b) = delete;
} }
#include "./expression_template/vector_algebra.hpp" #include "./expression_template/vector_algebra.hpp"

12
triqs/gfs/gf.hpp
View File

@ -479,16 +479,16 @@ namespace triqs { namespace gfs {
// ---------------------------------- slicing ------------------------------------ // ---------------------------------- slicing ------------------------------------
//slice //slice
template<typename Variable, typename Target, typename Opt, bool V, typename... Args> template<typename Variable, typename Target, typename Opt, typename... Args>
gf_view<Variable,matrix_valued,Opt> slice_target (gf_impl<Variable,Target,Opt,V> const & g, Args&& ... args) { gf_view<Variable,matrix_valued,Opt> slice_target (gf_view<Variable,Target,Opt> g, Args&& ... args) {
static_assert(std::is_same<Target,matrix_valued>::value, "slice_target only for matrix_valued GF's"); static_assert(std::is_same<Target,matrix_valued>::value, "slice_target only for matrix_valued GF's");
using arrays::range; using arrays::range;
//auto sg=slice_target (g.singularity(),range(args,args+1)...); //auto sg=slice_target (g.singularity(),range(args,args+1)...);
return gf_view<Variable,matrix_valued,Opt>(g.mesh(), g.data()(range(), std::forward<Args>(args)... ), slice_target (g.singularity(), std::forward<Args>(args)...) , g.symmetry()); return gf_view<Variable,matrix_valued,Opt>(g.mesh(), g.data()(range(), std::forward<Args>(args)... ), slice_target (g.singularity(), std::forward<Args>(args)...) , g.symmetry());
} }
template<typename Variable, typename Target, typename Opt, bool V, typename... Args> template<typename Variable, typename Target, typename Opt, typename... Args>
gf_view<Variable,scalar_valued,Opt> slice_target_to_scalar (gf_impl<Variable,Target,Opt,V> const & g, Args&& ... args) { gf_view<Variable,scalar_valued,Opt> slice_target_to_scalar (gf_view<Variable,Target,Opt> g, Args&& ... args) {
static_assert(std::is_same<Target,matrix_valued>::value, "slice_target only for matrix_valued GF's"); static_assert(std::is_same<Target,matrix_valued>::value, "slice_target only for matrix_valued GF's");
using arrays::range; using arrays::range;
auto sg=slice_target (g.singularity(),range(args,args+1)...); auto sg=slice_target (g.singularity(),range(args,args+1)...);
@ -496,8 +496,8 @@ namespace triqs { namespace gfs {
} }
// a scalar_valued gf can be viewed as a 1x1 matrix // a scalar_valued gf can be viewed as a 1x1 matrix
template<typename Variable, typename Opt, bool V, typename... Args> template<typename Variable, typename Opt, typename... Args>
gf_view<Variable,matrix_valued,Opt> reinterpret_scalar_valued_gf_as_matrix_valued (gf_impl<Variable,scalar_valued,Opt,V> const & g) { gf_view<Variable,matrix_valued,Opt> reinterpret_scalar_valued_gf_as_matrix_valued (gf_view<Variable,scalar_valued,Opt> g) {
typedef typename gf_view<Variable,matrix_valued,Opt>::data_view_t a_t; typedef typename gf_view<Variable,matrix_valued,Opt>::data_view_t a_t;
auto a = a_t {typename a_t::indexmap_type (join(g.data().shape(),make_shape(1,1))), g.data().storage()}; auto a = a_t {typename a_t::indexmap_type (join(g.data().shape(),make_shape(1,1))), g.data().storage()};
return gf_view<Variable,matrix_valued,Opt>(g.mesh(), a, g.singularity(), g.symmetry()); return gf_view<Variable,matrix_valued,Opt>(g.mesh(), a, g.singularity(), g.symmetry());

3
triqs/gfs/local/tail.hpp
View File

@ -266,7 +266,8 @@ namespace triqs { namespace gfs { namespace local {
} }
/// Slice in orbital space /// Slice in orbital space
template<bool V> tail_view slice_target(tail_impl<V> const & t, tqa::range R1, tqa::range R2) { //template<bool V> tail_view slice_target(tail_impl<V> const & t, tqa::range R1, tqa::range R2) {
inline tail_view slice_target(tail_view t, tqa::range R1, tqa::range R2) {
return tail_view(t.data()(tqa::range(),R1,R2), t.mask_view()(R1,R2), t.order_min()); return tail_view(t.data()(tqa::range(),R1,R2), t.mask_view()(R1,R2), t.order_min());
} }

2
triqs/gfs/meshes/product.hpp
View File

@ -54,6 +54,8 @@ namespace triqs { namespace gfs {
// index[0] + component[0].size * (index[1] + component[1].size* (index[2] + ....)) // index[0] + component[0].size * (index[1] + component[1].size* (index[2] + ....))
struct _aux2 { template<typename I, typename M> size_t operator()(M const & m, I const & i,size_t R) {return m.index_to_linear(i) + R * m.size();}}; struct _aux2 { template<typename I, typename M> size_t operator()(M const & m, I const & i,size_t R) {return m.index_to_linear(i) + R * m.size();}};
size_t index_to_linear(index_t const & ii) const { return triqs::tuple::fold_on_zip(_aux2(), reverse(m_tuple), reverse(ii), size_t(0)); } size_t index_to_linear(index_t const & ii) const { return triqs::tuple::fold_on_zip(_aux2(), reverse(m_tuple), reverse(ii), size_t(0)); }
// size_t index_to_linear(index_t const & ii) const { return triqs::tuple::fold_on_zip([](auto const &m, auto const &i, auto R){return m.index_to_linear(i) + R * m.size();} , m_tuple, ii, size_t(0)); }
// Same but a tuple of mesh_point_t // Same but a tuple of mesh_point_t
struct _aux3 { template<typename P, typename M> size_t operator()(M const & m, P const & p,size_t R) {return p.linear_index() + R * m.size();}}; struct _aux3 { template<typename P, typename M> size_t operator()(M const & m, P const & p,size_t R) {return p.linear_index() + R * m.size();}};

2
triqs/utility/factory.hpp
View File

@ -50,7 +50,7 @@ namespace triqs { namespace utility {
} }
template <typename VectorType> template <typename VectorType>
static TYPE_ENABLE_IF(R,ImmutableStdVector<VectorType>) invoke( VectorType const & v) { static TYPE_ENABLE_IF(R,ImmutableStdVector<VectorType>) invoke( VectorType & v) {
static_assert(std::is_constructible<T,decltype(v[0])>::value, "Can not make std::vector<T> from the proposed type"); static_assert(std::is_constructible<T,decltype(v[0])>::value, "Can not make std::vector<T> from the proposed type");
R r; r.reserve(v.size()); R r; r.reserve(v.size());
for(size_t i=0; i<v.size(); ++i) r.push_back(T(v[i])); for(size_t i=0; i<v.size(); ++i) r.push_back(T(v[i]));

2
triqs/utility/view_tools.hpp
View File

@ -38,7 +38,7 @@ namespace triqs {
template<typename T, bool HasView = has_view<T>::value> struct const_view_type_if_exists_else_type; template<typename T, bool HasView = has_view<T>::value> struct const_view_type_if_exists_else_type;
template<typename T> struct const_view_type_if_exists_else_type<T,false> {typedef T type;}; template<typename T> struct const_view_type_if_exists_else_type<T,false> {typedef T type;};
template<typename T> struct const_view_type_if_exists_else_type<T,true> {typedef const typename T::view_type type;}; template<typename T> struct const_view_type_if_exists_else_type<T,true> {typedef const typename T::const_view_type type;};
/* /*
// replacement of std::plus for views ... // replacement of std::plus for views ...