1 // This file is part of Eigen, a lightweight C++ template library 2 // for linear algebra. 3 // 4 // Copyright (C) 2008 Gael Guennebaud <gael.guennebaud (at) inria.fr> 5 // 6 // This Source Code Form is subject to the terms of the Mozilla 7 // Public License v. 2.0. If a copy of the MPL was not distributed 8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 10 #ifndef EIGEN_RANDOM_H 11 #define EIGEN_RANDOM_H 12 13 namespace Eigen { 14 15 namespace internal { 16 17 template<typename Scalar> struct scalar_random_op { 18 EIGEN_EMPTY_STRUCT_CTOR(scalar_random_op) 19 template<typename Index> 20 inline const Scalar operator() (Index, Index = 0) const { return random<Scalar>(); } 21 }; 22 23 template<typename Scalar> 24 struct functor_traits<scalar_random_op<Scalar> > 25 { enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false, IsRepeatable = false }; }; 26 27 } // end namespace internal 28 29 /** \returns a random matrix expression 30 * 31 * The parameters \a rows and \a cols are the number of rows and of columns of 32 * the returned matrix. Must be compatible with this MatrixBase type. 33 * 34 * This variant is meant to be used for dynamic-size matrix types. For fixed-size types, 35 * it is redundant to pass \a rows and \a cols as arguments, so Random() should be used 36 * instead. 37 * 38 * Example: \include MatrixBase_random_int_int.cpp 39 * Output: \verbinclude MatrixBase_random_int_int.out 40 * 41 * This expression has the "evaluate before nesting" flag so that it will be evaluated into 42 * a temporary matrix whenever it is nested in a larger expression. This prevents unexpected 43 * behavior with expressions involving random matrices. 44 * 45 * \sa MatrixBase::setRandom(), MatrixBase::Random(Index), MatrixBase::Random() 46 */ 47 template<typename Derived> 48 inline const CwiseNullaryOp<internal::scalar_random_op<typename internal::traits<Derived>::Scalar>, Derived> 49 DenseBase<Derived>::Random(Index rows, Index cols) 50 { 51 return NullaryExpr(rows, cols, internal::scalar_random_op<Scalar>()); 52 } 53 54 /** \returns a random vector expression 55 * 56 * The parameter \a size is the size of the returned vector. 57 * Must be compatible with this MatrixBase type. 58 * 59 * \only_for_vectors 60 * 61 * This variant is meant to be used for dynamic-size vector types. For fixed-size types, 62 * it is redundant to pass \a size as argument, so Random() should be used 63 * instead. 64 * 65 * Example: \include MatrixBase_random_int.cpp 66 * Output: \verbinclude MatrixBase_random_int.out 67 * 68 * This expression has the "evaluate before nesting" flag so that it will be evaluated into 69 * a temporary vector whenever it is nested in a larger expression. This prevents unexpected 70 * behavior with expressions involving random matrices. 71 * 72 * \sa MatrixBase::setRandom(), MatrixBase::Random(Index,Index), MatrixBase::Random() 73 */ 74 template<typename Derived> 75 inline const CwiseNullaryOp<internal::scalar_random_op<typename internal::traits<Derived>::Scalar>, Derived> 76 DenseBase<Derived>::Random(Index size) 77 { 78 return NullaryExpr(size, internal::scalar_random_op<Scalar>()); 79 } 80 81 /** \returns a fixed-size random matrix or vector expression 82 * 83 * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you 84 * need to use the variants taking size arguments. 85 * 86 * Example: \include MatrixBase_random.cpp 87 * Output: \verbinclude MatrixBase_random.out 88 * 89 * This expression has the "evaluate before nesting" flag so that it will be evaluated into 90 * a temporary matrix whenever it is nested in a larger expression. This prevents unexpected 91 * behavior with expressions involving random matrices. 92 * 93 * \sa MatrixBase::setRandom(), MatrixBase::Random(Index,Index), MatrixBase::Random(Index) 94 */ 95 template<typename Derived> 96 inline const CwiseNullaryOp<internal::scalar_random_op<typename internal::traits<Derived>::Scalar>, Derived> 97 DenseBase<Derived>::Random() 98 { 99 return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_random_op<Scalar>()); 100 } 101 102 /** Sets all coefficients in this expression to random values. 103 * 104 * Example: \include MatrixBase_setRandom.cpp 105 * Output: \verbinclude MatrixBase_setRandom.out 106 * 107 * \sa class CwiseNullaryOp, setRandom(Index), setRandom(Index,Index) 108 */ 109 template<typename Derived> 110 inline Derived& DenseBase<Derived>::setRandom() 111 { 112 return *this = Random(rows(), cols()); 113 } 114 115 /** Resizes to the given \a size, and sets all coefficients in this expression to random values. 116 * 117 * \only_for_vectors 118 * 119 * Example: \include Matrix_setRandom_int.cpp 120 * Output: \verbinclude Matrix_setRandom_int.out 121 * 122 * \sa MatrixBase::setRandom(), setRandom(Index,Index), class CwiseNullaryOp, MatrixBase::Random() 123 */ 124 template<typename Derived> 125 EIGEN_STRONG_INLINE Derived& 126 PlainObjectBase<Derived>::setRandom(Index size) 127 { 128 resize(size); 129 return setRandom(); 130 } 131 132 /** Resizes to the given size, and sets all coefficients in this expression to random values. 133 * 134 * \param rows the new number of rows 135 * \param cols the new number of columns 136 * 137 * Example: \include Matrix_setRandom_int_int.cpp 138 * Output: \verbinclude Matrix_setRandom_int_int.out 139 * 140 * \sa MatrixBase::setRandom(), setRandom(Index), class CwiseNullaryOp, MatrixBase::Random() 141 */ 142 template<typename Derived> 143 EIGEN_STRONG_INLINE Derived& 144 PlainObjectBase<Derived>::setRandom(Index rows, Index cols) 145 { 146 resize(rows, cols); 147 return setRandom(); 148 } 149 150 } // end namespace Eigen 151 152 #endif // EIGEN_RANDOM_H 153
