Commit 9c5d4d7e authored by Praetorius, Simon's avatar Praetorius, Simon

Merge branch 'feature/restructure_mpl' into 'develop'

split Mpl into Index, Logical, Range

See merge request spraetor/dune-amdis!94
parents 138c15d3 947d788f
Pipeline #1787 passed with stage
in 30 minutes and 56 seconds
......@@ -4,6 +4,7 @@
#include <string>
#include <utility>
#include <dune/common/hybridutilities.hh>
#include <dune/common/timer.hh>
#include <dune/typetree/childextraction.hh>
......@@ -12,7 +13,6 @@
#include <amdis/Assembler.hpp>
#include <amdis/GridFunctionOperator.hpp>
#include <amdis/GridTransferManager.hpp>
#include <amdis/common/Loops.hpp>
namespace AMDiS {
......
......@@ -7,7 +7,7 @@
#include <dune/functions/functionspacebases/pqknodalbasis.hh>
#include <dune/grid/yaspgrid.hh>
#include <amdis/common/Mpl.hpp>
#include <amdis/common/Logical.hpp>
namespace AMDiS
{
......
......@@ -4,7 +4,8 @@
#include <type_traits>
#include <utility>
#include <amdis/common/Mpl.hpp>
#include <amdis/common/Index.hpp>
#include <amdis/common/StaticSize.hpp>
#include <amdis/common/TypeTraits.hpp>
namespace AMDiS
......@@ -13,14 +14,15 @@ namespace AMDiS
{
namespace Impl_
{
template <class F, class Tuple, std::size_t... I>
constexpr decltype(auto) apply_impl(F&& f, Tuple&& t, std::index_sequence<I...>)
template <class Functor, class Tuple, std::size_t... I>
constexpr decltype(auto) apply_impl(Functor&& f, Tuple&& t, std::index_sequence<I...>)
{
return f(std::get<I>(FWD(t))...);
using std::get;
return f(get<I>(FWD(t))...);
}
template <class F, std::size_t I0, std::size_t... I>
constexpr decltype(auto) apply_indices_impl(F&& f, index_t<I0>, std::index_sequence<I...>)
template <class Functor, std::size_t I0, std::size_t... I>
constexpr decltype(auto) apply_indices_impl(Functor&& f, index_t<I0>, std::index_sequence<I...>)
{
return f(index_t<I0+I>{}...);
}
......@@ -29,25 +31,25 @@ namespace AMDiS
template <class F, class Tuple>
constexpr decltype(auto) apply(F&& f, Tuple&& t)
{
return Impl_::apply_impl(FWD(f), FWD(t),
std::make_index_sequence<std::tuple_size<std::remove_reference_t<Tuple>>::value>{});
return Impl_::apply_impl(FWD(f), FWD(t),
std::make_index_sequence<Size_v<std::remove_reference_t<Tuple>>>{});
}
template <class F, class... Args>
constexpr decltype(auto) apply_variadic(F&& f, Args&&... args)
template <class Functor, class... Args>
constexpr decltype(auto) apply_variadic(Functor&& f, Args&&... args)
{
return apply(FWD(f), std::forward_as_tuple(args...));
return apply(FWD(f), std::forward_as_tuple(args...));
}
template <class F, std::size_t N>
constexpr decltype(auto) apply_indices(F&& f, index_t<N>)
template <class Functor, std::size_t N>
constexpr decltype(auto) apply_indices(Functor&& f, index_t<N>)
{
return Impl_::apply_indices_impl(FWD(f), index_t<0>{},
std::make_index_sequence<N>{});
}
template <class F, std::size_t I0, std::size_t I1>
constexpr decltype(auto) apply_indices(F&& f, index_t<I0>, index_t<I1>)
template <class Functor, std::size_t I0, std::size_t I1>
constexpr decltype(auto) apply_indices(Functor&& f, index_t<I0>, index_t<I1>)
{
return Impl_::apply_indices_impl(FWD(f), index_t<I0>{},
std::make_index_sequence<I1-I0>{});
......
......@@ -12,12 +12,15 @@ install(FILES
FieldMatVec.hpp
FieldMatVec.inc.hpp
Filesystem.hpp
ForEach.hpp
Index.hpp
Literals.hpp
Logical.hpp
Loops.hpp
Math.hpp
Mpl.hpp
MultiTypeMatrix.hpp
MultiTypeVector.hpp
Range.hpp
StaticSize.hpp
String.hpp
Tags.hpp
......
......@@ -5,7 +5,7 @@
#include <dune/functions/common/functionconcepts.hh>
#include <amdis/common/ConceptsBase.hpp>
#include <amdis/common/Mpl.hpp>
#include <amdis/common/Logical.hpp>
#include <amdis/common/TypeTraits.hpp>
namespace AMDiS
......@@ -33,6 +33,18 @@ namespace AMDiS
struct IsSimilar<Types<A0,As...>, Types<B0,Bs...>>
: and_t<IsSimilar<A0, B0>::value, IsSimilar<Types<As...>, Types<Bs...>>::value> {};
template <class... Ts>
struct IsSame;
template <class T0, class... Ts>
struct IsSame<T0, Ts...>
: std::is_same<Types<T0,Ts...>, Types<Ts...,T0>> {};
template <>
struct IsSame<> : std::true_type {};
template <class T>
struct IsReferenceWrapper
: std::false_type {};
......@@ -71,6 +83,9 @@ namespace AMDiS
} // end namespace Definition
#endif // DOXYGEN
/// Types are the same
template <class... Ts>
constexpr bool Same = Traits::IsSame<Ts...>::value;
/// Types are the same, up to decay of qualifiers
template <class A, class B>
......
#pragma once
#include <initializer_list>
#include <amdis/common/Apply.hpp>
#include <amdis/common/Index.hpp>
#include <amdis/common/Range.hpp>
namespace AMDiS
{
namespace Tools
{
namespace Impl_
{
template <class T>
void ignored_evaluation(std::initializer_list<T>&&) { /* do nothing */ }
}
template <class Tuple, class Functor>
constexpr void for_each(Tuple&& tuple, Functor&& f)
{
#if AMDIS_HAS_CXX_FOLD_EXPRESSIONS
Tools::apply([f=std::move(f)](auto&&... t) { (f(FWD(t)),...); }, tuple);
#else
Tools::apply([f=std::move(f)](auto&&... t) {
Impl_::ignored_evaluation<int>({0, (f(FWD(t)), 0)...});
}, tuple);
#endif
}
template <std::size_t I0, std::size_t I1, class Functor>
constexpr void for_range(index_t<I0> i0, index_t<I1> i1, Functor&& f)
{
Tools::for_each(range_t<I0,I1>{}, FWD(f));
}
template <std::size_t N, class Functor>
constexpr void for_range(index_t<N>, Functor&& f)
{
Tools::for_each(range_t<0,N>{}, FWD(f));
}
template <std::size_t I0, std::size_t I1, class Functor>
constexpr void for_range(Functor&& f)
{
Tools::for_each(range_t<I0,I1>{}, FWD(f));
}
} // end namespace Tools
} // end namespace AMDiS
#pragma once
// std c++ headers
#include <tuple>
#include <type_traits>
#include <utility>
namespace AMDiS
{
// introduce some shortcuts for integral constants
// ---------------------------------------------------------------------------
/// A wrapper for int type
template <int I>
using int_t = std::integral_constant<int, I>;
/// Variable template to generate int-type
template <int I>
constexpr int_t<I> int_ = {};
/// class that represents a sequence of integers
template <int... I>
using Ints = std::integer_sequence<int, I...>;
template <std::size_t I, int... J>
auto get(Ints<J...>) { return std::get<I>(std::make_tuple(int_<J>...)); }
/// A wrapper for std::size_t type
template <std::size_t I>
using index_t = std::integral_constant<std::size_t, I>;
/// Variable template to generate std::size_t-type
template <std::size_t I>
constexpr index_t<I> index_ = {};
/// class that represents a sequence of indices
template <std::size_t... I>
using Indices = std::index_sequence<I...>;
template <std::size_t I, std::size_t... J>
auto get(Indices<J...>) { return std::get<I>(std::make_tuple(index_<J>...)); }
} // end namespace AMDiS
......@@ -7,42 +7,6 @@
namespace AMDiS
{
// introduce some shortcuts for integral constants
// ---------------------------------------------------------------------------
/// A wrapper for int type
template <int I>
using int_t = std::integral_constant<int, I>;
/// Variable template to generate int-type
template <int I>
constexpr int_t<I> int_ = {};
/// class that represents a sequence of integers
template <int... I>
using Ints = std::integer_sequence<int, I...>;
template <std::size_t I, int... J>
auto get(Ints<J...>) { return std::get<I>(std::make_tuple(int_<J>...)); }
/// A wrapper for std::size_t type
template <std::size_t I>
using index_t = std::integral_constant<std::size_t, I>;
/// Variable template to generate std::size_t-type
template <std::size_t I>
constexpr index_t<I> index_ = {};
/// class that represents a sequence of indices
template <std::size_t... I>
using Indices = std::index_sequence<I...>;
template <std::size_t I, std::size_t... J>
auto get(Indices<J...>) { return std::get<I>(std::make_tuple(index_<J>...)); }
/// A wrapper for bool types
template <bool B>
using bool_t = std::integral_constant<bool, B>;
......@@ -51,47 +15,6 @@ namespace AMDiS
template <bool B>
constexpr bool_t<B> bool_ = {};
namespace Impl
{
/// A range of indices [I,J)
template <class Int, Int I, Int J>
struct range_impl
{
using type = range_impl;
/// Return the first element in the range
static constexpr auto begin() { return std::integral_constant<Int, I>{}; }
/// Returns the element after the last element in the range
static constexpr auto end() { return std::integral_constant<Int, J>{}; }
/// Returns the ith index in the range as integral constant
template <std::size_t i>
constexpr auto operator[](index_t<i>) const
{
return std::integral_constant<Int, I+Int(i)>{};
}
/// Return whether the range is empty
static constexpr bool empty() { return I >= J; }
/// Returns the size of the range
static constexpr auto size() { return std::integral_constant<Int, J-I>{}; }
};
/// Extracts the Ith element element from the range
template <std::size_t I, class Int, Int begin, Int end>
constexpr auto get(range_impl<Int, begin, end> const& r) { return r[index_<I>]; }
} // end namespace Impl
template <std::size_t I, std::size_t J>
using range_t = Impl::range_impl<std::size_t, I, J>;
template <std::size_t I, std::size_t J>
constexpr range_t<I,J> range_ = {};
// some boolean operations
// ---------------------------------------------------------------------------
......@@ -163,17 +86,6 @@ namespace AMDiS
template <class T>
struct IsEqualImpl<T> { enum { value = true }; };
template <class... Ts>
struct IsSameImpl;
template <class T0, class... Ts>
struct IsSameImpl<T0, Ts...>
: public std::is_same<std::tuple<T0,Ts...>,
std::tuple<Ts...,T0>> {};
template <>
struct IsSameImpl<> { enum { value = true }; };
} // end namespace Impl
template <class T, T... values>
......@@ -182,7 +94,4 @@ namespace AMDiS
template <class T, class... Ts>
using is_one_of = or_t<std::is_same<T, Ts>::value...>;
template <class... Ts>
using IsSame = Impl::IsSameImpl<Ts...>;
} // end namespace AMDiS
#pragma once
#include <dune/common/hybridutilities.hh>
#include <dune/common/rangeutilities.hh>
namespace AMDiS
{
using Dune::Hybrid::forEach;
} // end namespace AMDiS
......@@ -6,10 +6,11 @@
#include <dune/common/ftraits.hh>
#include <amdis/common/Concepts.hpp>
#include <amdis/common/Loops.hpp>
#include <amdis/common/ForEach.hpp>
#include <amdis/common/Index.hpp>
#include <amdis/common/Math.hpp>
#include <amdis/common/Mpl.hpp>
#include <amdis/common/MultiTypeVector.hpp>
#include <amdis/common/Range.hpp>
#include <amdis/common/StaticSize.hpp>
#include <amdis/common/TypeTraits.hpp>
#include <amdis/typetree/MultiIndex.hpp>
......@@ -71,35 +72,35 @@ namespace AMDiS
/// Assignment of real number to all tuple elements
MultiTypeMatrix& operator=(real_type value)
{
forEach(*this, [value](auto& fv) { fv = value; });
Tools::for_each(*this, [value](auto& fv) { fv = value; });
return *this;
}
// Compound assignment operator +=
MultiTypeMatrix& operator+=(MultiTypeMatrix const& that)
{
forEach(range_<0,rows>, [&that,this](auto const _i) { (*this)[_i] += that[_i]; });
Tools::for_range<0,rows>([&that,this](auto const _i) { (*this)[_i] += that[_i]; });
return *this;
}
// Compound assignment operator -=
MultiTypeMatrix& operator-=(MultiTypeMatrix const& that)
{
forEach(range_<0,rows>, [&that,this](auto const _i) { (*this)[_i] -= that[_i]; });
Tools::for_range<0,rows>([&that,this](auto const _i) { (*this)[_i] -= that[_i]; });
return *this;
}
// Scaling of all tuple elements by a constant value
MultiTypeMatrix& operator*=(real_type value)
{
forEach(*this, [value](auto& fv) { fv *= value; });
Tools::for_each(*this, [value](auto& fv) { fv *= value; });
return *this;
}
// Scaling of all tuple elements by the inverse of a constant value
MultiTypeMatrix& operator/=(real_type value)
{
forEach(*this, [value](auto& fv) { fv /= value; });
Tools::for_each(*this, [value](auto& fv) { fv /= value; });
return *this;
}
......@@ -150,4 +151,15 @@ namespace AMDiS
}
};
namespace Impl
{
template <class... Rows>
struct RowsImpl<MultiTypeMatrix<Rows...>>
: std::integral_constant<std::size_t, sizeof...(Rows) > {};
template <class Row0, class... Rows>
struct ColsImpl<MultiTypeMatrix<Row0, Rows...>>
: SizeImpl<Row0> {};
}
} // end namespace AMDiS
......@@ -7,8 +7,9 @@
#include <dune/functions/common/indexaccess.hh>
#include <amdis/common/Concepts.hpp>
#include <amdis/common/Loops.hpp>
#include <amdis/common/Mpl.hpp>
#include <amdis/common/ForEach.hpp>
#include <amdis/common/Index.hpp>
#include <amdis/common/Range.hpp>
#include <amdis/common/StaticSize.hpp>
#include <amdis/common/TypeTraits.hpp>
......@@ -64,35 +65,35 @@ namespace AMDiS
/// Assignment of real number to all tuple elements
MultiTypeVector& operator=(real_type value)
{
forEach(*this, [value](auto& fv) { fv = value; });
Tools::for_each(*this, [value](auto& fv) { fv = value; });
return *this;
}
// Compound assignment operator +=
MultiTypeVector& operator+=(MultiTypeVector const& that)
{
forEach(range_<0,dimension>, [&that,this](auto const _i) { (*this)[_i] += that[_i]; });
Tools::for_range<0,dimension>([&that,this](auto const _i) { (*this)[_i] += that[_i]; });
return *this;
}
// Compound assignment operator -=
MultiTypeVector& operator-=(MultiTypeVector const& that)
{
forEach(range_<0,dimension>, [&that,this](auto const _i) { (*this)[_i] -= that[_i]; });
Tools::for_range<0,dimension>([&that,this](auto const _i) { (*this)[_i] -= that[_i]; });
return *this;
}
// Scaling of all tuple elements by a constant value
MultiTypeVector& operator*=(real_type value)
{
forEach(*this, [value](auto& fv) { fv *= value; });
Tools::for_each(*this, [value](auto& fv) { fv *= value; });
return *this;
}
// Scaling of all tuple elements by the inverse of a constant value
MultiTypeVector& operator/=(real_type value)
{
forEach(*this, [value](auto& fv) { fv /= value; });
Tools::for_each(*this, [value](auto& fv) { fv /= value; });
return *this;
}
......@@ -133,4 +134,11 @@ namespace AMDiS
}
};
namespace Impl
{
template <class... Ts>
struct SizeImpl<MultiTypeVector<Ts...>>
: std::integral_constant<std::size_t, sizeof...(Ts) > {};
}
} // end namespace AMDiS
#pragma once
#include <type_traits>
#include <amdis/common/Index.hpp>
#include <amdis/common/StaticSize.hpp>
namespace AMDiS
{
namespace Impl
{
/// A range of indices [I,J)
template <class Int, Int I, Int J>
struct range_impl
{
using type = range_impl;
/// Return the first element in the range
static constexpr auto begin() { return std::integral_constant<Int, I>{}; }
/// Returns the element after the last element in the range
static constexpr auto end() { return std::integral_constant<Int, J>{}; }
/// Returns the ith index in the range as integral constant
template <std::size_t i>
constexpr auto operator[](index_t<i>) const
{
return std::integral_constant<Int, I+Int(i)>{};
}
/// Return whether the range is empty
static constexpr bool empty() { return I >= J; }
/// Returns the size of the range
static constexpr auto size() { return std::integral_constant<Int, J-I>{}; }
};
/// Extracts the Ith element element from the range
template <std::size_t I, class Int, Int begin, Int end>
constexpr auto get(range_impl<Int, begin, end> const& r) { return r[index_<I>]; }
/// Return the size of the range
template <class Int, Int I, Int J>
struct SizeImpl<range_impl<Int,I,J>>
: std::integral_constant<std::size_t, std::size_t(J-I)> {};
} // end namespace Impl
template <std::size_t I, std::size_t J>
using range_t = Impl::range_impl<std::size_t, I, J>;
template <std::size_t I, std::size_t J>
constexpr range_t<I,J> range_ = {};
} // end namespace AMDiS
namespace std
{
template <class Int, Int I0, Int I1>
struct tuple_size<AMDiS::Impl::range_impl<Int,I0,I1>>
: std::integral_constant<std::size_t, std::size_t(I1-I0)> {};
template <std::size_t I, class Int, Int I0, Int I1>
struct tuple_element<I,AMDiS::Impl::range_impl<Int,I0,I1>>
{
using type = Int;
};
} // end namespace std
......@@ -4,6 +4,8 @@
#include <tuple>
#include <type_traits>
#include <amdis/common/TypeTraits.hpp>
namespace Dune
{
// forward declarations
......@@ -25,14 +27,6 @@ namespace Dune
namespace AMDiS
{
// forward declarations
template <class... Rows>
class MultiTypeMatrix;
template <class... Ts>
class MultiTypeVector;
namespace Impl
{
template <class Tuple, class = void>
......@@ -58,10 +52,6 @@ namespace AMDiS
struct SizeImpl<Dune::FieldMatrix<T,N,M>>
: std::integral_constant<std::size_t, N*M> {};
template <class... Ts>
struct SizeImpl<MultiTypeVector<Ts...>>
: std::integral_constant<std::size_t, sizeof...(Ts) > {};
template <class... Ts>
struct SizeImpl<Dune::TupleVector<Ts...>>
: std::integral_constant<std::size_t, sizeof...(Ts)> {};
......@@ -94,10 +84,6 @@ namespace AMDiS
struct RowsImpl<Dune::FieldMatrix<T,N,M>>
: std::integral_constant<std::size_t, N> {};
template <class... Rows>
struct RowsImpl<MultiTypeMatrix<Rows...>>
: std::integral_constant<std::size_t, sizeof...(Rows) > {};
template <class... Rows>
struct RowsImpl<Dune::MultiTypeBlockMatrix<Rows...>>
: std::integral_constant<std::size_t, sizeof...(Rows)> {};
......@@ -126,10 +112,6 @@ namespace AMDiS
struct ColsImpl<Dune::FieldMatrix<T,N,M>>
: std::integral_constant<std::size_t, M> {};
template <class Row0, class... Rows>
struct ColsImpl<MultiTypeMatrix<Row0, Rows...>>
: SizeImpl<Row0> {};
template <class Row0, class... Rows>
struct ColsImpl<Dune::MultiTypeBlockMatrix<Row0, Rows...>>
: SizeImpl<Row0> {};
......
......@@ -2,13 +2,6 @@
#include <memory>
#include <type_traits>
#include <vector>
#if AMDIS_HAS_CXX_CONSTEXPR_IF
#define IF_CONSTEXPR if constexpr
#else
#define IF_CONSTEXPR if
#endif
namespace AMDiS
{
......
......@@ -6,8 +6,8 @@
#include <dune/common/std/apply.hh>
#include <amdis/Operations.hpp>
#include <amdis/common/Loops.hpp>
#include <amdis/common/Mpl.hpp>
#include <amdis/common/ForEach.hpp>
#include <amdis/common/Logical.hpp>
#include <amdis/gridfunctions/GridFunctionConcepts.hpp>
namespace AMDiS
......@@ -74,7 +74,7 @@ namespace AMDiS
template <class Element>
void bind(Element const& element)
{
forEach(localFcts_, [&](auto& localFct) {
Tools::for_each(localFcts_, [&](auto& localFct) {
(*localFct).bind(element);
});
}
......@@ -82,7 +82,7 @@ namespace AMDiS
/// Calls \ref unbind for all localFunctions
void unbind()
{
forEach(localFcts_, [&](auto& localFct) {
Tools::for_each(localFcts_, [&](auto& localFct) {
(*localFct).unbind();
});
}
......@@ -90,8 +90,7 @@ namespace AMDiS
/// Applies the functor \ref fct_ to the evaluated localFunctions
Range operator()(Domain const& x) const
{
using Dune::Std::apply;
return apply([&](auto&&... localFct) { return fct_((*localFct)(x)...); }, localFcts_);
return Tools::apply([&](auto&&... localFct) { return fct_((*localFct)(x)...); }, localFcts_);
}
public:
......@@ -130,8 +129,7 @@ namespace AMDiS
// d_i(f)[lgfs...] * lgfs_i
auto term_i = [&](auto const _i)
{
using Dune::Std::apply;
auto di_f = apply([&](auto const&... lgfs) {
auto di_f = Tools::apply([&](auto const&... lgfs) {
return makeFunctorGridFunction(partial(lf.fct(), _i), (*lgfs)...);
}, lf.localFcts());
......@@ -141,8 +139,7 @@ namespace AMDiS
};
// sum_i [ d_i(f)[lgfs...] * derivative(lgfs_i)
using Dune::Std::apply;
auto gridFct = apply([&](auto const... _i)
auto gridFct = Tools::apply([&](auto const... _i)
{
return makeFunctorGridFunction(Operation::Plus{}, term_i(_i)...);
}, index_seq);
......@@ -164,8 +161,7 @@ namespace AMDiS
&& all_of_v<Concepts::HasOrder<LFs>...>)>
int order(FunctorLocalFunction<Sig,F,LFs...> const& lf)
{
using Dune::Std::apply;
return apply([&lf](auto const&... lgfs) { return order(lf.fct(), order(*lgfs)...); },
return Tools::apply([&lf](auto const&... lgfs) { return order(lf.fct(), order(*lgfs)...); },
lf.localFcts());
}
......@@ -221,21 +217,18 @@ namespace AMDiS
/// Applies the functor to the evaluated gridfunctions
Range operator()(Domain const& x) const