diff options
author | Benoit Jacob <jacob.benoit.1@gmail.com> | 2010-02-18 20:44:17 -0500 |
---|---|---|
committer | Benoit Jacob <jacob.benoit.1@gmail.com> | 2010-02-18 20:44:17 -0500 |
commit | 5491531a8119223322110d18056a5a94bbbe413e (patch) | |
tree | 4dc6b967ddfcc3d5ccd7a022ccf9fa46f68c7666 /Eigen/src/Core/Stride.h | |
parent | b73e22905dd1544830b41463576d112c53fc66d9 (diff) |
add Stride.h
Diffstat (limited to 'Eigen/src/Core/Stride.h')
-rw-r--r-- | Eigen/src/Core/Stride.h | 136 |
1 files changed, 136 insertions, 0 deletions
diff --git a/Eigen/src/Core/Stride.h b/Eigen/src/Core/Stride.h new file mode 100644 index 000000000..ba0b19de3 --- /dev/null +++ b/Eigen/src/Core/Stride.h @@ -0,0 +1,136 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com> +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, 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 2 of +// the License, or (at your option) any later version. +// +// Eigen 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 Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see <http://www.gnu.org/licenses/>. + +#ifndef EIGEN_STRIDE_H +#define EIGEN_STRIDE_H + +template<int _InnerStrideAtCompileTime, int _OuterStrideAtCompileTime> +class Stride +{ + public: + + enum { + InnerStrideAtCompileTime = _InnerStrideAtCompileTime, + OuterStrideAtCompileTime = _OuterStrideAtCompileTime + }; + + Stride() + : m_inner(InnerStrideAtCompileTime), m_outer(OuterStrideAtCompileTime) + { + ei_assert(InnerStrideAtCompileTime != Dynamic && OuterStrideAtCompileTime != Dynamic); + } + + Stride(int innerStride, int outerStride) + : m_inner(innerStride), m_outer(outerStride) + { + ei_assert(innerStride>=0 && outerStride>=0); + } + + Stride(const Stride& other) + : m_inner(other.inner()), m_outer(other.outer()) + {} + + inline int inner() const { return m_inner.value(); } + inline int outer() const { return m_outer.value(); } + + template<int OtherInnerStrideAtCompileTime, int OtherOuterStrideAtCompileTime> + Stride<EIGEN_ENUM_MAX(InnerStrideAtCompileTime, OtherInnerStrideAtCompileTime), + EIGEN_ENUM_MAX(OuterStrideAtCompileTime, OtherOuterStrideAtCompileTime)> + operator|(const Stride<OtherInnerStrideAtCompileTime, OtherOuterStrideAtCompileTime>& other) + { + EIGEN_STATIC_ASSERT(!((InnerStrideAtCompileTime && OtherInnerStrideAtCompileTime) + || (OuterStrideAtCompileTime && OtherOuterStrideAtCompileTime)), + YOU_ALREADY_SPECIFIED_THIS_STRIDE) + int result_inner = InnerStrideAtCompileTime ? inner() : other.inner(); + int result_outer = OuterStrideAtCompileTime ? outer() : other.outer(); + return Stride<EIGEN_ENUM_MAX(InnerStrideAtCompileTime, OtherInnerStrideAtCompileTime), + EIGEN_ENUM_MAX(OuterStrideAtCompileTime, OtherOuterStrideAtCompileTime)> + (result_inner, result_outer); + } + protected: + ei_int_if_dynamic<InnerStrideAtCompileTime> m_inner; + ei_int_if_dynamic<OuterStrideAtCompileTime> m_outer; +}; + +template<int Value = Dynamic> +class InnerStride : public Stride<Value, 0> +{ + typedef Stride<Value,0> Base; + public: + InnerStride() : Base() {} + InnerStride(int v) : Base(v,0) {} +}; + +template<int Value = Dynamic> +class OuterStride : public Stride<0, Value> +{ + typedef Stride<0,Value> Base; + public: + OuterStride() : Base() {} + OuterStride(int v) : Base(0,v) {} +}; + +template<typename T, bool HasDirectAccess = int(ei_traits<T>::Flags)&DirectAccessBit> +struct ei_outer_stride_or_outer_size_impl +{ + static inline int value(const T& x) { return x.outerStride(); } +}; + +template<typename T> +struct ei_outer_stride_or_outer_size_impl<T, false> +{ + static inline int value(const T& x) { return x.outerSize(); } +}; + +template<typename T> +inline int ei_outer_stride_or_outer_size(const T& x) +{ + return ei_outer_stride_or_outer_size_impl<T>::value(x); +} + +template<typename T, bool HasDirectAccess = int(ei_traits<typename ei_cleantype<T>::type>::Flags)&DirectAccessBit> +struct ei_inner_stride_at_compile_time +{ + enum { ret = ei_traits<typename ei_cleantype<T>::type>::InnerStrideAtCompileTime }; +}; + +template<typename T> +struct ei_inner_stride_at_compile_time<T, false> +{ + enum { ret = 1 }; +}; + +template<typename T, bool HasDirectAccess = int(ei_traits<typename ei_cleantype<T>::type>::Flags)&DirectAccessBit> +struct ei_outer_stride_at_compile_time +{ + enum { ret = ei_traits<typename ei_cleantype<T>::type>::OuterStrideAtCompileTime }; +}; + +template<typename T> +struct ei_outer_stride_at_compile_time<T, false> +{ + enum { ret = 1 }; +}; + +#endif // EIGEN_STRIDE_H |