mirror of
https://github.com/triqs/dft_tools
synced 2024-12-24 13:23:37 +01:00
2c542647fd
- change : all objects are by default stored now by reference, not by copy any more. Unless the trait force_copy_in_expr is true. - rvalue refs are moved into the tree - simplifies a lot the writing of lazy method, objects. - added a macro for methods - tests ok. Further check needed to control absence of copies... - improved documentation
83 lines
3.8 KiB
C++
83 lines
3.8 KiB
C++
/*******************************************************************************
|
|
*
|
|
* TRIQS: a Toolbox for Research in Interacting Quantum Systems
|
|
*
|
|
* Copyright (C) 2011 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/>.
|
|
*
|
|
******************************************************************************/
|
|
#ifndef TRIQS_ARRAYS_MAKE_IMMUTABLE_ARRAY_H
|
|
#define TRIQS_ARRAYS_MAKE_IMMUTABLE_ARRAY_H
|
|
#include "./array.hpp"
|
|
#include "../utility/tuple_tools.hpp"
|
|
|
|
namespace triqs { namespace arrays {
|
|
|
|
template<typename Expr, int ... ph>
|
|
class immutable_array_expr_impl : TRIQS_CONCEPT_TAG_NAME(ImmutableArray) {
|
|
template<int I> struct _si { typedef size_t type;};
|
|
public :
|
|
immutable_array_expr_impl(Expr e_, clef::pair<ph,range> ... p):
|
|
f(clef::make_function(e_, clef::placeholder<ph>()...)), dom_(make_shape(p.rhs.size()...)) {};
|
|
typedef typename triqs::clef::result_of::make_function<Expr,clef::placeholder<ph>... >::type function_type;
|
|
typedef typename std::result_of<function_type(typename _si<ph>::type...)>::type value_type;
|
|
typedef indexmaps::cuboid::domain_t<sizeof...(ph)> domain_type;
|
|
domain_type domain() const { return dom_;}
|
|
template<typename ... Args> value_type operator() (Args const & ... args) const { return f(args...); }
|
|
friend std::ostream & operator<<(std::ostream & out, immutable_array_expr_impl const & x){return out<<" immutable_array on domain : "<<x.domain();}
|
|
protected:
|
|
function_type f;
|
|
domain_type dom_;
|
|
};
|
|
|
|
/**
|
|
* \brief Makes a lazy immutable (cuboid) array from a simple expression and a set of range...
|
|
* \param expr The lazy expression
|
|
* \param i_=R i_ is a placeholder, R a range. The i_=R produce a pair of i_ and R , which is the parameter.
|
|
* \return A lazy object implementing the ImmutableArray concept with the domain built from the ranges.
|
|
*/
|
|
template<typename Expr, int ... ph>
|
|
immutable_array_expr_impl<Expr,ph...> make_immutable_array( Expr const & expr, clef::pair<ph,range> ... p) {
|
|
return immutable_array_expr_impl<Expr,ph...> (expr, p...);
|
|
}
|
|
|
|
// if ones prefers to use a function...
|
|
|
|
template<typename Function, typename ... Ranges>
|
|
class immutable_array_fun_impl : TRIQS_CONCEPT_TAG_NAME(ImmutableArray) {
|
|
template<int I> struct _si { typedef size_t type;};
|
|
public :
|
|
immutable_array_fun_impl(Function f, Ranges ... r) : f_(std::move(f)), dom_(make_shape(r.size()...)) {};
|
|
//typedef typename std::function<Function(typename Ranges::index_type...)>::result_type value_type;
|
|
typedef decltype( triqs::tuple::apply(std::declval<Function>(),std::make_tuple(typename Ranges::index_type()...))) value_type;
|
|
typedef indexmaps::cuboid::domain_t<sizeof...(Ranges)> domain_type;
|
|
domain_type domain() const { return dom_;}
|
|
template<typename ... Args> value_type operator() (Args const & ... args) const { return f_(args...); }
|
|
friend std::ostream & operator<<(std::ostream & out, immutable_array_fun_impl const & x){return out<<" immutable_array on domain : "<<x.domain();}
|
|
protected:
|
|
Function f_;
|
|
domain_type dom_;
|
|
};
|
|
|
|
template<typename Function, typename ... Ranges>
|
|
immutable_array_fun_impl<Function,Ranges...> make_immutable_array(Function f, Ranges ... r) {
|
|
return immutable_array_fun_impl<Function,Ranges...> (std::move(f), r...);
|
|
}
|
|
|
|
|
|
}}//namespace triqs::arrays
|
|
#endif
|
|
|