Eigne Matrix Class Library
Dependents: Eigen_test Odometry_test AttitudeEstimation_usingTicker MPU9250_Quaternion_Binary_Serial ... more
CwiseNullaryOp.h
00001 // This file is part of Eigen, a lightweight C++ template library 00002 // for linear algebra. 00003 // 00004 // Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr> 00005 // 00006 // This Source Code Form is subject to the terms of the Mozilla 00007 // Public License v. 2.0. If a copy of the MPL was not distributed 00008 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 00009 00010 #ifndef EIGEN_CWISE_NULLARY_OP_H 00011 #define EIGEN_CWISE_NULLARY_OP_H 00012 00013 namespace Eigen { 00014 00015 /** \class CwiseNullaryOp 00016 * \ingroup Core_Module 00017 * 00018 * \brief Generic expression of a matrix where all coefficients are defined by a functor 00019 * 00020 * \param NullaryOp template functor implementing the operator 00021 * \param PlainObjectType the underlying plain matrix/array type 00022 * 00023 * This class represents an expression of a generic nullary operator. 00024 * It is the return type of the Ones(), Zero(), Constant(), Identity() and Random() methods, 00025 * and most of the time this is the only way it is used. 00026 * 00027 * However, if you want to write a function returning such an expression, you 00028 * will need to use this class. 00029 * 00030 * \sa class CwiseUnaryOp, class CwiseBinaryOp, DenseBase::NullaryExpr() 00031 */ 00032 00033 namespace internal { 00034 template<typename NullaryOp, typename PlainObjectType> 00035 struct traits<CwiseNullaryOp<NullaryOp, PlainObjectType> > : traits<PlainObjectType> 00036 { 00037 enum { 00038 Flags = (traits<PlainObjectType>::Flags 00039 & ( HereditaryBits 00040 | (functor_has_linear_access<NullaryOp>::ret ? LinearAccessBit : 0) 00041 | (functor_traits<NullaryOp>::PacketAccess ? PacketAccessBit : 0))) 00042 | (functor_traits<NullaryOp>::IsRepeatable ? 0 : EvalBeforeNestingBit), 00043 CoeffReadCost = functor_traits<NullaryOp>::Cost 00044 }; 00045 }; 00046 } 00047 00048 template<typename NullaryOp, typename PlainObjectType> 00049 class CwiseNullaryOp : internal::no_assignment_operator, 00050 public internal::dense_xpr_base< CwiseNullaryOp<NullaryOp, PlainObjectType> >::type 00051 { 00052 public: 00053 00054 typedef typename internal::dense_xpr_base<CwiseNullaryOp>::type Base; 00055 EIGEN_DENSE_PUBLIC_INTERFACE(CwiseNullaryOp) 00056 00057 CwiseNullaryOp(Index nbRows, Index nbCols, const NullaryOp& func = NullaryOp()) 00058 : m_rows(nbRows), m_cols(nbCols), m_functor(func) 00059 { 00060 eigen_assert(nbRows >= 0 00061 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == nbRows) 00062 && nbCols >= 0 00063 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == nbCols)); 00064 } 00065 00066 EIGEN_STRONG_INLINE Index rows() const { return m_rows.value(); } 00067 EIGEN_STRONG_INLINE Index cols() const { return m_cols.value(); } 00068 00069 EIGEN_STRONG_INLINE const Scalar coeff(Index rowId, Index colId) const 00070 { 00071 return m_functor(rowId, colId); 00072 } 00073 00074 template<int LoadMode> 00075 EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const 00076 { 00077 return m_functor.packetOp(rowId, colId); 00078 } 00079 00080 EIGEN_STRONG_INLINE const Scalar coeff(Index index) const 00081 { 00082 return m_functor(index); 00083 } 00084 00085 template<int LoadMode> 00086 EIGEN_STRONG_INLINE PacketScalar packet(Index index) const 00087 { 00088 return m_functor.packetOp(index); 00089 } 00090 00091 /** \returns the functor representing the nullary operation */ 00092 const NullaryOp& functor() const { return m_functor; } 00093 00094 protected: 00095 const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows; 00096 const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols; 00097 const NullaryOp m_functor; 00098 }; 00099 00100 00101 /** \returns an expression of a matrix defined by a custom functor \a func 00102 * 00103 * The parameters \a rows and \a cols are the number of rows and of columns of 00104 * the returned matrix. Must be compatible with this MatrixBase type. 00105 * 00106 * This variant is meant to be used for dynamic-size matrix types. For fixed-size types, 00107 * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used 00108 * instead. 00109 * 00110 * The template parameter \a CustomNullaryOp is the type of the functor. 00111 * 00112 * \sa class CwiseNullaryOp 00113 */ 00114 template<typename Derived> 00115 template<typename CustomNullaryOp> 00116 EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, Derived> 00117 DenseBase<Derived>::NullaryExpr(Index rows, Index cols, const CustomNullaryOp& func) 00118 { 00119 return CwiseNullaryOp<CustomNullaryOp, Derived>(rows, cols, func); 00120 } 00121 00122 /** \returns an expression of a matrix defined by a custom functor \a func 00123 * 00124 * The parameter \a size is the size of the returned vector. 00125 * Must be compatible with this MatrixBase type. 00126 * 00127 * \only_for_vectors 00128 * 00129 * This variant is meant to be used for dynamic-size vector types. For fixed-size types, 00130 * it is redundant to pass \a size as argument, so Zero() should be used 00131 * instead. 00132 * 00133 * The template parameter \a CustomNullaryOp is the type of the functor. 00134 * 00135 * \sa class CwiseNullaryOp 00136 */ 00137 template<typename Derived> 00138 template<typename CustomNullaryOp> 00139 EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, Derived> 00140 DenseBase<Derived>::NullaryExpr(Index size, const CustomNullaryOp& func) 00141 { 00142 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 00143 if(RowsAtCompileTime == 1) return CwiseNullaryOp<CustomNullaryOp, Derived>(1, size, func); 00144 else return CwiseNullaryOp<CustomNullaryOp, Derived>(size, 1, func); 00145 } 00146 00147 /** \returns an expression of a matrix defined by a custom functor \a func 00148 * 00149 * This variant is only for fixed-size DenseBase types. For dynamic-size types, you 00150 * need to use the variants taking size arguments. 00151 * 00152 * The template parameter \a CustomNullaryOp is the type of the functor. 00153 * 00154 * \sa class CwiseNullaryOp 00155 */ 00156 template<typename Derived> 00157 template<typename CustomNullaryOp> 00158 EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, Derived> 00159 DenseBase<Derived>::NullaryExpr(const CustomNullaryOp& func) 00160 { 00161 return CwiseNullaryOp<CustomNullaryOp, Derived>(RowsAtCompileTime, ColsAtCompileTime, func); 00162 } 00163 00164 /** \returns an expression of a constant matrix of value \a value 00165 * 00166 * The parameters \a nbRows and \a nbCols are the number of rows and of columns of 00167 * the returned matrix. Must be compatible with this DenseBase type. 00168 * 00169 * This variant is meant to be used for dynamic-size matrix types. For fixed-size types, 00170 * it is redundant to pass \a nbRows and \a nbCols as arguments, so Zero() should be used 00171 * instead. 00172 * 00173 * The template parameter \a CustomNullaryOp is the type of the functor. 00174 * 00175 * \sa class CwiseNullaryOp 00176 */ 00177 template<typename Derived> 00178 EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType 00179 DenseBase<Derived>::Constant(Index nbRows, Index nbCols, const Scalar& value) 00180 { 00181 return DenseBase<Derived>::NullaryExpr(nbRows, nbCols, internal::scalar_constant_op<Scalar>(value)); 00182 } 00183 00184 /** \returns an expression of a constant matrix of value \a value 00185 * 00186 * The parameter \a size is the size of the returned vector. 00187 * Must be compatible with this DenseBase type. 00188 * 00189 * \only_for_vectors 00190 * 00191 * This variant is meant to be used for dynamic-size vector types. For fixed-size types, 00192 * it is redundant to pass \a size as argument, so Zero() should be used 00193 * instead. 00194 * 00195 * The template parameter \a CustomNullaryOp is the type of the functor. 00196 * 00197 * \sa class CwiseNullaryOp 00198 */ 00199 template<typename Derived> 00200 EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType 00201 DenseBase<Derived>::Constant(Index size, const Scalar& value) 00202 { 00203 return DenseBase<Derived>::NullaryExpr(size, internal::scalar_constant_op<Scalar>(value)); 00204 } 00205 00206 /** \returns an expression of a constant matrix of value \a value 00207 * 00208 * This variant is only for fixed-size DenseBase types. For dynamic-size types, you 00209 * need to use the variants taking size arguments. 00210 * 00211 * The template parameter \a CustomNullaryOp is the type of the functor. 00212 * 00213 * \sa class CwiseNullaryOp 00214 */ 00215 template<typename Derived> 00216 EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType 00217 DenseBase<Derived>::Constant(const Scalar& value) 00218 { 00219 EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) 00220 return DenseBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_constant_op<Scalar>(value)); 00221 } 00222 00223 /** 00224 * \brief Sets a linearly space vector. 00225 * 00226 * The function generates 'size' equally spaced values in the closed interval [low,high]. 00227 * This particular version of LinSpaced() uses sequential access, i.e. vector access is 00228 * assumed to be a(0), a(1), ..., a(size). This assumption allows for better vectorization 00229 * and yields faster code than the random access version. 00230 * 00231 * When size is set to 1, a vector of length 1 containing 'high' is returned. 00232 * 00233 * \only_for_vectors 00234 * 00235 * Example: \include DenseBase_LinSpaced_seq.cpp 00236 * Output: \verbinclude DenseBase_LinSpaced_seq.out 00237 * 00238 * \sa setLinSpaced(Index,const Scalar&,const Scalar&), LinSpaced(Index,Scalar,Scalar), CwiseNullaryOp 00239 */ 00240 template<typename Derived> 00241 EIGEN_STRONG_INLINE const typename DenseBase<Derived>::SequentialLinSpacedReturnType 00242 DenseBase<Derived>::LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high) 00243 { 00244 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 00245 return DenseBase<Derived>::NullaryExpr(size, internal::linspaced_op<Scalar,false>(low,high,size)); 00246 } 00247 00248 /** 00249 * \copydoc DenseBase::LinSpaced(Sequential_t, Index, const Scalar&, const Scalar&) 00250 * Special version for fixed size types which does not require the size parameter. 00251 */ 00252 template<typename Derived> 00253 EIGEN_STRONG_INLINE const typename DenseBase<Derived>::SequentialLinSpacedReturnType 00254 DenseBase<Derived>::LinSpaced(Sequential_t, const Scalar& low, const Scalar& high) 00255 { 00256 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 00257 EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) 00258 return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op<Scalar,false>(low,high,Derived::SizeAtCompileTime)); 00259 } 00260 00261 /** 00262 * \brief Sets a linearly space vector. 00263 * 00264 * The function generates 'size' equally spaced values in the closed interval [low,high]. 00265 * When size is set to 1, a vector of length 1 containing 'high' is returned. 00266 * 00267 * \only_for_vectors 00268 * 00269 * Example: \include DenseBase_LinSpaced.cpp 00270 * Output: \verbinclude DenseBase_LinSpaced.out 00271 * 00272 * \sa setLinSpaced(Index,const Scalar&,const Scalar&), LinSpaced(Sequential_t,Index,const Scalar&,const Scalar&,Index), CwiseNullaryOp 00273 */ 00274 template<typename Derived> 00275 EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType 00276 DenseBase<Derived>::LinSpaced(Index size, const Scalar& low, const Scalar& high) 00277 { 00278 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 00279 return DenseBase<Derived>::NullaryExpr(size, internal::linspaced_op<Scalar,true>(low,high,size)); 00280 } 00281 00282 /** 00283 * \copydoc DenseBase::LinSpaced(Index, const Scalar&, const Scalar&) 00284 * Special version for fixed size types which does not require the size parameter. 00285 */ 00286 template<typename Derived> 00287 EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType 00288 DenseBase<Derived>::LinSpaced(const Scalar& low, const Scalar& high) 00289 { 00290 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 00291 EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) 00292 return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op<Scalar,true>(low,high,Derived::SizeAtCompileTime)); 00293 } 00294 00295 /** \returns true if all coefficients in this matrix are approximately equal to \a val, to within precision \a prec */ 00296 template<typename Derived> 00297 bool DenseBase<Derived>::isApproxToConstant 00298 (const Scalar& val, const RealScalar& prec) const 00299 { 00300 for(Index j = 0; j < cols(); ++j) 00301 for(Index i = 0; i < rows(); ++i) 00302 if(!internal::isApprox(this->coeff(i, j), val, prec)) 00303 return false; 00304 return true; 00305 } 00306 00307 /** This is just an alias for isApproxToConstant(). 00308 * 00309 * \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */ 00310 template<typename Derived> 00311 bool DenseBase<Derived>::isConstant 00312 (const Scalar& val, const RealScalar& prec) const 00313 { 00314 return isApproxToConstant(val, prec); 00315 } 00316 00317 /** Alias for setConstant(): sets all coefficients in this expression to \a val. 00318 * 00319 * \sa setConstant(), Constant(), class CwiseNullaryOp 00320 */ 00321 template<typename Derived> 00322 EIGEN_STRONG_INLINE void DenseBase<Derived>::fill(const Scalar& val) 00323 { 00324 setConstant(val); 00325 } 00326 00327 /** Sets all coefficients in this expression to \a value. 00328 * 00329 * \sa fill(), setConstant(Index,const Scalar&), setConstant(Index,Index,const Scalar&), setZero(), setOnes(), Constant(), class CwiseNullaryOp, setZero(), setOnes() 00330 */ 00331 template<typename Derived> 00332 EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setConstant(const Scalar& val) 00333 { 00334 return derived() = Constant(rows(), cols(), val); 00335 } 00336 00337 /** Resizes to the given \a size, and sets all coefficients in this expression to the given \a value. 00338 * 00339 * \only_for_vectors 00340 * 00341 * Example: \include Matrix_setConstant_int.cpp 00342 * Output: \verbinclude Matrix_setConstant_int.out 00343 * 00344 * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&) 00345 */ 00346 template<typename Derived> 00347 EIGEN_STRONG_INLINE Derived& 00348 PlainObjectBase<Derived>::setConstant(Index size, const Scalar& val) 00349 { 00350 resize(size); 00351 return setConstant(val); 00352 } 00353 00354 /** Resizes to the given size, and sets all coefficients in this expression to the given \a value. 00355 * 00356 * \param nbRows the new number of rows 00357 * \param nbCols the new number of columns 00358 * \param val the value to which all coefficients are set 00359 * 00360 * Example: \include Matrix_setConstant_int_int.cpp 00361 * Output: \verbinclude Matrix_setConstant_int_int.out 00362 * 00363 * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&) 00364 */ 00365 template<typename Derived> 00366 EIGEN_STRONG_INLINE Derived& 00367 PlainObjectBase<Derived>::setConstant(Index nbRows, Index nbCols, const Scalar& val) 00368 { 00369 resize(nbRows, nbCols); 00370 return setConstant(val); 00371 } 00372 00373 /** 00374 * \brief Sets a linearly space vector. 00375 * 00376 * The function generates 'size' equally spaced values in the closed interval [low,high]. 00377 * When size is set to 1, a vector of length 1 containing 'high' is returned. 00378 * 00379 * \only_for_vectors 00380 * 00381 * Example: \include DenseBase_setLinSpaced.cpp 00382 * Output: \verbinclude DenseBase_setLinSpaced.out 00383 * 00384 * \sa CwiseNullaryOp 00385 */ 00386 template<typename Derived> 00387 EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setLinSpaced(Index newSize, const Scalar& low, const Scalar& high) 00388 { 00389 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 00390 return derived() = Derived::NullaryExpr(newSize, internal::linspaced_op<Scalar,false>(low,high,newSize)); 00391 } 00392 00393 /** 00394 * \brief Sets a linearly space vector. 00395 * 00396 * The function fill *this with equally spaced values in the closed interval [low,high]. 00397 * When size is set to 1, a vector of length 1 containing 'high' is returned. 00398 * 00399 * \only_for_vectors 00400 * 00401 * \sa setLinSpaced(Index, const Scalar&, const Scalar&), CwiseNullaryOp 00402 */ 00403 template<typename Derived> 00404 EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setLinSpaced(const Scalar& low, const Scalar& high) 00405 { 00406 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 00407 return setLinSpaced(size(), low, high); 00408 } 00409 00410 // zero: 00411 00412 /** \returns an expression of a zero matrix. 00413 * 00414 * The parameters \a rows and \a cols are the number of rows and of columns of 00415 * the returned matrix. Must be compatible with this MatrixBase type. 00416 * 00417 * This variant is meant to be used for dynamic-size matrix types. For fixed-size types, 00418 * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used 00419 * instead. 00420 * 00421 * Example: \include MatrixBase_zero_int_int.cpp 00422 * Output: \verbinclude MatrixBase_zero_int_int.out 00423 * 00424 * \sa Zero(), Zero(Index) 00425 */ 00426 template<typename Derived> 00427 EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType 00428 DenseBase<Derived>::Zero(Index nbRows, Index nbCols) 00429 { 00430 return Constant(nbRows, nbCols, Scalar(0)); 00431 } 00432 00433 /** \returns an expression of a zero vector. 00434 * 00435 * The parameter \a size is the size of the returned vector. 00436 * Must be compatible with this MatrixBase type. 00437 * 00438 * \only_for_vectors 00439 * 00440 * This variant is meant to be used for dynamic-size vector types. For fixed-size types, 00441 * it is redundant to pass \a size as argument, so Zero() should be used 00442 * instead. 00443 * 00444 * Example: \include MatrixBase_zero_int.cpp 00445 * Output: \verbinclude MatrixBase_zero_int.out 00446 * 00447 * \sa Zero(), Zero(Index,Index) 00448 */ 00449 template<typename Derived> 00450 EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType 00451 DenseBase<Derived>::Zero(Index size) 00452 { 00453 return Constant(size, Scalar(0)); 00454 } 00455 00456 /** \returns an expression of a fixed-size zero matrix or vector. 00457 * 00458 * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you 00459 * need to use the variants taking size arguments. 00460 * 00461 * Example: \include MatrixBase_zero.cpp 00462 * Output: \verbinclude MatrixBase_zero.out 00463 * 00464 * \sa Zero(Index), Zero(Index,Index) 00465 */ 00466 template<typename Derived> 00467 EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType 00468 DenseBase<Derived>::Zero() 00469 { 00470 return Constant(Scalar(0)); 00471 } 00472 00473 /** \returns true if *this is approximately equal to the zero matrix, 00474 * within the precision given by \a prec. 00475 * 00476 * Example: \include MatrixBase_isZero.cpp 00477 * Output: \verbinclude MatrixBase_isZero.out 00478 * 00479 * \sa class CwiseNullaryOp, Zero() 00480 */ 00481 template<typename Derived> 00482 bool DenseBase<Derived>::isZero(const RealScalar& prec) const 00483 { 00484 for(Index j = 0; j < cols(); ++j) 00485 for(Index i = 0; i < rows(); ++i) 00486 if(!internal::isMuchSmallerThan(this->coeff(i, j), static_cast<Scalar>(1), prec)) 00487 return false; 00488 return true; 00489 } 00490 00491 /** Sets all coefficients in this expression to zero. 00492 * 00493 * Example: \include MatrixBase_setZero.cpp 00494 * Output: \verbinclude MatrixBase_setZero.out 00495 * 00496 * \sa class CwiseNullaryOp, Zero() 00497 */ 00498 template<typename Derived> 00499 EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setZero() 00500 { 00501 return setConstant(Scalar(0)); 00502 } 00503 00504 /** Resizes to the given \a size, and sets all coefficients in this expression to zero. 00505 * 00506 * \only_for_vectors 00507 * 00508 * Example: \include Matrix_setZero_int.cpp 00509 * Output: \verbinclude Matrix_setZero_int.out 00510 * 00511 * \sa DenseBase::setZero(), setZero(Index,Index), class CwiseNullaryOp, DenseBase::Zero() 00512 */ 00513 template<typename Derived> 00514 EIGEN_STRONG_INLINE Derived& 00515 PlainObjectBase<Derived>::setZero(Index newSize) 00516 { 00517 resize(newSize); 00518 return setConstant(Scalar(0)); 00519 } 00520 00521 /** Resizes to the given size, and sets all coefficients in this expression to zero. 00522 * 00523 * \param nbRows the new number of rows 00524 * \param nbCols the new number of columns 00525 * 00526 * Example: \include Matrix_setZero_int_int.cpp 00527 * Output: \verbinclude Matrix_setZero_int_int.out 00528 * 00529 * \sa DenseBase::setZero(), setZero(Index), class CwiseNullaryOp, DenseBase::Zero() 00530 */ 00531 template<typename Derived> 00532 EIGEN_STRONG_INLINE Derived& 00533 PlainObjectBase<Derived>::setZero(Index nbRows, Index nbCols) 00534 { 00535 resize(nbRows, nbCols); 00536 return setConstant(Scalar(0)); 00537 } 00538 00539 // ones: 00540 00541 /** \returns an expression of a matrix where all coefficients equal one. 00542 * 00543 * The parameters \a nbRows and \a nbCols are the number of rows and of columns of 00544 * the returned matrix. Must be compatible with this MatrixBase type. 00545 * 00546 * This variant is meant to be used for dynamic-size matrix types. For fixed-size types, 00547 * it is redundant to pass \a rows and \a cols as arguments, so Ones() should be used 00548 * instead. 00549 * 00550 * Example: \include MatrixBase_ones_int_int.cpp 00551 * Output: \verbinclude MatrixBase_ones_int_int.out 00552 * 00553 * \sa Ones(), Ones(Index), isOnes(), class Ones 00554 */ 00555 template<typename Derived> 00556 EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType 00557 DenseBase<Derived>::Ones(Index nbRows, Index nbCols) 00558 { 00559 return Constant(nbRows, nbCols, Scalar(1)); 00560 } 00561 00562 /** \returns an expression of a vector where all coefficients equal one. 00563 * 00564 * The parameter \a newSize is the size of the returned vector. 00565 * Must be compatible with this MatrixBase type. 00566 * 00567 * \only_for_vectors 00568 * 00569 * This variant is meant to be used for dynamic-size vector types. For fixed-size types, 00570 * it is redundant to pass \a size as argument, so Ones() should be used 00571 * instead. 00572 * 00573 * Example: \include MatrixBase_ones_int.cpp 00574 * Output: \verbinclude MatrixBase_ones_int.out 00575 * 00576 * \sa Ones(), Ones(Index,Index), isOnes(), class Ones 00577 */ 00578 template<typename Derived> 00579 EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType 00580 DenseBase<Derived>::Ones(Index newSize) 00581 { 00582 return Constant(newSize, Scalar(1)); 00583 } 00584 00585 /** \returns an expression of a fixed-size matrix or vector where all coefficients equal one. 00586 * 00587 * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you 00588 * need to use the variants taking size arguments. 00589 * 00590 * Example: \include MatrixBase_ones.cpp 00591 * Output: \verbinclude MatrixBase_ones.out 00592 * 00593 * \sa Ones(Index), Ones(Index,Index), isOnes(), class Ones 00594 */ 00595 template<typename Derived> 00596 EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType 00597 DenseBase<Derived>::Ones() 00598 { 00599 return Constant(Scalar(1)); 00600 } 00601 00602 /** \returns true if *this is approximately equal to the matrix where all coefficients 00603 * are equal to 1, within the precision given by \a prec. 00604 * 00605 * Example: \include MatrixBase_isOnes.cpp 00606 * Output: \verbinclude MatrixBase_isOnes.out 00607 * 00608 * \sa class CwiseNullaryOp, Ones() 00609 */ 00610 template<typename Derived> 00611 bool DenseBase<Derived>::isOnes 00612 (const RealScalar& prec) const 00613 { 00614 return isApproxToConstant(Scalar(1), prec); 00615 } 00616 00617 /** Sets all coefficients in this expression to one. 00618 * 00619 * Example: \include MatrixBase_setOnes.cpp 00620 * Output: \verbinclude MatrixBase_setOnes.out 00621 * 00622 * \sa class CwiseNullaryOp, Ones() 00623 */ 00624 template<typename Derived> 00625 EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setOnes() 00626 { 00627 return setConstant(Scalar(1)); 00628 } 00629 00630 /** Resizes to the given \a newSize, and sets all coefficients in this expression to one. 00631 * 00632 * \only_for_vectors 00633 * 00634 * Example: \include Matrix_setOnes_int.cpp 00635 * Output: \verbinclude Matrix_setOnes_int.out 00636 * 00637 * \sa MatrixBase::setOnes(), setOnes(Index,Index), class CwiseNullaryOp, MatrixBase::Ones() 00638 */ 00639 template<typename Derived> 00640 EIGEN_STRONG_INLINE Derived& 00641 PlainObjectBase<Derived>::setOnes(Index newSize) 00642 { 00643 resize(newSize); 00644 return setConstant(Scalar(1)); 00645 } 00646 00647 /** Resizes to the given size, and sets all coefficients in this expression to one. 00648 * 00649 * \param nbRows the new number of rows 00650 * \param nbCols the new number of columns 00651 * 00652 * Example: \include Matrix_setOnes_int_int.cpp 00653 * Output: \verbinclude Matrix_setOnes_int_int.out 00654 * 00655 * \sa MatrixBase::setOnes(), setOnes(Index), class CwiseNullaryOp, MatrixBase::Ones() 00656 */ 00657 template<typename Derived> 00658 EIGEN_STRONG_INLINE Derived& 00659 PlainObjectBase<Derived>::setOnes(Index nbRows, Index nbCols) 00660 { 00661 resize(nbRows, nbCols); 00662 return setConstant(Scalar(1)); 00663 } 00664 00665 // Identity: 00666 00667 /** \returns an expression of the identity matrix (not necessarily square). 00668 * 00669 * The parameters \a nbRows and \a nbCols are the number of rows and of columns of 00670 * the returned matrix. Must be compatible with this MatrixBase type. 00671 * 00672 * This variant is meant to be used for dynamic-size matrix types. For fixed-size types, 00673 * it is redundant to pass \a rows and \a cols as arguments, so Identity() should be used 00674 * instead. 00675 * 00676 * Example: \include MatrixBase_identity_int_int.cpp 00677 * Output: \verbinclude MatrixBase_identity_int_int.out 00678 * 00679 * \sa Identity(), setIdentity(), isIdentity() 00680 */ 00681 template<typename Derived> 00682 EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType 00683 MatrixBase<Derived>::Identity(Index nbRows, Index nbCols) 00684 { 00685 return DenseBase<Derived>::NullaryExpr(nbRows, nbCols, internal::scalar_identity_op<Scalar>()); 00686 } 00687 00688 /** \returns an expression of the identity matrix (not necessarily square). 00689 * 00690 * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you 00691 * need to use the variant taking size arguments. 00692 * 00693 * Example: \include MatrixBase_identity.cpp 00694 * Output: \verbinclude MatrixBase_identity.out 00695 * 00696 * \sa Identity(Index,Index), setIdentity(), isIdentity() 00697 */ 00698 template<typename Derived> 00699 EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType 00700 MatrixBase<Derived>::Identity() 00701 { 00702 EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) 00703 return MatrixBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_identity_op<Scalar>()); 00704 } 00705 00706 /** \returns true if *this is approximately equal to the identity matrix 00707 * (not necessarily square), 00708 * within the precision given by \a prec. 00709 * 00710 * Example: \include MatrixBase_isIdentity.cpp 00711 * Output: \verbinclude MatrixBase_isIdentity.out 00712 * 00713 * \sa class CwiseNullaryOp, Identity(), Identity(Index,Index), setIdentity() 00714 */ 00715 template<typename Derived> 00716 bool MatrixBase<Derived>::isIdentity 00717 (const RealScalar& prec) const 00718 { 00719 for(Index j = 0; j < cols(); ++j) 00720 { 00721 for(Index i = 0; i < rows(); ++i) 00722 { 00723 if(i == j) 00724 { 00725 if(!internal::isApprox(this->coeff(i, j), static_cast<Scalar>(1), prec)) 00726 return false; 00727 } 00728 else 00729 { 00730 if(!internal::isMuchSmallerThan(this->coeff(i, j), static_cast<RealScalar>(1), prec)) 00731 return false; 00732 } 00733 } 00734 } 00735 return true; 00736 } 00737 00738 namespace internal { 00739 00740 template<typename Derived, bool Big = (Derived::SizeAtCompileTime>=16)> 00741 struct setIdentity_impl 00742 { 00743 static EIGEN_STRONG_INLINE Derived& run(Derived& m) 00744 { 00745 return m = Derived::Identity(m.rows(), m.cols()); 00746 } 00747 }; 00748 00749 template<typename Derived> 00750 struct setIdentity_impl<Derived, true> 00751 { 00752 typedef typename Derived::Index Index; 00753 static EIGEN_STRONG_INLINE Derived& run(Derived& m) 00754 { 00755 m.setZero(); 00756 const Index size = (std::min)(m.rows(), m.cols()); 00757 for(Index i = 0; i < size; ++i) m.coeffRef(i,i) = typename Derived::Scalar(1); 00758 return m; 00759 } 00760 }; 00761 00762 } // end namespace internal 00763 00764 /** Writes the identity expression (not necessarily square) into *this. 00765 * 00766 * Example: \include MatrixBase_setIdentity.cpp 00767 * Output: \verbinclude MatrixBase_setIdentity.out 00768 * 00769 * \sa class CwiseNullaryOp, Identity(), Identity(Index,Index), isIdentity() 00770 */ 00771 template<typename Derived> 00772 EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setIdentity() 00773 { 00774 return internal::setIdentity_impl<Derived>::run(derived()); 00775 } 00776 00777 /** \brief Resizes to the given size, and writes the identity expression (not necessarily square) into *this. 00778 * 00779 * \param nbRows the new number of rows 00780 * \param nbCols the new number of columns 00781 * 00782 * Example: \include Matrix_setIdentity_int_int.cpp 00783 * Output: \verbinclude Matrix_setIdentity_int_int.out 00784 * 00785 * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Identity() 00786 */ 00787 template<typename Derived> 00788 EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setIdentity(Index nbRows, Index nbCols) 00789 { 00790 derived().resize(nbRows, nbCols); 00791 return setIdentity(); 00792 } 00793 00794 /** \returns an expression of the i-th unit (basis) vector. 00795 * 00796 * \only_for_vectors 00797 * 00798 * \sa MatrixBase::Unit(Index), MatrixBase::UnitX(), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW() 00799 */ 00800 template<typename Derived> 00801 EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::Unit(Index newSize, Index i) 00802 { 00803 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 00804 return BasisReturnType(SquareMatrixType::Identity(newSize,newSize), i); 00805 } 00806 00807 /** \returns an expression of the i-th unit (basis) vector. 00808 * 00809 * \only_for_vectors 00810 * 00811 * This variant is for fixed-size vector only. 00812 * 00813 * \sa MatrixBase::Unit(Index,Index), MatrixBase::UnitX(), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW() 00814 */ 00815 template<typename Derived> 00816 EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::Unit(Index i) 00817 { 00818 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 00819 return BasisReturnType(SquareMatrixType::Identity(),i); 00820 } 00821 00822 /** \returns an expression of the X axis unit vector (1{,0}^*) 00823 * 00824 * \only_for_vectors 00825 * 00826 * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW() 00827 */ 00828 template<typename Derived> 00829 EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitX() 00830 { return Derived::Unit(0); } 00831 00832 /** \returns an expression of the Y axis unit vector (0,1{,0}^*) 00833 * 00834 * \only_for_vectors 00835 * 00836 * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW() 00837 */ 00838 template<typename Derived> 00839 EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitY() 00840 { return Derived::Unit(1); } 00841 00842 /** \returns an expression of the Z axis unit vector (0,0,1{,0}^*) 00843 * 00844 * \only_for_vectors 00845 * 00846 * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW() 00847 */ 00848 template<typename Derived> 00849 EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitZ() 00850 { return Derived::Unit(2); } 00851 00852 /** \returns an expression of the W axis unit vector (0,0,0,1) 00853 * 00854 * \only_for_vectors 00855 * 00856 * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW() 00857 */ 00858 template<typename Derived> 00859 EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitW() 00860 { return Derived::Unit(3); } 00861 00862 } // end namespace Eigen 00863 00864 #endif // EIGEN_CWISE_NULLARY_OP_H
Generated on Tue Jul 12 2022 17:46:51 by 1.7.2