Another set of UI messages fixes and tweaks! No functional changes.
[blender.git] / extern / Eigen3 / Eigen / src / Core / Random.h
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@inria.fr>
5 //
6 // Eigen is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 3 of the License, or (at your option) any later version.
10 //
11 // Alternatively, you can redistribute it and/or
12 // modify it under the terms of the GNU General Public License as
13 // published by the Free Software Foundation; either version 2 of
14 // the License, or (at your option) any later version.
15 //
16 // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
17 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
19 // GNU General Public License for more details.
20 //
21 // You should have received a copy of the GNU Lesser General Public
22 // License and a copy of the GNU General Public License along with
23 // Eigen. If not, see <http://www.gnu.org/licenses/>.
24
25 #ifndef EIGEN_RANDOM_H
26 #define EIGEN_RANDOM_H
27
28 namespace internal {
29
30 template<typename Scalar> struct scalar_random_op {
31   EIGEN_EMPTY_STRUCT_CTOR(scalar_random_op)
32   template<typename Index>
33   inline const Scalar operator() (Index, Index = 0) const { return random<Scalar>(); }
34 };
35
36 template<typename Scalar>
37 struct functor_traits<scalar_random_op<Scalar> >
38 { enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false, IsRepeatable = false }; };
39
40 } // end namespace internal
41
42 /** \returns a random matrix expression
43   *
44   * The parameters \a rows and \a cols are the number of rows and of columns of
45   * the returned matrix. Must be compatible with this MatrixBase type.
46   *
47   * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
48   * it is redundant to pass \a rows and \a cols as arguments, so Random() should be used
49   * instead.
50   *
51   * Example: \include MatrixBase_random_int_int.cpp
52   * Output: \verbinclude MatrixBase_random_int_int.out
53   *
54   * This expression has the "evaluate before nesting" flag so that it will be evaluated into
55   * a temporary matrix whenever it is nested in a larger expression. This prevents unexpected
56   * behavior with expressions involving random matrices.
57   *
58   * \sa MatrixBase::setRandom(), MatrixBase::Random(Index), MatrixBase::Random()
59   */
60 template<typename Derived>
61 inline const CwiseNullaryOp<internal::scalar_random_op<typename internal::traits<Derived>::Scalar>, Derived>
62 DenseBase<Derived>::Random(Index rows, Index cols)
63 {
64   return NullaryExpr(rows, cols, internal::scalar_random_op<Scalar>());
65 }
66
67 /** \returns a random vector expression
68   *
69   * The parameter \a size is the size of the returned vector.
70   * Must be compatible with this MatrixBase type.
71   *
72   * \only_for_vectors
73   *
74   * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
75   * it is redundant to pass \a size as argument, so Random() should be used
76   * instead.
77   *
78   * Example: \include MatrixBase_random_int.cpp
79   * Output: \verbinclude MatrixBase_random_int.out
80   *
81   * This expression has the "evaluate before nesting" flag so that it will be evaluated into
82   * a temporary vector whenever it is nested in a larger expression. This prevents unexpected
83   * behavior with expressions involving random matrices.
84   *
85   * \sa MatrixBase::setRandom(), MatrixBase::Random(Index,Index), MatrixBase::Random()
86   */
87 template<typename Derived>
88 inline const CwiseNullaryOp<internal::scalar_random_op<typename internal::traits<Derived>::Scalar>, Derived>
89 DenseBase<Derived>::Random(Index size)
90 {
91   return NullaryExpr(size, internal::scalar_random_op<Scalar>());
92 }
93
94 /** \returns a fixed-size random matrix or vector expression
95   *
96   * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
97   * need to use the variants taking size arguments.
98   *
99   * Example: \include MatrixBase_random.cpp
100   * Output: \verbinclude MatrixBase_random.out
101   *
102   * This expression has the "evaluate before nesting" flag so that it will be evaluated into
103   * a temporary matrix whenever it is nested in a larger expression. This prevents unexpected
104   * behavior with expressions involving random matrices.
105   *
106   * \sa MatrixBase::setRandom(), MatrixBase::Random(Index,Index), MatrixBase::Random(Index)
107   */
108 template<typename Derived>
109 inline const CwiseNullaryOp<internal::scalar_random_op<typename internal::traits<Derived>::Scalar>, Derived>
110 DenseBase<Derived>::Random()
111 {
112   return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_random_op<Scalar>());
113 }
114
115 /** Sets all coefficients in this expression to random values.
116   *
117   * Example: \include MatrixBase_setRandom.cpp
118   * Output: \verbinclude MatrixBase_setRandom.out
119   *
120   * \sa class CwiseNullaryOp, setRandom(Index), setRandom(Index,Index)
121   */
122 template<typename Derived>
123 inline Derived& DenseBase<Derived>::setRandom()
124 {
125   return *this = Random(rows(), cols());
126 }
127
128 /** Resizes to the given \a size, and sets all coefficients in this expression to random values.
129   *
130   * \only_for_vectors
131   *
132   * Example: \include Matrix_setRandom_int.cpp
133   * Output: \verbinclude Matrix_setRandom_int.out
134   *
135   * \sa MatrixBase::setRandom(), setRandom(Index,Index), class CwiseNullaryOp, MatrixBase::Random()
136   */
137 template<typename Derived>
138 EIGEN_STRONG_INLINE Derived&
139 PlainObjectBase<Derived>::setRandom(Index size)
140 {
141   resize(size);
142   return setRandom();
143 }
144
145 /** Resizes to the given size, and sets all coefficients in this expression to random values.
146   *
147   * \param rows the new number of rows
148   * \param cols the new number of columns
149   *
150   * Example: \include Matrix_setRandom_int_int.cpp
151   * Output: \verbinclude Matrix_setRandom_int_int.out
152   *
153   * \sa MatrixBase::setRandom(), setRandom(Index), class CwiseNullaryOp, MatrixBase::Random()
154   */
155 template<typename Derived>
156 EIGEN_STRONG_INLINE Derived&
157 PlainObjectBase<Derived>::setRandom(Index rows, Index cols)
158 {
159   resize(rows, cols);
160   return setRandom();
161 }
162
163 #endif // EIGEN_RANDOM_H