packages feed

numerical-integration 0.1.0.1 → 0.1.0.2

raw patch · 10 files changed

+3456/−1 lines, 10 files

Files

+ cpp/Eigen/src/plugins/ArrayCwiseBinaryOps.h view
@@ -0,0 +1,358 @@++/** \returns an expression of the coefficient wise product of \c *this and \a other+  *+  * \sa MatrixBase::cwiseProduct+  */+template<typename OtherDerived>+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)+operator*(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const+{+  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)(derived(), other.derived());+}++/** \returns an expression of the coefficient wise quotient of \c *this and \a other+  *+  * \sa MatrixBase::cwiseQuotient+  */+template<typename OtherDerived>+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_quotient_op<Scalar,typename OtherDerived::Scalar>, const Derived, const OtherDerived>+operator/(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const+{+  return CwiseBinaryOp<internal::scalar_quotient_op<Scalar,typename OtherDerived::Scalar>, const Derived, const OtherDerived>(derived(), other.derived());+}++/** \returns an expression of the coefficient-wise min of \c *this and \a other+  *+  * Example: \include Cwise_min.cpp+  * Output: \verbinclude Cwise_min.out+  *+  * \sa max()+  */+EIGEN_MAKE_CWISE_BINARY_OP(min,min)++/** \returns an expression of the coefficient-wise min of \c *this and scalar \a other+  *+  * \sa max()+  */+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived,+                                        const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> >+#ifdef EIGEN_PARSED_BY_DOXYGEN+min+#else+(min)+#endif+(const Scalar &other) const+{+  return (min)(Derived::PlainObject::Constant(rows(), cols(), other));+}++/** \returns an expression of the coefficient-wise max of \c *this and \a other+  *+  * Example: \include Cwise_max.cpp+  * Output: \verbinclude Cwise_max.out+  *+  * \sa min()+  */+EIGEN_MAKE_CWISE_BINARY_OP(max,max)++/** \returns an expression of the coefficient-wise max of \c *this and scalar \a other+  *+  * \sa min()+  */+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived,+                                        const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> >+#ifdef EIGEN_PARSED_BY_DOXYGEN+max+#else+(max)+#endif+(const Scalar &other) const+{+  return (max)(Derived::PlainObject::Constant(rows(), cols(), other));+}++/** \returns an expression of the coefficient-wise absdiff of \c *this and \a other+  *+  * Example: \include Cwise_absolute_difference.cpp+  * Output: \verbinclude Cwise_absolute_difference.out+  *+  * \sa absolute_difference()+  */+EIGEN_MAKE_CWISE_BINARY_OP(absolute_difference,absolute_difference)++/** \returns an expression of the coefficient-wise absolute_difference of \c *this and scalar \a other+  *+  * \sa absolute_difference()+  */+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_absolute_difference_op<Scalar,Scalar>, const Derived,+                                        const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> >+#ifdef EIGEN_PARSED_BY_DOXYGEN+absolute_difference+#else+(absolute_difference)+#endif+(const Scalar &other) const+{+  return (absolute_difference)(Derived::PlainObject::Constant(rows(), cols(), other));+}++/** \returns an expression of the coefficient-wise power of \c *this to the given array of \a exponents.+  *+  * This function computes the coefficient-wise power.+  *+  * Example: \include Cwise_array_power_array.cpp+  * Output: \verbinclude Cwise_array_power_array.out+  */+EIGEN_MAKE_CWISE_BINARY_OP(pow,pow)++#ifndef EIGEN_PARSED_BY_DOXYGEN+EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(pow,pow)+#else+/** \returns an expression of the coefficients of \c *this rasied to the constant power \a exponent+  *+  * \tparam T is the scalar type of \a exponent. It must be compatible with the scalar type of the given expression.+  *+  * This function computes the coefficient-wise power. The function MatrixBase::pow() in the+  * unsupported module MatrixFunctions computes the matrix power.+  *+  * Example: \include Cwise_pow.cpp+  * Output: \verbinclude Cwise_pow.out+  *+  * \sa ArrayBase::pow(ArrayBase), square(), cube(), exp(), log()+  */+template<typename T>+const CwiseBinaryOp<internal::scalar_pow_op<Scalar,T>,Derived,Constant<T> > pow(const T& exponent) const;+#endif+++// TODO code generating macros could be moved to Macros.h and could include generation of documentation+#define EIGEN_MAKE_CWISE_COMP_OP(OP, COMPARATOR) \+template<typename OtherDerived> \+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_cmp_op<Scalar, typename OtherDerived::Scalar, internal::cmp_ ## COMPARATOR>, const Derived, const OtherDerived> \+OP(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \+{ \+  return CwiseBinaryOp<internal::scalar_cmp_op<Scalar, typename OtherDerived::Scalar, internal::cmp_ ## COMPARATOR>, const Derived, const OtherDerived>(derived(), other.derived()); \+}\+typedef CwiseBinaryOp<internal::scalar_cmp_op<Scalar,Scalar, internal::cmp_ ## COMPARATOR>, const Derived, const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> > Cmp ## COMPARATOR ## ReturnType; \+typedef CwiseBinaryOp<internal::scalar_cmp_op<Scalar,Scalar, internal::cmp_ ## COMPARATOR>, const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject>, const Derived > RCmp ## COMPARATOR ## ReturnType; \+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Cmp ## COMPARATOR ## ReturnType \+OP(const Scalar& s) const { \+  return this->OP(Derived::PlainObject::Constant(rows(), cols(), s)); \+} \+EIGEN_DEVICE_FUNC friend EIGEN_STRONG_INLINE const RCmp ## COMPARATOR ## ReturnType \+OP(const Scalar& s, const EIGEN_CURRENT_STORAGE_BASE_CLASS<Derived>& d) { \+  return Derived::PlainObject::Constant(d.rows(), d.cols(), s).OP(d); \+}++#define EIGEN_MAKE_CWISE_COMP_R_OP(OP, R_OP, RCOMPARATOR) \+template<typename OtherDerived> \+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_cmp_op<typename OtherDerived::Scalar, Scalar, internal::cmp_##RCOMPARATOR>, const OtherDerived, const Derived> \+OP(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \+{ \+  return CwiseBinaryOp<internal::scalar_cmp_op<typename OtherDerived::Scalar, Scalar, internal::cmp_##RCOMPARATOR>, const OtherDerived, const Derived>(other.derived(), derived()); \+} \+EIGEN_DEVICE_FUNC \+inline const RCmp ## RCOMPARATOR ## ReturnType \+OP(const Scalar& s) const { \+  return Derived::PlainObject::Constant(rows(), cols(), s).R_OP(*this); \+} \+friend inline const Cmp ## RCOMPARATOR ## ReturnType \+OP(const Scalar& s, const Derived& d) { \+  return d.R_OP(Derived::PlainObject::Constant(d.rows(), d.cols(), s)); \+}++++/** \returns an expression of the coefficient-wise \< operator of *this and \a other+  *+  * Example: \include Cwise_less.cpp+  * Output: \verbinclude Cwise_less.out+  *+  * \sa all(), any(), operator>(), operator<=()+  */+EIGEN_MAKE_CWISE_COMP_OP(operator<, LT)++/** \returns an expression of the coefficient-wise \<= operator of *this and \a other+  *+  * Example: \include Cwise_less_equal.cpp+  * Output: \verbinclude Cwise_less_equal.out+  *+  * \sa all(), any(), operator>=(), operator<()+  */+EIGEN_MAKE_CWISE_COMP_OP(operator<=, LE)++/** \returns an expression of the coefficient-wise \> operator of *this and \a other+  *+  * Example: \include Cwise_greater.cpp+  * Output: \verbinclude Cwise_greater.out+  *+  * \sa all(), any(), operator>=(), operator<()+  */+EIGEN_MAKE_CWISE_COMP_R_OP(operator>, operator<, LT)++/** \returns an expression of the coefficient-wise \>= operator of *this and \a other+  *+  * Example: \include Cwise_greater_equal.cpp+  * Output: \verbinclude Cwise_greater_equal.out+  *+  * \sa all(), any(), operator>(), operator<=()+  */+EIGEN_MAKE_CWISE_COMP_R_OP(operator>=, operator<=, LE)++/** \returns an expression of the coefficient-wise == operator of *this and \a other+  *+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and+  * isMuchSmallerThan().+  *+  * Example: \include Cwise_equal_equal.cpp+  * Output: \verbinclude Cwise_equal_equal.out+  *+  * \sa all(), any(), isApprox(), isMuchSmallerThan()+  */+EIGEN_MAKE_CWISE_COMP_OP(operator==, EQ)++/** \returns an expression of the coefficient-wise != operator of *this and \a other+  *+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and+  * isMuchSmallerThan().+  *+  * Example: \include Cwise_not_equal.cpp+  * Output: \verbinclude Cwise_not_equal.out+  *+  * \sa all(), any(), isApprox(), isMuchSmallerThan()+  */+EIGEN_MAKE_CWISE_COMP_OP(operator!=, NEQ)+++#undef EIGEN_MAKE_CWISE_COMP_OP+#undef EIGEN_MAKE_CWISE_COMP_R_OP++// scalar addition+#ifndef EIGEN_PARSED_BY_DOXYGEN+EIGEN_MAKE_SCALAR_BINARY_OP(operator+,sum)+#else+/** \returns an expression of \c *this with each coeff incremented by the constant \a scalar+  *+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.+  *+  * Example: \include Cwise_plus.cpp+  * Output: \verbinclude Cwise_plus.out+  *+  * \sa operator+=(), operator-()+  */+template<typename T>+const CwiseBinaryOp<internal::scalar_sum_op<Scalar,T>,Derived,Constant<T> > operator+(const T& scalar) const;+/** \returns an expression of \a expr with each coeff incremented by the constant \a scalar+  *+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.+  */+template<typename T> friend+const CwiseBinaryOp<internal::scalar_sum_op<T,Scalar>,Constant<T>,Derived> operator+(const T& scalar, const StorageBaseType& expr);+#endif++#ifndef EIGEN_PARSED_BY_DOXYGEN+EIGEN_MAKE_SCALAR_BINARY_OP(operator-,difference)+#else+/** \returns an expression of \c *this with each coeff decremented by the constant \a scalar+  *+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.+  *+  * Example: \include Cwise_minus.cpp+  * Output: \verbinclude Cwise_minus.out+  *+  * \sa operator+=(), operator-()+  */+template<typename T>+const CwiseBinaryOp<internal::scalar_difference_op<Scalar,T>,Derived,Constant<T> > operator-(const T& scalar) const;+/** \returns an expression of the constant matrix of value \a scalar decremented by the coefficients of \a expr+  *+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.+  */+template<typename T> friend+const CwiseBinaryOp<internal::scalar_difference_op<T,Scalar>,Constant<T>,Derived> operator-(const T& scalar, const StorageBaseType& expr);+#endif+++#ifndef EIGEN_PARSED_BY_DOXYGEN+  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(operator/,quotient)+#else+  /**+    * \brief Component-wise division of the scalar \a s by array elements of \a a.+    *+    * \tparam Scalar is the scalar type of \a x. It must be compatible with the scalar type of the given array expression (\c Derived::Scalar).+    */+  template<typename T> friend+  inline const CwiseBinaryOp<internal::scalar_quotient_op<T,Scalar>,Constant<T>,Derived>+  operator/(const T& s,const StorageBaseType& a);+#endif++/** \returns an expression of the coefficient-wise ^ operator of *this and \a other+ *+ * \warning this operator is for expression of bool only.+ *+ * Example: \include Cwise_boolean_xor.cpp+ * Output: \verbinclude Cwise_boolean_xor.out+ *+ * \sa operator&&(), select()+ */+template<typename OtherDerived>+EIGEN_DEVICE_FUNC+inline const CwiseBinaryOp<internal::scalar_boolean_xor_op, const Derived, const OtherDerived>+operator^(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const+{+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value && internal::is_same<bool,typename OtherDerived::Scalar>::value),+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);+  return CwiseBinaryOp<internal::scalar_boolean_xor_op, const Derived, const OtherDerived>(derived(),other.derived());+}++// NOTE disabled until we agree on argument order+#if 0+/** \cpp11 \returns an expression of the coefficient-wise polygamma function.+  *+  * \specialfunctions_module+  *+  * It returns the \a n -th derivative of the digamma(psi) evaluated at \c *this.+  *+  * \warning Be careful with the order of the parameters: x.polygamma(n) is equivalent to polygamma(n,x)+  *+  * \sa Eigen::polygamma()+  */+template<typename DerivedN>+inline const CwiseBinaryOp<internal::scalar_polygamma_op<Scalar>, const DerivedN, const Derived>+polygamma(const EIGEN_CURRENT_STORAGE_BASE_CLASS<DerivedN> &n) const+{+  return CwiseBinaryOp<internal::scalar_polygamma_op<Scalar>, const DerivedN, const Derived>(n.derived(), this->derived());+}+#endif++/** \returns an expression of the coefficient-wise zeta function.+  *+  * \specialfunctions_module+  *+  * It returns the Riemann zeta function of two arguments \c *this and \a q:+  *+  * \param q is the shift, it must be > 0+  *+  * \note *this is the exponent, it must be > 1.+  * \note This function supports only float and double scalar types. To support other scalar types, the user has+  * to provide implementations of zeta(T,T) for any scalar type T to be supported.+  *+  * This method is an alias for zeta(*this,q);+  *+  * \sa Eigen::zeta()+  */+template<typename DerivedQ>+inline const CwiseBinaryOp<internal::scalar_zeta_op<Scalar>, const Derived, const DerivedQ>+zeta(const EIGEN_CURRENT_STORAGE_BASE_CLASS<DerivedQ> &q) const+{+  return CwiseBinaryOp<internal::scalar_zeta_op<Scalar>, const Derived, const DerivedQ>(this->derived(), q.derived());+}
+ cpp/Eigen/src/plugins/ArrayCwiseUnaryOps.h view
@@ -0,0 +1,696 @@+++typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> AbsReturnType;+typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived> ArgReturnType;+typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> Abs2ReturnType;+typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> SqrtReturnType;+typedef CwiseUnaryOp<internal::scalar_rsqrt_op<Scalar>, const Derived> RsqrtReturnType;+typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived> SignReturnType;+typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> InverseReturnType;+typedef CwiseUnaryOp<internal::scalar_boolean_not_op<Scalar>, const Derived> BooleanNotReturnType;++typedef CwiseUnaryOp<internal::scalar_exp_op<Scalar>, const Derived> ExpReturnType;+typedef CwiseUnaryOp<internal::scalar_expm1_op<Scalar>, const Derived> Expm1ReturnType;+typedef CwiseUnaryOp<internal::scalar_log_op<Scalar>, const Derived> LogReturnType;+typedef CwiseUnaryOp<internal::scalar_log1p_op<Scalar>, const Derived> Log1pReturnType;+typedef CwiseUnaryOp<internal::scalar_log10_op<Scalar>, const Derived> Log10ReturnType;+typedef CwiseUnaryOp<internal::scalar_log2_op<Scalar>, const Derived> Log2ReturnType;+typedef CwiseUnaryOp<internal::scalar_cos_op<Scalar>, const Derived> CosReturnType;+typedef CwiseUnaryOp<internal::scalar_sin_op<Scalar>, const Derived> SinReturnType;+typedef CwiseUnaryOp<internal::scalar_tan_op<Scalar>, const Derived> TanReturnType;+typedef CwiseUnaryOp<internal::scalar_acos_op<Scalar>, const Derived> AcosReturnType;+typedef CwiseUnaryOp<internal::scalar_asin_op<Scalar>, const Derived> AsinReturnType;+typedef CwiseUnaryOp<internal::scalar_atan_op<Scalar>, const Derived> AtanReturnType;+typedef CwiseUnaryOp<internal::scalar_tanh_op<Scalar>, const Derived> TanhReturnType;+typedef CwiseUnaryOp<internal::scalar_logistic_op<Scalar>, const Derived> LogisticReturnType;+typedef CwiseUnaryOp<internal::scalar_sinh_op<Scalar>, const Derived> SinhReturnType;+#if EIGEN_HAS_CXX11_MATH+typedef CwiseUnaryOp<internal::scalar_atanh_op<Scalar>, const Derived> AtanhReturnType;+typedef CwiseUnaryOp<internal::scalar_asinh_op<Scalar>, const Derived> AsinhReturnType;+typedef CwiseUnaryOp<internal::scalar_acosh_op<Scalar>, const Derived> AcoshReturnType;+#endif+typedef CwiseUnaryOp<internal::scalar_cosh_op<Scalar>, const Derived> CoshReturnType;+typedef CwiseUnaryOp<internal::scalar_square_op<Scalar>, const Derived> SquareReturnType;+typedef CwiseUnaryOp<internal::scalar_cube_op<Scalar>, const Derived> CubeReturnType;+typedef CwiseUnaryOp<internal::scalar_round_op<Scalar>, const Derived> RoundReturnType;+typedef CwiseUnaryOp<internal::scalar_rint_op<Scalar>, const Derived> RintReturnType;+typedef CwiseUnaryOp<internal::scalar_floor_op<Scalar>, const Derived> FloorReturnType;+typedef CwiseUnaryOp<internal::scalar_ceil_op<Scalar>, const Derived> CeilReturnType;+typedef CwiseUnaryOp<internal::scalar_isnan_op<Scalar>, const Derived> IsNaNReturnType;+typedef CwiseUnaryOp<internal::scalar_isinf_op<Scalar>, const Derived> IsInfReturnType;+typedef CwiseUnaryOp<internal::scalar_isfinite_op<Scalar>, const Derived> IsFiniteReturnType;++/** \returns an expression of the coefficient-wise absolute value of \c *this+  *+  * Example: \include Cwise_abs.cpp+  * Output: \verbinclude Cwise_abs.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_abs">Math functions</a>, abs2()+  */+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const AbsReturnType+abs() const+{+  return AbsReturnType(derived());+}++/** \returns an expression of the coefficient-wise phase angle of \c *this+  *+  * Example: \include Cwise_arg.cpp+  * Output: \verbinclude Cwise_arg.out+  *+  * \sa abs()+  */+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const ArgReturnType+arg() const+{+  return ArgReturnType(derived());+}++/** \returns an expression of the coefficient-wise squared absolute value of \c *this+  *+  * Example: \include Cwise_abs2.cpp+  * Output: \verbinclude Cwise_abs2.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_abs2">Math functions</a>, abs(), square()+  */+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const Abs2ReturnType+abs2() const+{+  return Abs2ReturnType(derived());+}++/** \returns an expression of the coefficient-wise exponential of *this.+  *+  * This function computes the coefficient-wise exponential. The function MatrixBase::exp() in the+  * unsupported module MatrixFunctions computes the matrix exponential.+  *+  * Example: \include Cwise_exp.cpp+  * Output: \verbinclude Cwise_exp.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_exp">Math functions</a>, pow(), log(), sin(), cos()+  */+EIGEN_DEVICE_FUNC+inline const ExpReturnType+exp() const+{+  return ExpReturnType(derived());+}++/** \returns an expression of the coefficient-wise exponential of *this minus 1.+  *+  * In exact arithmetic, \c x.expm1() is equivalent to \c x.exp() - 1,+  * however, with finite precision, this function is much more accurate when \c x is close to zero.+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_expm1">Math functions</a>, exp()+  */+EIGEN_DEVICE_FUNC+inline const Expm1ReturnType+expm1() const+{+  return Expm1ReturnType(derived());+}++/** \returns an expression of the coefficient-wise logarithm of *this.+  *+  * This function computes the coefficient-wise logarithm. The function MatrixBase::log() in the+  * unsupported module MatrixFunctions computes the matrix logarithm.+  *+  * Example: \include Cwise_log.cpp+  * Output: \verbinclude Cwise_log.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log">Math functions</a>, log()+  */+EIGEN_DEVICE_FUNC+inline const LogReturnType+log() const+{+  return LogReturnType(derived());+}++/** \returns an expression of the coefficient-wise logarithm of 1 plus \c *this.+  *+  * In exact arithmetic, \c x.log() is equivalent to \c (x+1).log(),+  * however, with finite precision, this function is much more accurate when \c x is close to zero.+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log1p">Math functions</a>, log()+  */+EIGEN_DEVICE_FUNC+inline const Log1pReturnType+log1p() const+{+  return Log1pReturnType(derived());+}++/** \returns an expression of the coefficient-wise base-10 logarithm of *this.+  *+  * This function computes the coefficient-wise base-10 logarithm.+  *+  * Example: \include Cwise_log10.cpp+  * Output: \verbinclude Cwise_log10.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log10">Math functions</a>, log()+  */+EIGEN_DEVICE_FUNC+inline const Log10ReturnType+log10() const+{+  return Log10ReturnType(derived());+}++/** \returns an expression of the coefficient-wise base-2 logarithm of *this.+  *+  * This function computes the coefficient-wise base-2 logarithm.+  *+  */+EIGEN_DEVICE_FUNC+inline const Log2ReturnType+log2() const+{+  return Log2ReturnType(derived());+}++/** \returns an expression of the coefficient-wise square root of *this.+  *+  * This function computes the coefficient-wise square root. The function MatrixBase::sqrt() in the+  * unsupported module MatrixFunctions computes the matrix square root.+  *+  * Example: \include Cwise_sqrt.cpp+  * Output: \verbinclude Cwise_sqrt.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sqrt">Math functions</a>, pow(), square()+  */+EIGEN_DEVICE_FUNC+inline const SqrtReturnType+sqrt() const+{+  return SqrtReturnType(derived());+}++/** \returns an expression of the coefficient-wise inverse square root of *this.+  *+  * This function computes the coefficient-wise inverse square root.+  *+  * Example: \include Cwise_sqrt.cpp+  * Output: \verbinclude Cwise_sqrt.out+  *+  * \sa pow(), square()+  */+EIGEN_DEVICE_FUNC+inline const RsqrtReturnType+rsqrt() const+{+  return RsqrtReturnType(derived());+}++/** \returns an expression of the coefficient-wise signum of *this.+  *+  * This function computes the coefficient-wise signum.+  *+  * Example: \include Cwise_sign.cpp+  * Output: \verbinclude Cwise_sign.out+  *+  * \sa pow(), square()+  */+EIGEN_DEVICE_FUNC+inline const SignReturnType+sign() const+{+  return SignReturnType(derived());+}+++/** \returns an expression of the coefficient-wise cosine of *this.+  *+  * This function computes the coefficient-wise cosine. The function MatrixBase::cos() in the+  * unsupported module MatrixFunctions computes the matrix cosine.+  *+  * Example: \include Cwise_cos.cpp+  * Output: \verbinclude Cwise_cos.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cos">Math functions</a>, sin(), acos()+  */+EIGEN_DEVICE_FUNC+inline const CosReturnType+cos() const+{+  return CosReturnType(derived());+}+++/** \returns an expression of the coefficient-wise sine of *this.+  *+  * This function computes the coefficient-wise sine. The function MatrixBase::sin() in the+  * unsupported module MatrixFunctions computes the matrix sine.+  *+  * Example: \include Cwise_sin.cpp+  * Output: \verbinclude Cwise_sin.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sin">Math functions</a>, cos(), asin()+  */+EIGEN_DEVICE_FUNC+inline const SinReturnType+sin() const+{+  return SinReturnType(derived());+}++/** \returns an expression of the coefficient-wise tan of *this.+  *+  * Example: \include Cwise_tan.cpp+  * Output: \verbinclude Cwise_tan.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_tan">Math functions</a>, cos(), sin()+  */+EIGEN_DEVICE_FUNC+inline const TanReturnType+tan() const+{+  return TanReturnType(derived());+}++/** \returns an expression of the coefficient-wise arc tan of *this.+  *+  * Example: \include Cwise_atan.cpp+  * Output: \verbinclude Cwise_atan.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_atan">Math functions</a>, tan(), asin(), acos()+  */+EIGEN_DEVICE_FUNC+inline const AtanReturnType+atan() const+{+  return AtanReturnType(derived());+}++/** \returns an expression of the coefficient-wise arc cosine of *this.+  *+  * Example: \include Cwise_acos.cpp+  * Output: \verbinclude Cwise_acos.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_acos">Math functions</a>, cos(), asin()+  */+EIGEN_DEVICE_FUNC+inline const AcosReturnType+acos() const+{+  return AcosReturnType(derived());+}++/** \returns an expression of the coefficient-wise arc sine of *this.+  *+  * Example: \include Cwise_asin.cpp+  * Output: \verbinclude Cwise_asin.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_asin">Math functions</a>, sin(), acos()+  */+EIGEN_DEVICE_FUNC+inline const AsinReturnType+asin() const+{+  return AsinReturnType(derived());+}++/** \returns an expression of the coefficient-wise hyperbolic tan of *this.+  *+  * Example: \include Cwise_tanh.cpp+  * Output: \verbinclude Cwise_tanh.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_tanh">Math functions</a>, tan(), sinh(), cosh()+  */+EIGEN_DEVICE_FUNC+inline const TanhReturnType+tanh() const+{+  return TanhReturnType(derived());+}++/** \returns an expression of the coefficient-wise hyperbolic sin of *this.+  *+  * Example: \include Cwise_sinh.cpp+  * Output: \verbinclude Cwise_sinh.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sinh">Math functions</a>, sin(), tanh(), cosh()+  */+EIGEN_DEVICE_FUNC+inline const SinhReturnType+sinh() const+{+  return SinhReturnType(derived());+}++/** \returns an expression of the coefficient-wise hyperbolic cos of *this.+  *+  * Example: \include Cwise_cosh.cpp+  * Output: \verbinclude Cwise_cosh.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cosh">Math functions</a>, tanh(), sinh(), cosh()+  */+EIGEN_DEVICE_FUNC+inline const CoshReturnType+cosh() const+{+  return CoshReturnType(derived());+}++#if EIGEN_HAS_CXX11_MATH+/** \returns an expression of the coefficient-wise inverse hyperbolic tan of *this.+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_atanh">Math functions</a>, atanh(), asinh(), acosh()+  */+EIGEN_DEVICE_FUNC+inline const AtanhReturnType+atanh() const+{+  return AtanhReturnType(derived());+}++/** \returns an expression of the coefficient-wise inverse hyperbolic sin of *this.+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_asinh">Math functions</a>, atanh(), asinh(), acosh()+  */+EIGEN_DEVICE_FUNC+inline const AsinhReturnType+asinh() const+{+  return AsinhReturnType(derived());+}++/** \returns an expression of the coefficient-wise inverse hyperbolic cos of *this.+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_acosh">Math functions</a>, atanh(), asinh(), acosh()+  */+EIGEN_DEVICE_FUNC+inline const AcoshReturnType+acosh() const+{+  return AcoshReturnType(derived());+}+#endif++/** \returns an expression of the coefficient-wise logistic of *this.+  */+EIGEN_DEVICE_FUNC+inline const LogisticReturnType+logistic() const+{+  return LogisticReturnType(derived());+}++/** \returns an expression of the coefficient-wise inverse of *this.+  *+  * Example: \include Cwise_inverse.cpp+  * Output: \verbinclude Cwise_inverse.out+  *+  * \sa operator/(), operator*()+  */+EIGEN_DEVICE_FUNC+inline const InverseReturnType+inverse() const+{+  return InverseReturnType(derived());+}++/** \returns an expression of the coefficient-wise square of *this.+  *+  * Example: \include Cwise_square.cpp+  * Output: \verbinclude Cwise_square.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_squareE">Math functions</a>, abs2(), cube(), pow()+  */+EIGEN_DEVICE_FUNC+inline const SquareReturnType+square() const+{+  return SquareReturnType(derived());+}++/** \returns an expression of the coefficient-wise cube of *this.+  *+  * Example: \include Cwise_cube.cpp+  * Output: \verbinclude Cwise_cube.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cube">Math functions</a>, square(), pow()+  */+EIGEN_DEVICE_FUNC+inline const CubeReturnType+cube() const+{+  return CubeReturnType(derived());+}++/** \returns an expression of the coefficient-wise rint of *this.+  *+  * Example: \include Cwise_rint.cpp+  * Output: \verbinclude Cwise_rint.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_rint">Math functions</a>, ceil(), floor()+  */+EIGEN_DEVICE_FUNC+inline const RintReturnType+rint() const+{+  return RintReturnType(derived());+}++/** \returns an expression of the coefficient-wise round of *this.+  *+  * Example: \include Cwise_round.cpp+  * Output: \verbinclude Cwise_round.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_round">Math functions</a>, ceil(), floor()+  */+EIGEN_DEVICE_FUNC+inline const RoundReturnType+round() const+{+  return RoundReturnType(derived());+}++/** \returns an expression of the coefficient-wise floor of *this.+  *+  * Example: \include Cwise_floor.cpp+  * Output: \verbinclude Cwise_floor.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_floor">Math functions</a>, ceil(), round()+  */+EIGEN_DEVICE_FUNC+inline const FloorReturnType+floor() const+{+  return FloorReturnType(derived());+}++/** \returns an expression of the coefficient-wise ceil of *this.+  *+  * Example: \include Cwise_ceil.cpp+  * Output: \verbinclude Cwise_ceil.out+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_ceil">Math functions</a>, floor(), round()+  */+EIGEN_DEVICE_FUNC+inline const CeilReturnType+ceil() const+{+  return CeilReturnType(derived());+}++template<int N> struct ShiftRightXpr {+  typedef CwiseUnaryOp<internal::scalar_shift_right_op<Scalar, N>, const Derived> Type;+};++/** \returns an expression of \c *this with the \a Scalar type arithmetically+  * shifted right by \a N bit positions.+  *+  * The template parameter \a N specifies the number of bit positions to shift.+  * +  * \sa shiftLeft()+  */+template<int N>+EIGEN_DEVICE_FUNC+typename ShiftRightXpr<N>::Type+shiftRight() const+{+  return typename ShiftRightXpr<N>::Type(derived());+}+++template<int N> struct ShiftLeftXpr {+  typedef CwiseUnaryOp<internal::scalar_shift_left_op<Scalar, N>, const Derived> Type;+};++/** \returns an expression of \c *this with the \a Scalar type logically+  * shifted left by \a N bit positions.+  *+  * The template parameter \a N specifies the number of bit positions to shift.+  *+  * \sa shiftRight()+  */+template<int N>+EIGEN_DEVICE_FUNC+typename ShiftLeftXpr<N>::Type+shiftLeft() const+{+  return typename ShiftLeftXpr<N>::Type(derived());+}++/** \returns an expression of the coefficient-wise isnan of *this.+  *+  * Example: \include Cwise_isNaN.cpp+  * Output: \verbinclude Cwise_isNaN.out+  *+  * \sa isfinite(), isinf()+  */+EIGEN_DEVICE_FUNC+inline const IsNaNReturnType+isNaN() const+{+  return IsNaNReturnType(derived());+}++/** \returns an expression of the coefficient-wise isinf of *this.+  *+  * Example: \include Cwise_isInf.cpp+  * Output: \verbinclude Cwise_isInf.out+  *+  * \sa isnan(), isfinite()+  */+EIGEN_DEVICE_FUNC+inline const IsInfReturnType+isInf() const+{+  return IsInfReturnType(derived());+}++/** \returns an expression of the coefficient-wise isfinite of *this.+  *+  * Example: \include Cwise_isFinite.cpp+  * Output: \verbinclude Cwise_isFinite.out+  *+  * \sa isnan(), isinf()+  */+EIGEN_DEVICE_FUNC+inline const IsFiniteReturnType+isFinite() const+{+  return IsFiniteReturnType(derived());+}++/** \returns an expression of the coefficient-wise ! operator of *this+  *+  * \warning this operator is for expression of bool only.+  *+  * Example: \include Cwise_boolean_not.cpp+  * Output: \verbinclude Cwise_boolean_not.out+  *+  * \sa operator!=()+  */+EIGEN_DEVICE_FUNC+inline const BooleanNotReturnType+operator!() const+{+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value),+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);+  return BooleanNotReturnType(derived());+}+++// --- SpecialFunctions module ---++typedef CwiseUnaryOp<internal::scalar_lgamma_op<Scalar>, const Derived> LgammaReturnType;+typedef CwiseUnaryOp<internal::scalar_digamma_op<Scalar>, const Derived> DigammaReturnType;+typedef CwiseUnaryOp<internal::scalar_erf_op<Scalar>, const Derived> ErfReturnType;+typedef CwiseUnaryOp<internal::scalar_erfc_op<Scalar>, const Derived> ErfcReturnType;+typedef CwiseUnaryOp<internal::scalar_ndtri_op<Scalar>, const Derived> NdtriReturnType;++/** \cpp11 \returns an expression of the coefficient-wise ln(|gamma(*this)|).+  *+  * \specialfunctions_module+  *+  * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,+  * or float/double in non c++11 mode, the user has to provide implementations of lgamma(T) for any scalar+  * type T to be supported.+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_lgamma">Math functions</a>, digamma()+  */+EIGEN_DEVICE_FUNC+inline const LgammaReturnType+lgamma() const+{+  return LgammaReturnType(derived());+}++/** \returns an expression of the coefficient-wise digamma (psi, derivative of lgamma).+  *+  * \specialfunctions_module+  *+  * \note This function supports only float and double scalar types. To support other scalar types,+  * the user has to provide implementations of digamma(T) for any scalar+  * type T to be supported.+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_digamma">Math functions</a>, Eigen::digamma(), Eigen::polygamma(), lgamma()+  */+EIGEN_DEVICE_FUNC+inline const DigammaReturnType+digamma() const+{+  return DigammaReturnType(derived());+}++/** \cpp11 \returns an expression of the coefficient-wise Gauss error+  * function of *this.+  *+  * \specialfunctions_module+  *+  * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,+  * or float/double in non c++11 mode, the user has to provide implementations of erf(T) for any scalar+  * type T to be supported.+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_erf">Math functions</a>, erfc()+  */+EIGEN_DEVICE_FUNC+inline const ErfReturnType+erf() const+{+  return ErfReturnType(derived());+}++/** \cpp11 \returns an expression of the coefficient-wise Complementary error+  * function of *this.+  *+  * \specialfunctions_module+  *+  * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,+  * or float/double in non c++11 mode, the user has to provide implementations of erfc(T) for any scalar+  * type T to be supported.+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_erfc">Math functions</a>, erf()+  */+EIGEN_DEVICE_FUNC+inline const ErfcReturnType+erfc() const+{+  return ErfcReturnType(derived());+}++/** \returns an expression of the coefficient-wise inverse of the CDF of the Normal distribution function+  * function of *this.+  *+  * \specialfunctions_module+  * +  * In other words, considering `x = ndtri(y)`, it returns the argument, x, for which the area under the+  * Gaussian probability density function (integrated from minus infinity to x) is equal to y.+  *+  * \note This function supports only float and double scalar types. To support other scalar types,+  * the user has to provide implementations of ndtri(T) for any scalar type T to be supported.+  *+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_ndtri">Math functions</a>+  */+EIGEN_DEVICE_FUNC+inline const NdtriReturnType+ndtri() const+{+  return NdtriReturnType(derived());+}
+ cpp/Eigen/src/plugins/BlockMethods.h view
@@ -0,0 +1,1442 @@+// This file is part of Eigen, a lightweight C++ template library+// for linear algebra.+//+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>+//+// This Source Code Form is subject to the terms of the Mozilla+// Public License v. 2.0. If a copy of the MPL was not distributed+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.++#ifndef EIGEN_PARSED_BY_DOXYGEN++/// \internal expression type of a column */+typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr;+typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ConstColXpr;+/// \internal expression type of a row */+typedef Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr;+typedef const Block<const Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowXpr;+/// \internal expression type of a block of whole columns */+typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr;+typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ConstColsBlockXpr;+/// \internal expression type of a block of whole rows */+typedef Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr;+typedef const Block<const Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowsBlockXpr;+/// \internal expression type of a block of whole columns */+template<int N> struct NColsBlockXpr { typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; };+template<int N> struct ConstNColsBlockXpr { typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; };+/// \internal expression type of a block of whole rows */+template<int N> struct NRowsBlockXpr { typedef Block<Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; };+template<int N> struct ConstNRowsBlockXpr { typedef const Block<const Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; };+/// \internal expression of a block */+typedef Block<Derived> BlockXpr;+typedef const Block<const Derived> ConstBlockXpr;+/// \internal expression of a block of fixed sizes */+template<int Rows, int Cols> struct FixedBlockXpr { typedef Block<Derived,Rows,Cols> Type; };+template<int Rows, int Cols> struct ConstFixedBlockXpr { typedef Block<const Derived,Rows,Cols> Type; };++typedef VectorBlock<Derived> SegmentReturnType;+typedef const VectorBlock<const Derived> ConstSegmentReturnType;+template<int Size> struct FixedSegmentReturnType { typedef VectorBlock<Derived, Size> Type; };+template<int Size> struct ConstFixedSegmentReturnType { typedef const VectorBlock<const Derived, Size> Type; };++/// \internal inner-vector+typedef Block<Derived,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true>       InnerVectorReturnType;+typedef Block<const Derived,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true> ConstInnerVectorReturnType;++/// \internal set of inner-vectors+typedef Block<Derived,Dynamic,Dynamic,true> InnerVectorsReturnType;+typedef Block<const Derived,Dynamic,Dynamic,true> ConstInnerVectorsReturnType;++#endif // not EIGEN_PARSED_BY_DOXYGEN++/// \returns an expression of a block in \c *this with either dynamic or fixed sizes.+///+/// \param  startRow  the first row in the block+/// \param  startCol  the first column in the block+/// \param  blockRows number of rows in the block, specified at either run-time or compile-time+/// \param  blockCols number of columns in the block, specified at either run-time or compile-time+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.+///+/// Example using runtime (aka dynamic) sizes: \include MatrixBase_block_int_int_int_int.cpp+/// Output: \verbinclude MatrixBase_block_int_int_int_int.out+///+/// \newin{3.4}:+///+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments. In the later case, \c n plays the role of a runtime fallback value in case \c N equals Eigen::Dynamic.+/// Here is an example with a fixed number of rows \c NRows and dynamic number of columns \c cols:+/// \code+/// mat.block(i,j,fix<NRows>,cols)+/// \endcode+///+/// This function thus fully covers the features offered by the following overloads block<NRows,NCols>(Index, Index),+/// and block<NRows,NCols>(Index, Index, Index, Index) that are thus obsolete. Indeed, this generic version avoids+/// redundancy, it preserves the argument order, and prevents the need to rely on the template keyword in templated code.+///+/// but with less redundancy and more consistency as it does not modify the argument order+/// and seamlessly enable hybrid fixed/dynamic sizes.+///+/// \note Even in the case that the returned expression has dynamic size, in the case+/// when it is applied to a fixed-size matrix, it inherits a fixed maximal size,+/// which means that evaluating it does not cause a dynamic memory allocation.+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa class Block, fix, fix<N>(int)+///+template<typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+#else+typename FixedBlockXpr<...,...>::Type+#endif+block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols)+{+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type(+            derived(), startRow, startCol, internal::get_runtime_value(blockRows), internal::get_runtime_value(blockCols));+}++/// This is the const version of block(Index,Index,NRowsType,NColsType)+template<typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+#else+const typename ConstFixedBlockXpr<...,...>::Type+#endif+block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols) const+{+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type(+            derived(), startRow, startCol, internal::get_runtime_value(blockRows), internal::get_runtime_value(blockCols));+}++++/// \returns a expression of a top-right corner of \c *this with either dynamic or fixed sizes.+///+/// \param cRows the number of rows in the corner+/// \param cCols the number of columns in the corner+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.+///+/// Example with dynamic sizes: \include MatrixBase_topRightCorner_int_int.cpp+/// Output: \verbinclude MatrixBase_topRightCorner_int_int.out+///+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+#else+typename FixedBlockXpr<...,...>::Type+#endif+topRightCorner(NRowsType cRows, NColsType cCols)+{+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+            (derived(), 0, cols() - internal::get_runtime_value(cCols), internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));+}++/// This is the const version of topRightCorner(NRowsType, NColsType).+template<typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+#else+const typename ConstFixedBlockXpr<...,...>::Type+#endif+topRightCorner(NRowsType cRows, NColsType cCols) const+{+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+            (derived(), 0, cols() - internal::get_runtime_value(cCols), internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));+}++/// \returns an expression of a fixed-size top-right corner of \c *this.+///+/// \tparam CRows the number of rows in the corner+/// \tparam CCols the number of columns in the corner+///+/// Example: \include MatrixBase_template_int_int_topRightCorner.cpp+/// Output: \verbinclude MatrixBase_template_int_int_topRightCorner.out+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa class Block, block<int,int>(Index,Index)+///+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename FixedBlockXpr<CRows,CCols>::Type topRightCorner()+{+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols);+}++/// This is the const version of topRightCorner<int, int>().+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner() const+{+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols);+}++/// \returns an expression of a top-right corner of \c *this.+///+/// \tparam CRows number of rows in corner as specified at compile-time+/// \tparam CCols number of columns in corner as specified at compile-time+/// \param  cRows number of rows in corner as specified at run-time+/// \param  cCols number of columns in corner as specified at run-time+///+/// This function is mainly useful for corners where the number of rows is specified at compile-time+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time+/// information should not contradict. In other words, \a cRows should equal \a CRows unless+/// \a CRows is \a Dynamic, and the same for the number of columns.+///+/// Example: \include MatrixBase_template_int_int_topRightCorner_int_int.cpp+/// Output: \verbinclude MatrixBase_template_int_int_topRightCorner_int_int.out+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa class Block+///+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename FixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols)+{+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);+}++/// This is the const version of topRightCorner<int, int>(Index, Index).+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols) const+{+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);+}++++/// \returns an expression of a top-left corner of \c *this  with either dynamic or fixed sizes.+///+/// \param cRows the number of rows in the corner+/// \param cCols the number of columns in the corner+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.+///+/// Example: \include MatrixBase_topLeftCorner_int_int.cpp+/// Output: \verbinclude MatrixBase_topLeftCorner_int_int.out+///+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+#else+typename FixedBlockXpr<...,...>::Type+#endif+topLeftCorner(NRowsType cRows, NColsType cCols)+{+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+            (derived(), 0, 0, internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));+}++/// This is the const version of topLeftCorner(Index, Index).+template<typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+#else+const typename ConstFixedBlockXpr<...,...>::Type+#endif+topLeftCorner(NRowsType cRows, NColsType cCols) const+{+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+            (derived(), 0, 0, internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));+}++/// \returns an expression of a fixed-size top-left corner of \c *this.+///+/// The template parameters CRows and CCols are the number of rows and columns in the corner.+///+/// Example: \include MatrixBase_template_int_int_topLeftCorner.cpp+/// Output: \verbinclude MatrixBase_template_int_int_topLeftCorner.out+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename FixedBlockXpr<CRows,CCols>::Type topLeftCorner()+{+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0);+}++/// This is the const version of topLeftCorner<int, int>().+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner() const+{+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0);+}++/// \returns an expression of a top-left corner of \c *this.+///+/// \tparam CRows number of rows in corner as specified at compile-time+/// \tparam CCols number of columns in corner as specified at compile-time+/// \param  cRows number of rows in corner as specified at run-time+/// \param  cCols number of columns in corner as specified at run-time+///+/// This function is mainly useful for corners where the number of rows is specified at compile-time+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time+/// information should not contradict. In other words, \a cRows should equal \a CRows unless+/// \a CRows is \a Dynamic, and the same for the number of columns.+///+/// Example: \include MatrixBase_template_int_int_topLeftCorner_int_int.cpp+/// Output: \verbinclude MatrixBase_template_int_int_topLeftCorner_int_int.out+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa class Block+///+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename FixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols)+{+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols);+}++/// This is the const version of topLeftCorner<int, int>(Index, Index).+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols) const+{+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols);+}++++/// \returns an expression of a bottom-right corner of \c *this  with either dynamic or fixed sizes.+///+/// \param cRows the number of rows in the corner+/// \param cCols the number of columns in the corner+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.+///+/// Example: \include MatrixBase_bottomRightCorner_int_int.cpp+/// Output: \verbinclude MatrixBase_bottomRightCorner_int_int.out+///+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+#else+typename FixedBlockXpr<...,...>::Type+#endif+bottomRightCorner(NRowsType cRows, NColsType cCols)+{+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+            (derived(), rows() - internal::get_runtime_value(cRows), cols() - internal::get_runtime_value(cCols),+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));+}++/// This is the const version of bottomRightCorner(NRowsType, NColsType).+template<typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+#else+const typename ConstFixedBlockXpr<...,...>::Type+#endif+bottomRightCorner(NRowsType cRows, NColsType cCols) const+{+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+            (derived(), rows() - internal::get_runtime_value(cRows), cols() - internal::get_runtime_value(cCols),+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));+}++/// \returns an expression of a fixed-size bottom-right corner of \c *this.+///+/// The template parameters CRows and CCols are the number of rows and columns in the corner.+///+/// Example: \include MatrixBase_template_int_int_bottomRightCorner.cpp+/// Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner.out+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename FixedBlockXpr<CRows,CCols>::Type bottomRightCorner()+{+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols);+}++/// This is the const version of bottomRightCorner<int, int>().+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner() const+{+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols);+}++/// \returns an expression of a bottom-right corner of \c *this.+///+/// \tparam CRows number of rows in corner as specified at compile-time+/// \tparam CCols number of columns in corner as specified at compile-time+/// \param  cRows number of rows in corner as specified at run-time+/// \param  cCols number of columns in corner as specified at run-time+///+/// This function is mainly useful for corners where the number of rows is specified at compile-time+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time+/// information should not contradict. In other words, \a cRows should equal \a CRows unless+/// \a CRows is \a Dynamic, and the same for the number of columns.+///+/// Example: \include MatrixBase_template_int_int_bottomRightCorner_int_int.cpp+/// Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner_int_int.out+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa class Block+///+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename FixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRows, Index cCols)+{+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);+}++/// This is the const version of bottomRightCorner<int, int>(Index, Index).+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRows, Index cCols) const+{+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);+}++++/// \returns an expression of a bottom-left corner of \c *this  with either dynamic or fixed sizes.+///+/// \param cRows the number of rows in the corner+/// \param cCols the number of columns in the corner+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.+///+/// Example: \include MatrixBase_bottomLeftCorner_int_int.cpp+/// Output: \verbinclude MatrixBase_bottomLeftCorner_int_int.out+///+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+#else+typename FixedBlockXpr<...,...>::Type+#endif+bottomLeftCorner(NRowsType cRows, NColsType cCols)+{+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+            (derived(), rows() - internal::get_runtime_value(cRows), 0,+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));+}++/// This is the const version of bottomLeftCorner(NRowsType, NColsType).+template<typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+#else+typename ConstFixedBlockXpr<...,...>::Type+#endif+bottomLeftCorner(NRowsType cRows, NColsType cCols) const+{+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type+            (derived(), rows() - internal::get_runtime_value(cRows), 0,+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));+}++/// \returns an expression of a fixed-size bottom-left corner of \c *this.+///+/// The template parameters CRows and CCols are the number of rows and columns in the corner.+///+/// Example: \include MatrixBase_template_int_int_bottomLeftCorner.cpp+/// Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner.out+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename FixedBlockXpr<CRows,CCols>::Type bottomLeftCorner()+{+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0);+}++/// This is the const version of bottomLeftCorner<int, int>().+template<int CRows, int CCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner() const+{+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0);+}++/// \returns an expression of a bottom-left corner of \c *this.+///+/// \tparam CRows number of rows in corner as specified at compile-time+/// \tparam CCols number of columns in corner as specified at compile-time+/// \param  cRows number of rows in corner as specified at run-time+/// \param  cCols number of columns in corner as specified at run-time+///+/// This function is mainly useful for corners where the number of rows is specified at compile-time+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time+/// information should not contradict. In other words, \a cRows should equal \a CRows unless+/// \a CRows is \a Dynamic, and the same for the number of columns.+///+/// Example: \include MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp+/// Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner_int_int.out+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa class Block+///+template<int CRows, int CCols>+EIGEN_STRONG_INLINE+typename FixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols)+{+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);+}++/// This is the const version of bottomLeftCorner<int, int>(Index, Index).+template<int CRows, int CCols>+EIGEN_STRONG_INLINE+const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols) const+{+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);+}++++/// \returns a block consisting of the top rows of \c *this.+///+/// \param n the number of rows in the block+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.+///+/// Example: \include MatrixBase_topRows_int.cpp+/// Output: \verbinclude MatrixBase_topRows_int.out+///+/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments.+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<typename NRowsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type+#else+typename NRowsBlockXpr<...>::Type+#endif+topRows(NRowsType n)+{+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type+            (derived(), 0, 0, internal::get_runtime_value(n), cols());+}++/// This is the const version of topRows(NRowsType).+template<typename NRowsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type+#else+const typename ConstNRowsBlockXpr<...>::Type+#endif+topRows(NRowsType n) const+{+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type+            (derived(), 0, 0, internal::get_runtime_value(n), cols());+}++/// \returns a block consisting of the top rows of \c *this.+///+/// \tparam N the number of rows in the block as specified at compile-time+/// \param n the number of rows in the block as specified at run-time+///+/// The compile-time and run-time information should not contradict. In other words,+/// \a n should equal \a N unless \a N is \a Dynamic.+///+/// Example: \include MatrixBase_template_int_topRows.cpp+/// Output: \verbinclude MatrixBase_template_int_topRows.out+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename NRowsBlockXpr<N>::Type topRows(Index n = N)+{+  return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());+}++/// This is the const version of topRows<int>().+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename ConstNRowsBlockXpr<N>::Type topRows(Index n = N) const+{+  return typename ConstNRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());+}++++/// \returns a block consisting of the bottom rows of \c *this.+///+/// \param n the number of rows in the block+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.+///+/// Example: \include MatrixBase_bottomRows_int.cpp+/// Output: \verbinclude MatrixBase_bottomRows_int.out+///+/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments.+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<typename NRowsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type+#else+typename NRowsBlockXpr<...>::Type+#endif+bottomRows(NRowsType n)+{+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type+            (derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());+}++/// This is the const version of bottomRows(NRowsType).+template<typename NRowsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type+#else+const typename ConstNRowsBlockXpr<...>::Type+#endif+bottomRows(NRowsType n) const+{+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type+            (derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());+}++/// \returns a block consisting of the bottom rows of \c *this.+///+/// \tparam N the number of rows in the block as specified at compile-time+/// \param n the number of rows in the block as specified at run-time+///+/// The compile-time and run-time information should not contradict. In other words,+/// \a n should equal \a N unless \a N is \a Dynamic.+///+/// Example: \include MatrixBase_template_int_bottomRows.cpp+/// Output: \verbinclude MatrixBase_template_int_bottomRows.out+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename NRowsBlockXpr<N>::Type bottomRows(Index n = N)+{+  return typename NRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());+}++/// This is the const version of bottomRows<int>().+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename ConstNRowsBlockXpr<N>::Type bottomRows(Index n = N) const+{+  return typename ConstNRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());+}++++/// \returns a block consisting of a range of rows of \c *this.+///+/// \param startRow the index of the first row in the block+/// \param n the number of rows in the block+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.+///+/// Example: \include DenseBase_middleRows_int.cpp+/// Output: \verbinclude DenseBase_middleRows_int.out+///+/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments.+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<typename NRowsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type+#else+typename NRowsBlockXpr<...>::Type+#endif+middleRows(Index startRow, NRowsType n)+{+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type+            (derived(), startRow, 0, internal::get_runtime_value(n), cols());+}++/// This is the const version of middleRows(Index,NRowsType).+template<typename NRowsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type+#else+const typename ConstNRowsBlockXpr<...>::Type+#endif+middleRows(Index startRow, NRowsType n) const+{+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type+            (derived(), startRow, 0, internal::get_runtime_value(n), cols());+}++/// \returns a block consisting of a range of rows of \c *this.+///+/// \tparam N the number of rows in the block as specified at compile-time+/// \param startRow the index of the first row in the block+/// \param n the number of rows in the block as specified at run-time+///+/// The compile-time and run-time information should not contradict. In other words,+/// \a n should equal \a N unless \a N is \a Dynamic.+///+/// Example: \include DenseBase_template_int_middleRows.cpp+/// Output: \verbinclude DenseBase_template_int_middleRows.out+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename NRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N)+{+  return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());+}++/// This is the const version of middleRows<int>().+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N) const+{+  return typename ConstNRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());+}++++/// \returns a block consisting of the left columns of \c *this.+///+/// \param n the number of columns in the block+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.+///+/// Example: \include MatrixBase_leftCols_int.cpp+/// Output: \verbinclude MatrixBase_leftCols_int.out+///+/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments.+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type+#else+typename NColsBlockXpr<...>::Type+#endif+leftCols(NColsType n)+{+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type+            (derived(), 0, 0, rows(), internal::get_runtime_value(n));+}++/// This is the const version of leftCols(NColsType).+template<typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type+#else+const typename ConstNColsBlockXpr<...>::Type+#endif+leftCols(NColsType n) const+{+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type+            (derived(), 0, 0, rows(), internal::get_runtime_value(n));+}++/// \returns a block consisting of the left columns of \c *this.+///+/// \tparam N the number of columns in the block as specified at compile-time+/// \param n the number of columns in the block as specified at run-time+///+/// The compile-time and run-time information should not contradict. In other words,+/// \a n should equal \a N unless \a N is \a Dynamic.+///+/// Example: \include MatrixBase_template_int_leftCols.cpp+/// Output: \verbinclude MatrixBase_template_int_leftCols.out+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename NColsBlockXpr<N>::Type leftCols(Index n = N)+{+  return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);+}++/// This is the const version of leftCols<int>().+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename ConstNColsBlockXpr<N>::Type leftCols(Index n = N) const+{+  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);+}++++/// \returns a block consisting of the right columns of \c *this.+///+/// \param n the number of columns in the block+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.+///+/// Example: \include MatrixBase_rightCols_int.cpp+/// Output: \verbinclude MatrixBase_rightCols_int.out+///+/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments.+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type+#else+typename NColsBlockXpr<...>::Type+#endif+rightCols(NColsType n)+{+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type+            (derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));+}++/// This is the const version of rightCols(NColsType).+template<typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type+#else+const typename ConstNColsBlockXpr<...>::Type+#endif+rightCols(NColsType n) const+{+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type+            (derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));+}++/// \returns a block consisting of the right columns of \c *this.+///+/// \tparam N the number of columns in the block as specified at compile-time+/// \param n the number of columns in the block as specified at run-time+///+/// The compile-time and run-time information should not contradict. In other words,+/// \a n should equal \a N unless \a N is \a Dynamic.+///+/// Example: \include MatrixBase_template_int_rightCols.cpp+/// Output: \verbinclude MatrixBase_template_int_rightCols.out+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename NColsBlockXpr<N>::Type rightCols(Index n = N)+{+  return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);+}++/// This is the const version of rightCols<int>().+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename ConstNColsBlockXpr<N>::Type rightCols(Index n = N) const+{+  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);+}++++/// \returns a block consisting of a range of columns of \c *this.+///+/// \param startCol the index of the first column in the block+/// \param numCols the number of columns in the block+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.+///+/// Example: \include DenseBase_middleCols_int.cpp+/// Output: \verbinclude DenseBase_middleCols_int.out+///+/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments.+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type+#else+typename NColsBlockXpr<...>::Type+#endif+middleCols(Index startCol, NColsType numCols)+{+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type+            (derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));+}++/// This is the const version of middleCols(Index,NColsType).+template<typename NColsType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type+#else+const typename ConstNColsBlockXpr<...>::Type+#endif+middleCols(Index startCol, NColsType numCols) const+{+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type+            (derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));+}++/// \returns a block consisting of a range of columns of \c *this.+///+/// \tparam N the number of columns in the block as specified at compile-time+/// \param startCol the index of the first column in the block+/// \param n the number of columns in the block as specified at run-time+///+/// The compile-time and run-time information should not contradict. In other words,+/// \a n should equal \a N unless \a N is \a Dynamic.+///+/// Example: \include DenseBase_template_int_middleCols.cpp+/// Output: \verbinclude DenseBase_template_int_middleCols.out+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename NColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N)+{+  return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);+}++/// This is the const version of middleCols<int>().+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N) const+{+  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);+}++++/// \returns a fixed-size expression of a block of \c *this.+///+/// The template parameters \a NRows and \a NCols are the number of+/// rows and columns in the block.+///+/// \param startRow the first row in the block+/// \param startCol the first column in the block+///+/// Example: \include MatrixBase_block_int_int.cpp+/// Output: \verbinclude MatrixBase_block_int_int.out+///+/// \note The usage of of this overload is discouraged from %Eigen 3.4, better used the generic+/// block(Index,Index,NRowsType,NColsType), here is the one-to-one equivalence:+/// \code+/// mat.template block<NRows,NCols>(i,j)  <-->  mat.block(i,j,fix<NRows>,fix<NCols>)+/// \endcode+///+/// \note since block is a templated member, the keyword template has to be used+/// if the matrix type is also a template parameter: \code m.template block<3,3>(1,1); \endcode+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<int NRows, int NCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol)+{+  return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol);+}++/// This is the const version of block<>(Index, Index). */+template<int NRows, int NCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol) const+{+  return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol);+}++/// \returns an expression of a block of \c *this.+///+/// \tparam NRows number of rows in block as specified at compile-time+/// \tparam NCols number of columns in block as specified at compile-time+/// \param  startRow  the first row in the block+/// \param  startCol  the first column in the block+/// \param  blockRows number of rows in block as specified at run-time+/// \param  blockCols number of columns in block as specified at run-time+///+/// This function is mainly useful for blocks where the number of rows is specified at compile-time+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time+/// information should not contradict. In other words, \a blockRows should equal \a NRows unless+/// \a NRows is \a Dynamic, and the same for the number of columns.+///+/// Example: \include MatrixBase_template_int_int_block_int_int_int_int.cpp+/// Output: \verbinclude MatrixBase_template_int_int_block_int_int_int_int.out+///+/// \note The usage of of this overload is discouraged from %Eigen 3.4, better used the generic+/// block(Index,Index,NRowsType,NColsType), here is the one-to-one complete equivalence:+/// \code+/// mat.template block<NRows,NCols>(i,j,rows,cols)     <-->  mat.block(i,j,fix<NRows>(rows),fix<NCols>(cols))+/// \endcode+/// If we known that, e.g., NRows==Dynamic and NCols!=Dynamic, then the equivalence becomes:+/// \code+/// mat.template block<Dynamic,NCols>(i,j,rows,NCols)  <-->  mat.block(i,j,rows,fix<NCols>)+/// \endcode+///+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL+///+/// \sa block(Index,Index,NRowsType,NColsType), class Block+///+template<int NRows, int NCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol,+                                                  Index blockRows, Index blockCols)+{+  return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);+}++/// This is the const version of block<>(Index, Index, Index, Index).+template<int NRows, int NCols>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol,+                                                              Index blockRows, Index blockCols) const+{+  return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);+}++/// \returns an expression of the \a i-th column of \c *this. Note that the numbering starts at 0.+///+/// Example: \include MatrixBase_col.cpp+/// Output: \verbinclude MatrixBase_col.out+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)+/**+  * \sa row(), class Block */+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+ColXpr col(Index i)+{+  return ColXpr(derived(), i);+}++/// This is the const version of col().+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+ConstColXpr col(Index i) const+{+  return ConstColXpr(derived(), i);+}++/// \returns an expression of the \a i-th row of \c *this. Note that the numbering starts at 0.+///+/// Example: \include MatrixBase_row.cpp+/// Output: \verbinclude MatrixBase_row.out+///+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)+/**+  * \sa col(), class Block */+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+RowXpr row(Index i)+{+  return RowXpr(derived(), i);+}++/// This is the const version of row(). */+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+ConstRowXpr row(Index i) const+{+  return ConstRowXpr(derived(), i);+}++/// \returns an expression of a segment (i.e. a vector block) in \c *this with either dynamic or fixed sizes.+///+/// \only_for_vectors+///+/// \param start the first coefficient in the segment+/// \param n the number of coefficients in the segment+/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.+///+/// Example: \include MatrixBase_segment_int_int.cpp+/// Output: \verbinclude MatrixBase_segment_int_int.out+///+/// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments.+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.+///+/// \note Even in the case that the returned expression has dynamic size, in the case+/// when it is applied to a fixed-size vector, it inherits a fixed maximal size,+/// which means that evaluating it does not cause a dynamic memory allocation.+///+/// \sa block(Index,Index,NRowsType,NColsType), fix<N>, fix<N>(int), class Block+///+template<typename NType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type+#else+typename FixedSegmentReturnType<...>::Type+#endif+segment(Index start, NType n)+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type+            (derived(), start, internal::get_runtime_value(n));+}+++/// This is the const version of segment(Index,NType).+template<typename NType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type+#else+const typename ConstFixedSegmentReturnType<...>::Type+#endif+segment(Index start, NType n) const+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type+            (derived(), start, internal::get_runtime_value(n));+}++/// \returns an expression of the first coefficients of \c *this with either dynamic or fixed sizes.+///+/// \only_for_vectors+///+/// \param n the number of coefficients in the segment+/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.+///+/// Example: \include MatrixBase_start_int.cpp+/// Output: \verbinclude MatrixBase_start_int.out+///+/// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments.+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.+///+/// \note Even in the case that the returned expression has dynamic size, in the case+/// when it is applied to a fixed-size vector, it inherits a fixed maximal size,+/// which means that evaluating it does not cause a dynamic memory allocation.+///+/// \sa class Block, block(Index,Index)+///+template<typename NType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type+#else+typename FixedSegmentReturnType<...>::Type+#endif+head(NType n)+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type+              (derived(), 0, internal::get_runtime_value(n));+}++/// This is the const version of head(NType).+template<typename NType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type+#else+const typename ConstFixedSegmentReturnType<...>::Type+#endif+head(NType n) const+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type+            (derived(), 0, internal::get_runtime_value(n));+}++/// \returns an expression of a last coefficients of \c *this with either dynamic or fixed sizes.+///+/// \only_for_vectors+///+/// \param n the number of coefficients in the segment+/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.+///+/// Example: \include MatrixBase_end_int.cpp+/// Output: \verbinclude MatrixBase_end_int.out+///+/// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments.+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.+///+/// \note Even in the case that the returned expression has dynamic size, in the case+/// when it is applied to a fixed-size vector, it inherits a fixed maximal size,+/// which means that evaluating it does not cause a dynamic memory allocation.+///+/// \sa class Block, block(Index,Index)+///+template<typename NType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type+#else+typename FixedSegmentReturnType<...>::Type+#endif+tail(NType n)+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type+            (derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));+}++/// This is the const version of tail(Index).+template<typename NType>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+#ifndef EIGEN_PARSED_BY_DOXYGEN+const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type+#else+const typename ConstFixedSegmentReturnType<...>::Type+#endif+tail(NType n) const+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type+            (derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));+}++/// \returns a fixed-size expression of a segment (i.e. a vector block) in \c *this+///+/// \only_for_vectors+///+/// \tparam N the number of coefficients in the segment as specified at compile-time+/// \param start the index of the first element in the segment+/// \param n the number of coefficients in the segment as specified at compile-time+///+/// The compile-time and run-time information should not contradict. In other words,+/// \a n should equal \a N unless \a N is \a Dynamic.+///+/// Example: \include MatrixBase_template_int_segment.cpp+/// Output: \verbinclude MatrixBase_template_int_segment.out+///+/// \sa segment(Index,NType), class Block+///+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename FixedSegmentReturnType<N>::Type segment(Index start, Index n = N)+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return typename FixedSegmentReturnType<N>::Type(derived(), start, n);+}++/// This is the const version of segment<int>(Index).+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename ConstFixedSegmentReturnType<N>::Type segment(Index start, Index n = N) const+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return typename ConstFixedSegmentReturnType<N>::Type(derived(), start, n);+}++/// \returns a fixed-size expression of the first coefficients of \c *this.+///+/// \only_for_vectors+///+/// \tparam N the number of coefficients in the segment as specified at compile-time+/// \param  n the number of coefficients in the segment as specified at run-time+///+/// The compile-time and run-time information should not contradict. In other words,+/// \a n should equal \a N unless \a N is \a Dynamic.+///+/// Example: \include MatrixBase_template_int_start.cpp+/// Output: \verbinclude MatrixBase_template_int_start.out+///+/// \sa head(NType), class Block+///+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename FixedSegmentReturnType<N>::Type head(Index n = N)+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return typename FixedSegmentReturnType<N>::Type(derived(), 0, n);+}++/// This is the const version of head<int>().+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return typename ConstFixedSegmentReturnType<N>::Type(derived(), 0, n);+}++/// \returns a fixed-size expression of the last coefficients of \c *this.+///+/// \only_for_vectors+///+/// \tparam N the number of coefficients in the segment as specified at compile-time+/// \param  n the number of coefficients in the segment as specified at run-time+///+/// The compile-time and run-time information should not contradict. In other words,+/// \a n should equal \a N unless \a N is \a Dynamic.+///+/// Example: \include MatrixBase_template_int_end.cpp+/// Output: \verbinclude MatrixBase_template_int_end.out+///+/// \sa tail(NType), class Block+///+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename FixedSegmentReturnType<N>::Type tail(Index n = N)+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return typename FixedSegmentReturnType<N>::Type(derived(), size() - n);+}++/// This is the const version of tail<int>.+template<int N>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename ConstFixedSegmentReturnType<N>::Type tail(Index n = N) const+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return typename ConstFixedSegmentReturnType<N>::Type(derived(), size() - n);+}++/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this+/// is col-major (resp. row-major).+///+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+InnerVectorReturnType innerVector(Index outer)+{ return InnerVectorReturnType(derived(), outer); }++/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this+/// is col-major (resp. row-major). Read-only.+///+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+const ConstInnerVectorReturnType innerVector(Index outer) const+{ return ConstInnerVectorReturnType(derived(), outer); }++/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this+/// is col-major (resp. row-major).+///+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+InnerVectorsReturnType+innerVectors(Index outerStart, Index outerSize)+{+  return Block<Derived,Dynamic,Dynamic,true>(derived(),+                                             IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,+                                             IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);++}++/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this+/// is col-major (resp. row-major). Read-only.+///+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+const ConstInnerVectorsReturnType+innerVectors(Index outerStart, Index outerSize) const+{+  return Block<const Derived,Dynamic,Dynamic,true>(derived(),+                                                  IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,+                                                  IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);++}++/** \returns the i-th subvector (column or vector) according to the \c Direction+  * \sa subVectors()+  */+template<DirectionType Direction>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename internal::conditional<Direction==Vertical,ColXpr,RowXpr>::type+subVector(Index i)+{+  return typename internal::conditional<Direction==Vertical,ColXpr,RowXpr>::type(derived(),i);+}++/** This is the const version of subVector(Index) */+template<DirectionType Direction>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE+typename internal::conditional<Direction==Vertical,ConstColXpr,ConstRowXpr>::type+subVector(Index i) const+{+  return typename internal::conditional<Direction==Vertical,ConstColXpr,ConstRowXpr>::type(derived(),i);+}++/** \returns the number of subvectors (rows or columns) in the direction \c Direction+  * \sa subVector(Index)+  */+template<DirectionType Direction>+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR+Index subVectors() const+{ return (Direction==Vertical)?cols():rows(); }
+ cpp/Eigen/src/plugins/CommonCwiseBinaryOps.h view
@@ -0,0 +1,115 @@+// This file is part of Eigen, a lightweight C++ template library+// for linear algebra.+//+// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>+//+// This Source Code Form is subject to the terms of the Mozilla+// Public License v. 2.0. If a copy of the MPL was not distributed+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.++// This file is a base class plugin containing common coefficient wise functions.++/** \returns an expression of the difference of \c *this and \a other+  *+  * \note If you want to substract a given scalar from all coefficients, see Cwise::operator-().+  *+  * \sa class CwiseBinaryOp, operator-=()+  */+EIGEN_MAKE_CWISE_BINARY_OP(operator-,difference)++/** \returns an expression of the sum of \c *this and \a other+  *+  * \note If you want to add a given scalar to all coefficients, see Cwise::operator+().+  *+  * \sa class CwiseBinaryOp, operator+=()+  */+EIGEN_MAKE_CWISE_BINARY_OP(operator+,sum)++/** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other+  *+  * The template parameter \a CustomBinaryOp is the type of the functor+  * of the custom operator (see class CwiseBinaryOp for an example)+  *+  * Here is an example illustrating the use of custom functors:+  * \include class_CwiseBinaryOp.cpp+  * Output: \verbinclude class_CwiseBinaryOp.out+  *+  * \sa class CwiseBinaryOp, operator+(), operator-(), cwiseProduct()+  */+template<typename CustomBinaryOp, typename OtherDerived>+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const CwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived>+binaryExpr(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other, const CustomBinaryOp& func = CustomBinaryOp()) const+{+  return CwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived>(derived(), other.derived(), func);+}+++#ifndef EIGEN_PARSED_BY_DOXYGEN+EIGEN_MAKE_SCALAR_BINARY_OP(operator*,product)+#else+/** \returns an expression of \c *this scaled by the scalar factor \a scalar+  *+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.+  */+template<typename T>+const CwiseBinaryOp<internal::scalar_product_op<Scalar,T>,Derived,Constant<T> > operator*(const T& scalar) const;+/** \returns an expression of \a expr scaled by the scalar factor \a scalar+  *+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.+  */+template<typename T> friend+const CwiseBinaryOp<internal::scalar_product_op<T,Scalar>,Constant<T>,Derived> operator*(const T& scalar, const StorageBaseType& expr);+#endif++++#ifndef EIGEN_PARSED_BY_DOXYGEN+EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(operator/,quotient)+#else+/** \returns an expression of \c *this divided by the scalar value \a scalar+  *+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.+  */+template<typename T>+const CwiseBinaryOp<internal::scalar_quotient_op<Scalar,T>,Derived,Constant<T> > operator/(const T& scalar) const;+#endif++/** \returns an expression of the coefficient-wise boolean \b and operator of \c *this and \a other+  *+  * \warning this operator is for expression of bool only.+  *+  * Example: \include Cwise_boolean_and.cpp+  * Output: \verbinclude Cwise_boolean_and.out+  *+  * \sa operator||(), select()+  */+template<typename OtherDerived>+EIGEN_DEVICE_FUNC+inline const CwiseBinaryOp<internal::scalar_boolean_and_op, const Derived, const OtherDerived>+operator&&(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const+{+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value && internal::is_same<bool,typename OtherDerived::Scalar>::value),+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);+  return CwiseBinaryOp<internal::scalar_boolean_and_op, const Derived, const OtherDerived>(derived(),other.derived());+}++/** \returns an expression of the coefficient-wise boolean \b or operator of \c *this and \a other+  *+  * \warning this operator is for expression of bool only.+  *+  * Example: \include Cwise_boolean_or.cpp+  * Output: \verbinclude Cwise_boolean_or.out+  *+  * \sa operator&&(), select()+  */+template<typename OtherDerived>+EIGEN_DEVICE_FUNC+inline const CwiseBinaryOp<internal::scalar_boolean_or_op, const Derived, const OtherDerived>+operator||(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const+{+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value && internal::is_same<bool,typename OtherDerived::Scalar>::value),+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);+  return CwiseBinaryOp<internal::scalar_boolean_or_op, const Derived, const OtherDerived>(derived(),other.derived());+}
+ cpp/Eigen/src/plugins/CommonCwiseUnaryOps.h view
@@ -0,0 +1,177 @@+// This file is part of Eigen, a lightweight C++ template library+// for linear algebra.+//+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>+//+// This Source Code Form is subject to the terms of the Mozilla+// Public License v. 2.0. If a copy of the MPL was not distributed+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.++// This file is a base class plugin containing common coefficient wise functions.++#ifndef EIGEN_PARSED_BY_DOXYGEN++/** \internal the return type of conjugate() */+typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,+                    const CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, const Derived>,+                    const Derived&+                  >::type ConjugateReturnType;+/** \internal the return type of real() const */+typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,+                    const CwiseUnaryOp<internal::scalar_real_op<Scalar>, const Derived>,+                    const Derived&+                  >::type RealReturnType;+/** \internal the return type of real() */+typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,+                    CwiseUnaryView<internal::scalar_real_ref_op<Scalar>, Derived>,+                    Derived&+                  >::type NonConstRealReturnType;+/** \internal the return type of imag() const */+typedef CwiseUnaryOp<internal::scalar_imag_op<Scalar>, const Derived> ImagReturnType;+/** \internal the return type of imag() */+typedef CwiseUnaryView<internal::scalar_imag_ref_op<Scalar>, Derived> NonConstImagReturnType;++typedef CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const Derived> NegativeReturnType;++#endif // not EIGEN_PARSED_BY_DOXYGEN++/// \returns an expression of the opposite of \c *this+///+EIGEN_DOC_UNARY_ADDONS(operator-,opposite)+///+EIGEN_DEVICE_FUNC+inline const NegativeReturnType+operator-() const { return NegativeReturnType(derived()); }+++template<class NewType> struct CastXpr { typedef typename internal::cast_return_type<Derived,const CwiseUnaryOp<internal::scalar_cast_op<Scalar, NewType>, const Derived> >::type Type; };++/// \returns an expression of \c *this with the \a Scalar type casted to+/// \a NewScalar.+///+/// The template parameter \a NewScalar is the type we are casting the scalars to.+///+EIGEN_DOC_UNARY_ADDONS(cast,conversion function)+///+/// \sa class CwiseUnaryOp+///+template<typename NewType>+EIGEN_DEVICE_FUNC+typename CastXpr<NewType>::Type+cast() const+{+  return typename CastXpr<NewType>::Type(derived());+}++/// \returns an expression of the complex conjugate of \c *this.+///+EIGEN_DOC_UNARY_ADDONS(conjugate,complex conjugate)+///+/// \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_conj">Math functions</a>, MatrixBase::adjoint()+EIGEN_DEVICE_FUNC+inline ConjugateReturnType+conjugate() const+{+  return ConjugateReturnType(derived());+}++/// \returns an expression of the complex conjugate of \c *this if Cond==true, returns derived() otherwise.+///+EIGEN_DOC_UNARY_ADDONS(conjugate,complex conjugate)+///+/// \sa conjugate()+template<bool Cond>+EIGEN_DEVICE_FUNC+inline typename internal::conditional<Cond,ConjugateReturnType,const Derived&>::type+conjugateIf() const+{+  typedef typename internal::conditional<Cond,ConjugateReturnType,const Derived&>::type ReturnType;+  return ReturnType(derived());+}++/// \returns a read-only expression of the real part of \c *this.+///+EIGEN_DOC_UNARY_ADDONS(real,real part function)+///+/// \sa imag()+EIGEN_DEVICE_FUNC+inline RealReturnType+real() const { return RealReturnType(derived()); }++/// \returns an read-only expression of the imaginary part of \c *this.+///+EIGEN_DOC_UNARY_ADDONS(imag,imaginary part function)+///+/// \sa real()+EIGEN_DEVICE_FUNC+inline const ImagReturnType+imag() const { return ImagReturnType(derived()); }++/// \brief Apply a unary operator coefficient-wise+/// \param[in]  func  Functor implementing the unary operator+/// \tparam  CustomUnaryOp Type of \a func+/// \returns An expression of a custom coefficient-wise unary operator \a func of *this+///+/// The function \c ptr_fun() from the C++ standard library can be used to make functors out of normal functions.+///+/// Example:+/// \include class_CwiseUnaryOp_ptrfun.cpp+/// Output: \verbinclude class_CwiseUnaryOp_ptrfun.out+///+/// Genuine functors allow for more possibilities, for instance it may contain a state.+///+/// Example:+/// \include class_CwiseUnaryOp.cpp+/// Output: \verbinclude class_CwiseUnaryOp.out+///+EIGEN_DOC_UNARY_ADDONS(unaryExpr,unary function)+///+/// \sa unaryViewExpr, binaryExpr, class CwiseUnaryOp+///+template<typename CustomUnaryOp>+EIGEN_DEVICE_FUNC+inline const CwiseUnaryOp<CustomUnaryOp, const Derived>+unaryExpr(const CustomUnaryOp& func = CustomUnaryOp()) const+{+  return CwiseUnaryOp<CustomUnaryOp, const Derived>(derived(), func);+}++/// \returns an expression of a custom coefficient-wise unary operator \a func of *this+///+/// The template parameter \a CustomUnaryOp is the type of the functor+/// of the custom unary operator.+///+/// Example:+/// \include class_CwiseUnaryOp.cpp+/// Output: \verbinclude class_CwiseUnaryOp.out+///+EIGEN_DOC_UNARY_ADDONS(unaryViewExpr,unary function)+///+/// \sa unaryExpr, binaryExpr class CwiseUnaryOp+///+template<typename CustomViewOp>+EIGEN_DEVICE_FUNC+inline const CwiseUnaryView<CustomViewOp, const Derived>+unaryViewExpr(const CustomViewOp& func = CustomViewOp()) const+{+  return CwiseUnaryView<CustomViewOp, const Derived>(derived(), func);+}++/// \returns a non const expression of the real part of \c *this.+///+EIGEN_DOC_UNARY_ADDONS(real,real part function)+///+/// \sa imag()+EIGEN_DEVICE_FUNC+inline NonConstRealReturnType+real() { return NonConstRealReturnType(derived()); }++/// \returns a non const expression of the imaginary part of \c *this.+///+EIGEN_DOC_UNARY_ADDONS(imag,imaginary part function)+///+/// \sa real()+EIGEN_DEVICE_FUNC+inline NonConstImagReturnType+imag() { return NonConstImagReturnType(derived()); }
+ cpp/Eigen/src/plugins/IndexedViewMethods.h view
@@ -0,0 +1,262 @@+// This file is part of Eigen, a lightweight C++ template library+// for linear algebra.+//+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>+//+// This Source Code Form is subject to the terms of the Mozilla+// Public License v. 2.0. If a copy of the MPL was not distributed+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.++#if !defined(EIGEN_PARSED_BY_DOXYGEN)++// This file is automatically included twice to generate const and non-const versions++#ifndef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS+#define EIGEN_INDEXED_VIEW_METHOD_CONST const+#define EIGEN_INDEXED_VIEW_METHOD_TYPE  ConstIndexedViewType+#else+#define EIGEN_INDEXED_VIEW_METHOD_CONST+#define EIGEN_INDEXED_VIEW_METHOD_TYPE IndexedViewType+#endif++#ifndef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS+protected:++// define some aliases to ease readability++template<typename Indices>+struct IvcRowType : public internal::IndexedViewCompatibleType<Indices,RowsAtCompileTime> {};++template<typename Indices>+struct IvcColType : public internal::IndexedViewCompatibleType<Indices,ColsAtCompileTime> {};++template<typename Indices>+struct IvcType : public internal::IndexedViewCompatibleType<Indices,SizeAtCompileTime> {};++typedef typename internal::IndexedViewCompatibleType<Index,1>::type IvcIndex;++template<typename Indices>+typename IvcRowType<Indices>::type+ivcRow(const Indices& indices) const {+  return internal::makeIndexedViewCompatible(indices, internal::variable_if_dynamic<Index,RowsAtCompileTime>(derived().rows()),Specialized);+}++template<typename Indices>+typename IvcColType<Indices>::type+ivcCol(const Indices& indices) const {+  return internal::makeIndexedViewCompatible(indices, internal::variable_if_dynamic<Index,ColsAtCompileTime>(derived().cols()),Specialized);+}++template<typename Indices>+typename IvcColType<Indices>::type+ivcSize(const Indices& indices) const {+  return internal::makeIndexedViewCompatible(indices, internal::variable_if_dynamic<Index,SizeAtCompileTime>(derived().size()),Specialized);+}++public:++#endif++template<typename RowIndices, typename ColIndices>+struct EIGEN_INDEXED_VIEW_METHOD_TYPE {+  typedef IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,+                      typename IvcRowType<RowIndices>::type,+                      typename IvcColType<ColIndices>::type> type;+};++// This is the generic version++template<typename RowIndices, typename ColIndices>+typename internal::enable_if<internal::valid_indexed_view_overload<RowIndices,ColIndices>::value+  && internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::ReturnAsIndexedView,+  typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type >::type+operator()(const RowIndices& rowIndices, const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST+{+  return typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type+            (derived(), ivcRow(rowIndices), ivcCol(colIndices));+}++// The following overload returns a Block<> object++template<typename RowIndices, typename ColIndices>+typename internal::enable_if<internal::valid_indexed_view_overload<RowIndices,ColIndices>::value+  && internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::ReturnAsBlock,+  typename internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::BlockType>::type+operator()(const RowIndices& rowIndices, const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST+{+  typedef typename internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::BlockType BlockType;+  typename IvcRowType<RowIndices>::type actualRowIndices = ivcRow(rowIndices);+  typename IvcColType<ColIndices>::type actualColIndices = ivcCol(colIndices);+  return BlockType(derived(),+                   internal::first(actualRowIndices),+                   internal::first(actualColIndices),+                   internal::size(actualRowIndices),+                   internal::size(actualColIndices));+}++// The following overload returns a Scalar++template<typename RowIndices, typename ColIndices>+typename internal::enable_if<internal::valid_indexed_view_overload<RowIndices,ColIndices>::value+  && internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::ReturnAsScalar,+  CoeffReturnType >::type+operator()(const RowIndices& rowIndices, const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST+{+  return Base::operator()(internal::eval_expr_given_size(rowIndices,rows()),internal::eval_expr_given_size(colIndices,cols()));+}++#if EIGEN_HAS_STATIC_ARRAY_TEMPLATE++// The following three overloads are needed to handle raw Index[N] arrays.++template<typename RowIndicesT, std::size_t RowIndicesN, typename ColIndices>+IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN],typename IvcColType<ColIndices>::type>+operator()(const RowIndicesT (&rowIndices)[RowIndicesN], const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST+{+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN],typename IvcColType<ColIndices>::type>+                    (derived(), rowIndices, ivcCol(colIndices));+}++template<typename RowIndices, typename ColIndicesT, std::size_t ColIndicesN>+IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcRowType<RowIndices>::type, const ColIndicesT (&)[ColIndicesN]>+operator()(const RowIndices& rowIndices, const ColIndicesT (&colIndices)[ColIndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST+{+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcRowType<RowIndices>::type,const ColIndicesT (&)[ColIndicesN]>+                    (derived(), ivcRow(rowIndices), colIndices);+}++template<typename RowIndicesT, std::size_t RowIndicesN, typename ColIndicesT, std::size_t ColIndicesN>+IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN], const ColIndicesT (&)[ColIndicesN]>+operator()(const RowIndicesT (&rowIndices)[RowIndicesN], const ColIndicesT (&colIndices)[ColIndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST+{+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN],const ColIndicesT (&)[ColIndicesN]>+                    (derived(), rowIndices, colIndices);+}++#endif // EIGEN_HAS_STATIC_ARRAY_TEMPLATE++// Overloads for 1D vectors/arrays++template<typename Indices>+typename internal::enable_if<+  IsRowMajor && (!(internal::get_compile_time_incr<typename IvcType<Indices>::type>::value==1 || internal::is_valid_index_type<Indices>::value)),+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,typename IvcType<Indices>::type> >::type+operator()(const Indices& indices) EIGEN_INDEXED_VIEW_METHOD_CONST+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,typename IvcType<Indices>::type>+            (derived(), IvcIndex(0), ivcCol(indices));+}++template<typename Indices>+typename internal::enable_if<+  (!IsRowMajor) && (!(internal::get_compile_time_incr<typename IvcType<Indices>::type>::value==1 || internal::is_valid_index_type<Indices>::value)),+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcType<Indices>::type,IvcIndex> >::type+operator()(const Indices& indices) EIGEN_INDEXED_VIEW_METHOD_CONST+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcType<Indices>::type,IvcIndex>+            (derived(), ivcRow(indices), IvcIndex(0));+}++template<typename Indices>+typename internal::enable_if<+  (internal::get_compile_time_incr<typename IvcType<Indices>::type>::value==1) && (!internal::is_valid_index_type<Indices>::value) && (!symbolic::is_symbolic<Indices>::value),+  VectorBlock<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,internal::array_size<Indices>::value> >::type+operator()(const Indices& indices) EIGEN_INDEXED_VIEW_METHOD_CONST+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  typename IvcType<Indices>::type actualIndices = ivcSize(indices);+  return VectorBlock<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,internal::array_size<Indices>::value>+            (derived(), internal::first(actualIndices), internal::size(actualIndices));+}++template<typename IndexType>+typename internal::enable_if<symbolic::is_symbolic<IndexType>::value, CoeffReturnType >::type+operator()(const IndexType& id) EIGEN_INDEXED_VIEW_METHOD_CONST+{+  return Base::operator()(internal::eval_expr_given_size(id,size()));+}++#if EIGEN_HAS_STATIC_ARRAY_TEMPLATE++template<typename IndicesT, std::size_t IndicesN>+typename internal::enable_if<IsRowMajor,+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,const IndicesT (&)[IndicesN]> >::type+operator()(const IndicesT (&indices)[IndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,const IndicesT (&)[IndicesN]>+            (derived(), IvcIndex(0), indices);+}++template<typename IndicesT, std::size_t IndicesN>+typename internal::enable_if<!IsRowMajor,+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const IndicesT (&)[IndicesN],IvcIndex> >::type+operator()(const IndicesT (&indices)[IndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST+{+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const IndicesT (&)[IndicesN],IvcIndex>+            (derived(), indices, IvcIndex(0));+}++#endif // EIGEN_HAS_STATIC_ARRAY_TEMPLATE++#undef EIGEN_INDEXED_VIEW_METHOD_CONST+#undef EIGEN_INDEXED_VIEW_METHOD_TYPE++#ifndef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS+#define EIGEN_INDEXED_VIEW_METHOD_2ND_PASS+#include "IndexedViewMethods.h"+#undef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS+#endif++#else // EIGEN_PARSED_BY_DOXYGEN++/**+  * \returns a generic submatrix view defined by the rows and columns indexed \a rowIndices and \a colIndices respectively.+  *+  * Each parameter must either be:+  *  - An integer indexing a single row or column+  *  - Eigen::all indexing the full set of respective rows or columns in increasing order+  *  - An ArithmeticSequence as returned by the Eigen::seq and Eigen::seqN functions+  *  - Any %Eigen's vector/array of integers or expressions+  *  - Plain C arrays: \c int[N]+  *  - And more generally any type exposing the following two member functions:+  * \code+  * <integral type> operator[](<integral type>) const;+  * <integral type> size() const;+  * \endcode+  * where \c <integral \c type>  stands for any integer type compatible with Eigen::Index (i.e. \c std::ptrdiff_t).+  *+  * The last statement implies compatibility with \c std::vector, \c std::valarray, \c std::array, many of the Range-v3's ranges, etc.+  *+  * If the submatrix can be represented using a starting position \c (i,j) and positive sizes \c (rows,columns), then this+  * method will returns a Block object after extraction of the relevant information from the passed arguments. This is the case+  * when all arguments are either:+  *  - An integer+  *  - Eigen::all+  *  - An ArithmeticSequence with compile-time increment strictly equal to 1, as returned by Eigen::seq(a,b), and Eigen::seqN(a,N).+  *+  * Otherwise a more general IndexedView<Derived,RowIndices',ColIndices'> object will be returned, after conversion of the inputs+  * to more suitable types \c RowIndices' and \c ColIndices'.+  *+  * For 1D vectors and arrays, you better use the operator()(const Indices&) overload, which behave the same way but taking a single parameter.+  *+  * See also this <a href="https://stackoverflow.com/questions/46110917/eigen-replicate-items-along-one-dimension-without-useless-allocations">question</a> and its answer for an example of how to duplicate coefficients.+  *+  * \sa operator()(const Indices&), class Block, class IndexedView, DenseBase::block(Index,Index,Index,Index)+  */+template<typename RowIndices, typename ColIndices>+IndexedView_or_Block+operator()(const RowIndices& rowIndices, const ColIndices& colIndices);++/** This is an overload of operator()(const RowIndices&, const ColIndices&) for 1D vectors or arrays+  *+  * \only_for_vectors+  */+template<typename Indices>+IndexedView_or_VectorBlock+operator()(const Indices& indices);++#endif  // EIGEN_PARSED_BY_DOXYGEN
+ cpp/Eigen/src/plugins/MatrixCwiseBinaryOps.h view
@@ -0,0 +1,152 @@+// This file is part of Eigen, a lightweight C++ template library+// for linear algebra.+//+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>+//+// This Source Code Form is subject to the terms of the Mozilla+// Public License v. 2.0. If a copy of the MPL was not distributed+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.++// This file is a base class plugin containing matrix specifics coefficient wise functions.++/** \returns an expression of the Schur product (coefficient wise product) of *this and \a other+  *+  * Example: \include MatrixBase_cwiseProduct.cpp+  * Output: \verbinclude MatrixBase_cwiseProduct.out+  *+  * \sa class CwiseBinaryOp, cwiseAbs2+  */+template<typename OtherDerived>+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)+cwiseProduct(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const+{+  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)(derived(), other.derived());+}++/** \returns an expression of the coefficient-wise == operator of *this and \a other+  *+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and+  * isMuchSmallerThan().+  *+  * Example: \include MatrixBase_cwiseEqual.cpp+  * Output: \verbinclude MatrixBase_cwiseEqual.out+  *+  * \sa cwiseNotEqual(), isApprox(), isMuchSmallerThan()+  */+template<typename OtherDerived>+EIGEN_DEVICE_FUNC+inline const CwiseBinaryOp<numext::equal_to<Scalar>, const Derived, const OtherDerived>+cwiseEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const+{+  return CwiseBinaryOp<numext::equal_to<Scalar>, const Derived, const OtherDerived>(derived(), other.derived());+}++/** \returns an expression of the coefficient-wise != operator of *this and \a other+  *+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and+  * isMuchSmallerThan().+  *+  * Example: \include MatrixBase_cwiseNotEqual.cpp+  * Output: \verbinclude MatrixBase_cwiseNotEqual.out+  *+  * \sa cwiseEqual(), isApprox(), isMuchSmallerThan()+  */+template<typename OtherDerived>+EIGEN_DEVICE_FUNC+inline const CwiseBinaryOp<numext::not_equal_to<Scalar>, const Derived, const OtherDerived>+cwiseNotEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const+{+  return CwiseBinaryOp<numext::not_equal_to<Scalar>, const Derived, const OtherDerived>(derived(), other.derived());+}++/** \returns an expression of the coefficient-wise min of *this and \a other+  *+  * Example: \include MatrixBase_cwiseMin.cpp+  * Output: \verbinclude MatrixBase_cwiseMin.out+  *+  * \sa class CwiseBinaryOp, max()+  */+template<typename OtherDerived>+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived, const OtherDerived>+cwiseMin(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const+{+  return CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived, const OtherDerived>(derived(), other.derived());+}++/** \returns an expression of the coefficient-wise min of *this and scalar \a other+  *+  * \sa class CwiseBinaryOp, min()+  */+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived, const ConstantReturnType>+cwiseMin(const Scalar &other) const+{+  return cwiseMin(Derived::Constant(rows(), cols(), other));+}++/** \returns an expression of the coefficient-wise max of *this and \a other+  *+  * Example: \include MatrixBase_cwiseMax.cpp+  * Output: \verbinclude MatrixBase_cwiseMax.out+  *+  * \sa class CwiseBinaryOp, min()+  */+template<typename OtherDerived>+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived, const OtherDerived>+cwiseMax(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const+{+  return CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived, const OtherDerived>(derived(), other.derived());+}++/** \returns an expression of the coefficient-wise max of *this and scalar \a other+  *+  * \sa class CwiseBinaryOp, min()+  */+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived, const ConstantReturnType>+cwiseMax(const Scalar &other) const+{+  return cwiseMax(Derived::Constant(rows(), cols(), other));+}+++/** \returns an expression of the coefficient-wise quotient of *this and \a other+  *+  * Example: \include MatrixBase_cwiseQuotient.cpp+  * Output: \verbinclude MatrixBase_cwiseQuotient.out+  *+  * \sa class CwiseBinaryOp, cwiseProduct(), cwiseInverse()+  */+template<typename OtherDerived>+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const Derived, const OtherDerived>+cwiseQuotient(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const+{+  return CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const Derived, const OtherDerived>(derived(), other.derived());+}++typedef CwiseBinaryOp<internal::scalar_cmp_op<Scalar,Scalar,internal::cmp_EQ>, const Derived, const ConstantReturnType> CwiseScalarEqualReturnType;++/** \returns an expression of the coefficient-wise == operator of \c *this and a scalar \a s+  *+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and+  * isMuchSmallerThan().+  *+  * \sa cwiseEqual(const MatrixBase<OtherDerived> &) const+  */+EIGEN_DEVICE_FUNC+inline const CwiseScalarEqualReturnType+cwiseEqual(const Scalar& s) const+{+  return CwiseScalarEqualReturnType(derived(), Derived::Constant(rows(), cols(), s), internal::scalar_cmp_op<Scalar,Scalar,internal::cmp_EQ>());+}
+ cpp/Eigen/src/plugins/MatrixCwiseUnaryOps.h view
@@ -0,0 +1,95 @@+// This file is part of Eigen, a lightweight C++ template library+// for linear algebra.+//+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>+//+// This Source Code Form is subject to the terms of the Mozilla+// Public License v. 2.0. If a copy of the MPL was not distributed+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.++// This file is included into the body of the base classes supporting matrix specific coefficient-wise functions.+// This include MatrixBase and SparseMatrixBase.+++typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> CwiseAbsReturnType;+typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> CwiseAbs2ReturnType;+typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived> CwiseArgReturnType;+typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> CwiseSqrtReturnType;+typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived> CwiseSignReturnType;+typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> CwiseInverseReturnType;++/// \returns an expression of the coefficient-wise absolute value of \c *this+///+/// Example: \include MatrixBase_cwiseAbs.cpp+/// Output: \verbinclude MatrixBase_cwiseAbs.out+///+EIGEN_DOC_UNARY_ADDONS(cwiseAbs,absolute value)+///+/// \sa cwiseAbs2()+///+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const CwiseAbsReturnType+cwiseAbs() const { return CwiseAbsReturnType(derived()); }++/// \returns an expression of the coefficient-wise squared absolute value of \c *this+///+/// Example: \include MatrixBase_cwiseAbs2.cpp+/// Output: \verbinclude MatrixBase_cwiseAbs2.out+///+EIGEN_DOC_UNARY_ADDONS(cwiseAbs2,squared absolute value)+///+/// \sa cwiseAbs()+///+EIGEN_DEVICE_FUNC+EIGEN_STRONG_INLINE const CwiseAbs2ReturnType+cwiseAbs2() const { return CwiseAbs2ReturnType(derived()); }++/// \returns an expression of the coefficient-wise square root of *this.+///+/// Example: \include MatrixBase_cwiseSqrt.cpp+/// Output: \verbinclude MatrixBase_cwiseSqrt.out+///+EIGEN_DOC_UNARY_ADDONS(cwiseSqrt,square-root)+///+/// \sa cwisePow(), cwiseSquare()+///+EIGEN_DEVICE_FUNC+inline const CwiseSqrtReturnType+cwiseSqrt() const { return CwiseSqrtReturnType(derived()); }++/// \returns an expression of the coefficient-wise signum of *this.+///+/// Example: \include MatrixBase_cwiseSign.cpp+/// Output: \verbinclude MatrixBase_cwiseSign.out+///+EIGEN_DOC_UNARY_ADDONS(cwiseSign,sign function)+///+EIGEN_DEVICE_FUNC+inline const CwiseSignReturnType+cwiseSign() const { return CwiseSignReturnType(derived()); }+++/// \returns an expression of the coefficient-wise inverse of *this.+///+/// Example: \include MatrixBase_cwiseInverse.cpp+/// Output: \verbinclude MatrixBase_cwiseInverse.out+///+EIGEN_DOC_UNARY_ADDONS(cwiseInverse,inverse)+///+/// \sa cwiseProduct()+///+EIGEN_DEVICE_FUNC+inline const CwiseInverseReturnType+cwiseInverse() const { return CwiseInverseReturnType(derived()); }++/// \returns an expression of the coefficient-wise phase angle of \c *this+///+/// Example: \include MatrixBase_cwiseArg.cpp+/// Output: \verbinclude MatrixBase_cwiseArg.out+///+EIGEN_DOC_UNARY_ADDONS(cwiseArg,arg)++EIGEN_DEVICE_FUNC+inline const CwiseArgReturnType+cwiseArg() const { return CwiseArgReturnType(derived()); }
+ cpp/Eigen/src/plugins/ReshapedMethods.h view
@@ -0,0 +1,149 @@++#ifdef EIGEN_PARSED_BY_DOXYGEN++/// \returns an expression of \c *this with reshaped sizes.+///+/// \param nRows the number of rows in the reshaped expression, specified at either run-time or compile-time, or AutoSize+/// \param nCols the number of columns in the reshaped expression, specified at either run-time or compile-time, or AutoSize+/// \tparam Order specifies whether the coefficients should be processed in column-major-order (ColMajor), in row-major-order (RowMajor),+///               or follows the \em natural order of the nested expression (AutoOrder). The default is ColMajor.+/// \tparam NRowsType the type of the value handling the number of rows, typically Index.+/// \tparam NColsType the type of the value handling the number of columns, typically Index.+///+/// Dynamic size example: \include MatrixBase_reshaped_int_int.cpp+/// Output: \verbinclude MatrixBase_reshaped_int_int.out+///+/// The number of rows \a nRows and columns \a nCols can also be specified at compile-time by passing Eigen::fix<N>,+/// or Eigen::fix<N>(n) as arguments. In the later case, \c n plays the role of a runtime fallback value in case \c N equals Eigen::Dynamic.+/// Here is an example with a fixed number of rows and columns:+/// \include MatrixBase_reshaped_fixed.cpp+/// Output: \verbinclude MatrixBase_reshaped_fixed.out+///+/// Finally, one of the sizes parameter can be automatically deduced from the other one by passing AutoSize as in the following example:+/// \include MatrixBase_reshaped_auto.cpp+/// Output: \verbinclude MatrixBase_reshaped_auto.out+/// AutoSize does preserve compile-time sizes when possible, i.e., when the sizes of the input are known at compile time \b and+/// that the other size is passed at compile-time using Eigen::fix<N> as above.+///+/// \sa class Reshaped, fix, fix<N>(int)+///+template<int Order = ColMajor, typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC+inline Reshaped<Derived,...>+reshaped(NRowsType nRows, NColsType nCols);++/// This is the const version of reshaped(NRowsType,NColsType).+template<int Order = ColMajor, typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC+inline const Reshaped<const Derived,...>+reshaped(NRowsType nRows, NColsType nCols) const;++/// \returns an expression of \c *this with columns (or rows) stacked to a linear column vector+///+/// \tparam Order specifies whether the coefficients should be processed in column-major-order (ColMajor), in row-major-order (RowMajor),+///               or follows the \em natural order of the nested expression (AutoOrder). The default is ColMajor.+///+/// This overloads is essentially a shortcut for `A.reshaped<Order>(AutoSize,fix<1>)`.+///+/// - If `Order==ColMajor` (the default), then it returns a column-vector from the stacked columns of \c *this.+/// - If `Order==RowMajor`, then it returns a column-vector from the stacked rows of \c *this.+/// - If `Order==AutoOrder`, then it returns a column-vector with elements stacked following the storage order of \c *this.+///   This mode is the recommended one when the particular ordering of the element is not relevant.+///+/// Example:+/// \include MatrixBase_reshaped_to_vector.cpp+/// Output: \verbinclude MatrixBase_reshaped_to_vector.out+///+/// If you want more control, you can still fall back to reshaped(NRowsType,NColsType).+///+/// \sa reshaped(NRowsType,NColsType), class Reshaped+///+template<int Order = ColMajor>+EIGEN_DEVICE_FUNC+inline Reshaped<Derived,...>+reshaped();++/// This is the const version of reshaped().+template<int Order = ColMajor>+EIGEN_DEVICE_FUNC+inline const Reshaped<const Derived,...>+reshaped() const;++#else++// This file is automatically included twice to generate const and non-const versions++#ifndef EIGEN_RESHAPED_METHOD_2ND_PASS+#define EIGEN_RESHAPED_METHOD_CONST const+#else+#define EIGEN_RESHAPED_METHOD_CONST+#endif++#ifndef EIGEN_RESHAPED_METHOD_2ND_PASS++// This part is included once++#endif++template<typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC+inline Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,+                internal::get_compiletime_reshape_size<NRowsType,NColsType,SizeAtCompileTime>::value,+                internal::get_compiletime_reshape_size<NColsType,NRowsType,SizeAtCompileTime>::value>+reshaped(NRowsType nRows, NColsType nCols) EIGEN_RESHAPED_METHOD_CONST+{+  return Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,+                  internal::get_compiletime_reshape_size<NRowsType,NColsType,SizeAtCompileTime>::value,+                  internal::get_compiletime_reshape_size<NColsType,NRowsType,SizeAtCompileTime>::value>+                (derived(),+                 internal::get_runtime_reshape_size(nRows,internal::get_runtime_value(nCols),size()),+                 internal::get_runtime_reshape_size(nCols,internal::get_runtime_value(nRows),size()));+}++template<int Order, typename NRowsType, typename NColsType>+EIGEN_DEVICE_FUNC+inline Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,+                internal::get_compiletime_reshape_size<NRowsType,NColsType,SizeAtCompileTime>::value,+                internal::get_compiletime_reshape_size<NColsType,NRowsType,SizeAtCompileTime>::value,+                internal::get_compiletime_reshape_order<Flags,Order>::value>+reshaped(NRowsType nRows, NColsType nCols) EIGEN_RESHAPED_METHOD_CONST+{+  return Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,+                  internal::get_compiletime_reshape_size<NRowsType,NColsType,SizeAtCompileTime>::value,+                  internal::get_compiletime_reshape_size<NColsType,NRowsType,SizeAtCompileTime>::value,+                  internal::get_compiletime_reshape_order<Flags,Order>::value>+                (derived(),+                 internal::get_runtime_reshape_size(nRows,internal::get_runtime_value(nCols),size()),+                 internal::get_runtime_reshape_size(nCols,internal::get_runtime_value(nRows),size()));+}++// Views as linear vectors++EIGEN_DEVICE_FUNC+inline Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,SizeAtCompileTime,1>+reshaped() EIGEN_RESHAPED_METHOD_CONST+{+  return Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,SizeAtCompileTime,1>(derived(),size(),1);+}++template<int Order>+EIGEN_DEVICE_FUNC+inline Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived, SizeAtCompileTime, 1,+                internal::get_compiletime_reshape_order<Flags,Order>::value>+reshaped() EIGEN_RESHAPED_METHOD_CONST+{+  EIGEN_STATIC_ASSERT(Order==RowMajor || Order==ColMajor || Order==AutoOrder, INVALID_TEMPLATE_PARAMETER);+  return Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived, SizeAtCompileTime, 1,+                  internal::get_compiletime_reshape_order<Flags,Order>::value>+                (derived(), size(), 1);+}++#undef EIGEN_RESHAPED_METHOD_CONST++#ifndef EIGEN_RESHAPED_METHOD_2ND_PASS+#define EIGEN_RESHAPED_METHOD_2ND_PASS+#include "ReshapedMethods.h"+#undef EIGEN_RESHAPED_METHOD_2ND_PASS+#endif++#endif // EIGEN_PARSED_BY_DOXYGEN
numerical-integration.cabal view
@@ -1,6 +1,6 @@ cabal-version:       2.2 name:                numerical-integration-version:             0.1.0.1+version:             0.1.0.2 synopsis:            Numerical integration. description:         One-dimensional numerical integration using the 'NumericalIntegration' C++ library. homepage:            https://github.com/stla/numerical-integration#readme@@ -243,6 +243,15 @@                      , cpp/Eigen/src/misc/Kernel.h                      , cpp/Eigen/src/misc/lapacke.h                      , cpp/Eigen/src/misc/RealSvd2x2.h+                     , cpp/Eigen/src/plugins/ArrayCwiseBinaryOps.h+                     , cpp/Eigen/src/plugins/ArrayCwiseUnaryOps.h+                     , cpp/Eigen/src/plugins/BlockMethods.h+                     , cpp/Eigen/src/plugins/CommonCwiseBinaryOps.h+                     , cpp/Eigen/src/plugins/CommonCwiseUnaryOps.h+                     , cpp/Eigen/src/plugins/IndexedViewMethods.h+                     , cpp/Eigen/src/plugins/MatrixCwiseBinaryOps.h+                     , cpp/Eigen/src/plugins/MatrixCwiseUnaryOps.h+                     , cpp/Eigen/src/plugins/ReshapedMethods.h                      , cpp/Eigen/src/QR/ColPivHouseholderQR.h                      , cpp/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h                      , cpp/Eigen/src/QR/CompleteOrthogonalDecomposition.h