Branch data Line data Source code
1 : : // This file is part of Eigen, a lightweight C++ template library
2 : : // for linear algebra.
3 : : //
4 : : // Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@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_CWISE_NULLARY_OP_H
11 : : #define EIGEN_CWISE_NULLARY_OP_H
12 : :
13 : : namespace Eigen {
14 : :
15 : : namespace internal {
16 : : template<typename NullaryOp, typename PlainObjectType>
17 : : struct traits<CwiseNullaryOp<NullaryOp, PlainObjectType> > : traits<PlainObjectType>
18 : : {
19 : : enum {
20 : : Flags = traits<PlainObjectType>::Flags & RowMajorBit
21 : : };
22 : : };
23 : :
24 : : } // namespace internal
25 : :
26 : : /** \class CwiseNullaryOp
27 : : * \ingroup Core_Module
28 : : *
29 : : * \brief Generic expression of a matrix where all coefficients are defined by a functor
30 : : *
31 : : * \tparam NullaryOp template functor implementing the operator
32 : : * \tparam PlainObjectType the underlying plain matrix/array type
33 : : *
34 : : * This class represents an expression of a generic nullary operator.
35 : : * It is the return type of the Ones(), Zero(), Constant(), Identity() and Random() methods,
36 : : * and most of the time this is the only way it is used.
37 : : *
38 : : * However, if you want to write a function returning such an expression, you
39 : : * will need to use this class.
40 : : *
41 : : * The functor NullaryOp must expose one of the following method:
42 : : <table class="manual">
43 : : <tr ><td>\c operator()() </td><td>if the procedural generation does not depend on the coefficient entries (e.g., random numbers)</td></tr>
44 : : <tr class="alt"><td>\c operator()(Index i)</td><td>if the procedural generation makes sense for vectors only and that it depends on the coefficient index \c i (e.g., linspace) </td></tr>
45 : : <tr ><td>\c operator()(Index i,Index j)</td><td>if the procedural generation depends on the matrix coordinates \c i, \c j (e.g., to generate a checkerboard with 0 and 1)</td></tr>
46 : : </table>
47 : : * It is also possible to expose the last two operators if the generation makes sense for matrices but can be optimized for vectors.
48 : : *
49 : : * See DenseBase::NullaryExpr(Index,const CustomNullaryOp&) for an example binding
50 : : * C++11 random number generators.
51 : : *
52 : : * A nullary expression can also be used to implement custom sophisticated matrix manipulations
53 : : * that cannot be covered by the existing set of natively supported matrix manipulations.
54 : : * See this \ref TopicCustomizing_NullaryExpr "page" for some examples and additional explanations
55 : : * on the behavior of CwiseNullaryOp.
56 : : *
57 : : * \sa class CwiseUnaryOp, class CwiseBinaryOp, DenseBase::NullaryExpr
58 : : */
59 : : template<typename NullaryOp, typename PlainObjectType>
60 : : class CwiseNullaryOp : public internal::dense_xpr_base< CwiseNullaryOp<NullaryOp, PlainObjectType> >::type, internal::no_assignment_operator
61 : : {
62 : : public:
63 : :
64 : : typedef typename internal::dense_xpr_base<CwiseNullaryOp>::type Base;
65 : : EIGEN_DENSE_PUBLIC_INTERFACE(CwiseNullaryOp)
66 : :
67 : : EIGEN_DEVICE_FUNC
68 : 64715 : CwiseNullaryOp(Index rows, Index cols, const NullaryOp& func = NullaryOp())
69 : 64715 : : m_rows(rows), m_cols(cols), m_functor(func)
70 : : {
71 : 64715 : eigen_assert(rows >= 0
72 : : && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
73 : : && cols >= 0
74 : : && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols));
75 : 64715 : }
76 : :
77 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
78 : 135417 : Index rows() const { return m_rows.value(); }
79 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
80 : 133287 : Index cols() const { return m_cols.value(); }
81 : :
82 : : /** \returns the functor representing the nullary operation */
83 : : EIGEN_DEVICE_FUNC
84 : 66549 : const NullaryOp& functor() const { return m_functor; }
85 : :
86 : : protected:
87 : : const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows;
88 : : const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols;
89 : : const NullaryOp m_functor;
90 : : };
91 : :
92 : :
93 : : /** \returns an expression of a matrix defined by a custom functor \a func
94 : : *
95 : : * The parameters \a rows and \a cols are the number of rows and of columns of
96 : : * the returned matrix. Must be compatible with this MatrixBase type.
97 : : *
98 : : * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
99 : : * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
100 : : * instead.
101 : : *
102 : : * The template parameter \a CustomNullaryOp is the type of the functor.
103 : : *
104 : : * \sa class CwiseNullaryOp
105 : : */
106 : : template<typename Derived>
107 : : template<typename CustomNullaryOp>
108 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
109 : : #ifndef EIGEN_PARSED_BY_DOXYGEN
110 : : const CwiseNullaryOp<CustomNullaryOp,typename DenseBase<Derived>::PlainObject>
111 : : #else
112 : : const CwiseNullaryOp<CustomNullaryOp,PlainObject>
113 : : #endif
114 : 37607 : DenseBase<Derived>::NullaryExpr(Index rows, Index cols, const CustomNullaryOp& func)
115 : : {
116 : 37607 : return CwiseNullaryOp<CustomNullaryOp, PlainObject>(rows, cols, func);
117 : : }
118 : :
119 : : /** \returns an expression of a matrix defined by a custom functor \a func
120 : : *
121 : : * The parameter \a size is the size of the returned vector.
122 : : * Must be compatible with this MatrixBase type.
123 : : *
124 : : * \only_for_vectors
125 : : *
126 : : * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
127 : : * it is redundant to pass \a size as argument, so Zero() should be used
128 : : * instead.
129 : : *
130 : : * The template parameter \a CustomNullaryOp is the type of the functor.
131 : : *
132 : : * Here is an example with C++11 random generators: \include random_cpp11.cpp
133 : : * Output: \verbinclude random_cpp11.out
134 : : *
135 : : * \sa class CwiseNullaryOp
136 : : */
137 : : template<typename Derived>
138 : : template<typename CustomNullaryOp>
139 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
140 : : #ifndef EIGEN_PARSED_BY_DOXYGEN
141 : : const CwiseNullaryOp<CustomNullaryOp, typename DenseBase<Derived>::PlainObject>
142 : : #else
143 : : const CwiseNullaryOp<CustomNullaryOp, PlainObject>
144 : : #endif
145 : : DenseBase<Derived>::NullaryExpr(Index size, const CustomNullaryOp& func)
146 : : {
147 : : EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
148 : : if(RowsAtCompileTime == 1) return CwiseNullaryOp<CustomNullaryOp, PlainObject>(1, size, func);
149 : : else return CwiseNullaryOp<CustomNullaryOp, PlainObject>(size, 1, func);
150 : : }
151 : :
152 : : /** \returns an expression of a matrix defined by a custom functor \a func
153 : : *
154 : : * This variant is only for fixed-size DenseBase types. For dynamic-size types, you
155 : : * need to use the variants taking size arguments.
156 : : *
157 : : * The template parameter \a CustomNullaryOp is the type of the functor.
158 : : *
159 : : * \sa class CwiseNullaryOp
160 : : */
161 : : template<typename Derived>
162 : : template<typename CustomNullaryOp>
163 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
164 : : #ifndef EIGEN_PARSED_BY_DOXYGEN
165 : : const CwiseNullaryOp<CustomNullaryOp, typename DenseBase<Derived>::PlainObject>
166 : : #else
167 : : const CwiseNullaryOp<CustomNullaryOp, PlainObject>
168 : : #endif
169 : : DenseBase<Derived>::NullaryExpr(const CustomNullaryOp& func)
170 : : {
171 : : return CwiseNullaryOp<CustomNullaryOp, PlainObject>(RowsAtCompileTime, ColsAtCompileTime, func);
172 : : }
173 : :
174 : : /** \returns an expression of a constant matrix of value \a value
175 : : *
176 : : * The parameters \a rows and \a cols are the number of rows and of columns of
177 : : * the returned matrix. Must be compatible with this DenseBase type.
178 : : *
179 : : * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
180 : : * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
181 : : * instead.
182 : : *
183 : : * The template parameter \a CustomNullaryOp is the type of the functor.
184 : : *
185 : : * \sa class CwiseNullaryOp
186 : : */
187 : : template<typename Derived>
188 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
189 : 20087 : DenseBase<Derived>::Constant(Index rows, Index cols, const Scalar& value)
190 : : {
191 : 20087 : return DenseBase<Derived>::NullaryExpr(rows, cols, internal::scalar_constant_op<Scalar>(value));
192 : : }
193 : :
194 : : /** \returns an expression of a constant matrix of value \a value
195 : : *
196 : : * The parameter \a size is the size of the returned vector.
197 : : * Must be compatible with this DenseBase type.
198 : : *
199 : : * \only_for_vectors
200 : : *
201 : : * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
202 : : * it is redundant to pass \a size as argument, so Zero() should be used
203 : : * instead.
204 : : *
205 : : * The template parameter \a CustomNullaryOp is the type of the functor.
206 : : *
207 : : * \sa class CwiseNullaryOp
208 : : */
209 : : template<typename Derived>
210 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
211 : : DenseBase<Derived>::Constant(Index size, const Scalar& value)
212 : : {
213 : : return DenseBase<Derived>::NullaryExpr(size, internal::scalar_constant_op<Scalar>(value));
214 : : }
215 : :
216 : : /** \returns an expression of a constant matrix of value \a value
217 : : *
218 : : * This variant is only for fixed-size DenseBase types. For dynamic-size types, you
219 : : * need to use the variants taking size arguments.
220 : : *
221 : : * The template parameter \a CustomNullaryOp is the type of the functor.
222 : : *
223 : : * \sa class CwiseNullaryOp
224 : : */
225 : : template<typename Derived>
226 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
227 : : DenseBase<Derived>::Constant(const Scalar& value)
228 : : {
229 : : EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
230 : : return DenseBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_constant_op<Scalar>(value));
231 : : }
232 : :
233 : : /** \deprecated because of accuracy loss. In Eigen 3.3, it is an alias for LinSpaced(Index,const Scalar&,const Scalar&)
234 : : *
235 : : * \only_for_vectors
236 : : *
237 : : * Example: \include DenseBase_LinSpaced_seq_deprecated.cpp
238 : : * Output: \verbinclude DenseBase_LinSpaced_seq_deprecated.out
239 : : *
240 : : * \sa LinSpaced(Index,const Scalar&, const Scalar&), setLinSpaced(Index,const Scalar&,const Scalar&)
241 : : */
242 : : template<typename Derived>
243 : : EIGEN_DEPRECATED EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
244 : : DenseBase<Derived>::LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high)
245 : : {
246 : : EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
247 : : return DenseBase<Derived>::NullaryExpr(size, internal::linspaced_op<Scalar>(low,high,size));
248 : : }
249 : :
250 : : /** \deprecated because of accuracy loss. In Eigen 3.3, it is an alias for LinSpaced(const Scalar&,const Scalar&)
251 : : *
252 : : * \sa LinSpaced(const Scalar&, const Scalar&)
253 : : */
254 : : template<typename Derived>
255 : : EIGEN_DEPRECATED EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
256 : : DenseBase<Derived>::LinSpaced(Sequential_t, const Scalar& low, const Scalar& high)
257 : : {
258 : : EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
259 : : EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
260 : : return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op<Scalar>(low,high,Derived::SizeAtCompileTime));
261 : : }
262 : :
263 : : /**
264 : : * \brief Sets a linearly spaced vector.
265 : : *
266 : : * The function generates 'size' equally spaced values in the closed interval [low,high].
267 : : * When size is set to 1, a vector of length 1 containing 'high' is returned.
268 : : *
269 : : * \only_for_vectors
270 : : *
271 : : * Example: \include DenseBase_LinSpaced.cpp
272 : : * Output: \verbinclude DenseBase_LinSpaced.out
273 : : *
274 : : * For integer scalar types, an even spacing is possible if and only if the length of the range,
275 : : * i.e., \c high-low is a scalar multiple of \c size-1, or if \c size is a scalar multiple of the
276 : : * number of values \c high-low+1 (meaning each value can be repeated the same number of time).
277 : : * If one of these two considions is not satisfied, then \c high is lowered to the largest value
278 : : * satisfying one of this constraint.
279 : : * Here are some examples:
280 : : *
281 : : * Example: \include DenseBase_LinSpacedInt.cpp
282 : : * Output: \verbinclude DenseBase_LinSpacedInt.out
283 : : *
284 : : * \sa setLinSpaced(Index,const Scalar&,const Scalar&), CwiseNullaryOp
285 : : */
286 : : template<typename Derived>
287 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
288 : : DenseBase<Derived>::LinSpaced(Index size, const Scalar& low, const Scalar& high)
289 : : {
290 : : EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
291 : : return DenseBase<Derived>::NullaryExpr(size, internal::linspaced_op<Scalar>(low,high,size));
292 : : }
293 : :
294 : : /**
295 : : * \copydoc DenseBase::LinSpaced(Index, const Scalar&, const Scalar&)
296 : : * Special version for fixed size types which does not require the size parameter.
297 : : */
298 : : template<typename Derived>
299 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
300 : : DenseBase<Derived>::LinSpaced(const Scalar& low, const Scalar& high)
301 : : {
302 : : EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
303 : : EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
304 : : return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op<Scalar>(low,high,Derived::SizeAtCompileTime));
305 : : }
306 : :
307 : : /** \returns true if all coefficients in this matrix are approximately equal to \a val, to within precision \a prec */
308 : : template<typename Derived>
309 : : EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isApproxToConstant
310 : : (const Scalar& val, const RealScalar& prec) const
311 : : {
312 : : typename internal::nested_eval<Derived,1>::type self(derived());
313 : : for(Index j = 0; j < cols(); ++j)
314 : : for(Index i = 0; i < rows(); ++i)
315 : : if(!internal::isApprox(self.coeff(i, j), val, prec))
316 : : return false;
317 : : return true;
318 : : }
319 : :
320 : : /** This is just an alias for isApproxToConstant().
321 : : *
322 : : * \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */
323 : : template<typename Derived>
324 : : EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isConstant
325 : : (const Scalar& val, const RealScalar& prec) const
326 : : {
327 : : return isApproxToConstant(val, prec);
328 : : }
329 : :
330 : : /** Alias for setConstant(): sets all coefficients in this expression to \a val.
331 : : *
332 : : * \sa setConstant(), Constant(), class CwiseNullaryOp
333 : : */
334 : : template<typename Derived>
335 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void DenseBase<Derived>::fill(const Scalar& val)
336 : : {
337 : : setConstant(val);
338 : : }
339 : :
340 : : /** Sets all coefficients in this expression to value \a val.
341 : : *
342 : : * \sa fill(), setConstant(Index,const Scalar&), setConstant(Index,Index,const Scalar&), setZero(), setOnes(), Constant(), class CwiseNullaryOp, setZero(), setOnes()
343 : : */
344 : : template<typename Derived>
345 : 4 : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setConstant(const Scalar& val)
346 : : {
347 : 4 : return derived() = Constant(rows(), cols(), val);
348 : : }
349 : :
350 : : /** Resizes to the given \a size, and sets all coefficients in this expression to the given value \a val.
351 : : *
352 : : * \only_for_vectors
353 : : *
354 : : * Example: \include Matrix_setConstant_int.cpp
355 : : * Output: \verbinclude Matrix_setConstant_int.out
356 : : *
357 : : * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
358 : : */
359 : : template<typename Derived>
360 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
361 : : PlainObjectBase<Derived>::setConstant(Index size, const Scalar& val)
362 : : {
363 : : resize(size);
364 : : return setConstant(val);
365 : : }
366 : :
367 : : /** Resizes to the given size, and sets all coefficients in this expression to the given value \a val.
368 : : *
369 : : * \param rows the new number of rows
370 : : * \param cols the new number of columns
371 : : * \param val the value to which all coefficients are set
372 : : *
373 : : * Example: \include Matrix_setConstant_int_int.cpp
374 : : * Output: \verbinclude Matrix_setConstant_int_int.out
375 : : *
376 : : * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
377 : : */
378 : : template<typename Derived>
379 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
380 : : PlainObjectBase<Derived>::setConstant(Index rows, Index cols, const Scalar& val)
381 : : {
382 : : resize(rows, cols);
383 : : return setConstant(val);
384 : : }
385 : :
386 : : /** Resizes to the given size, changing only the number of columns, and sets all
387 : : * coefficients in this expression to the given value \a val. For the parameter
388 : : * of type NoChange_t, just pass the special value \c NoChange.
389 : : *
390 : : * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
391 : : */
392 : : template<typename Derived>
393 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
394 : : PlainObjectBase<Derived>::setConstant(NoChange_t, Index cols, const Scalar& val)
395 : : {
396 : : return setConstant(rows(), cols, val);
397 : : }
398 : :
399 : : /** Resizes to the given size, changing only the number of rows, and sets all
400 : : * coefficients in this expression to the given value \a val. For the parameter
401 : : * of type NoChange_t, just pass the special value \c NoChange.
402 : : *
403 : : * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
404 : : */
405 : : template<typename Derived>
406 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
407 : : PlainObjectBase<Derived>::setConstant(Index rows, NoChange_t, const Scalar& val)
408 : : {
409 : : return setConstant(rows, cols(), val);
410 : : }
411 : :
412 : :
413 : : /**
414 : : * \brief Sets a linearly spaced vector.
415 : : *
416 : : * The function generates 'size' equally spaced values in the closed interval [low,high].
417 : : * When size is set to 1, a vector of length 1 containing 'high' is returned.
418 : : *
419 : : * \only_for_vectors
420 : : *
421 : : * Example: \include DenseBase_setLinSpaced.cpp
422 : : * Output: \verbinclude DenseBase_setLinSpaced.out
423 : : *
424 : : * For integer scalar types, do not miss the explanations on the definition
425 : : * of \link LinSpaced(Index,const Scalar&,const Scalar&) even spacing \endlink.
426 : : *
427 : : * \sa LinSpaced(Index,const Scalar&,const Scalar&), CwiseNullaryOp
428 : : */
429 : : template<typename Derived>
430 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setLinSpaced(Index newSize, const Scalar& low, const Scalar& high)
431 : : {
432 : : EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
433 : : return derived() = Derived::NullaryExpr(newSize, internal::linspaced_op<Scalar>(low,high,newSize));
434 : : }
435 : :
436 : : /**
437 : : * \brief Sets a linearly spaced vector.
438 : : *
439 : : * The function fills \c *this with equally spaced values in the closed interval [low,high].
440 : : * When size is set to 1, a vector of length 1 containing 'high' is returned.
441 : : *
442 : : * \only_for_vectors
443 : : *
444 : : * For integer scalar types, do not miss the explanations on the definition
445 : : * of \link LinSpaced(Index,const Scalar&,const Scalar&) even spacing \endlink.
446 : : *
447 : : * \sa LinSpaced(Index,const Scalar&,const Scalar&), setLinSpaced(Index, const Scalar&, const Scalar&), CwiseNullaryOp
448 : : */
449 : : template<typename Derived>
450 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setLinSpaced(const Scalar& low, const Scalar& high)
451 : : {
452 : : EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
453 : : return setLinSpaced(size(), low, high);
454 : : }
455 : :
456 : : // zero:
457 : :
458 : : /** \returns an expression of a zero matrix.
459 : : *
460 : : * The parameters \a rows and \a cols are the number of rows and of columns of
461 : : * the returned matrix. Must be compatible with this MatrixBase type.
462 : : *
463 : : * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
464 : : * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
465 : : * instead.
466 : : *
467 : : * Example: \include MatrixBase_zero_int_int.cpp
468 : : * Output: \verbinclude MatrixBase_zero_int_int.out
469 : : *
470 : : * \sa Zero(), Zero(Index)
471 : : */
472 : : template<typename Derived>
473 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
474 : : DenseBase<Derived>::Zero(Index rows, Index cols)
475 : : {
476 : : return Constant(rows, cols, Scalar(0));
477 : : }
478 : :
479 : : /** \returns an expression of a zero vector.
480 : : *
481 : : * The parameter \a size is the size of the returned vector.
482 : : * Must be compatible with this MatrixBase type.
483 : : *
484 : : * \only_for_vectors
485 : : *
486 : : * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
487 : : * it is redundant to pass \a size as argument, so Zero() should be used
488 : : * instead.
489 : : *
490 : : * Example: \include MatrixBase_zero_int.cpp
491 : : * Output: \verbinclude MatrixBase_zero_int.out
492 : : *
493 : : * \sa Zero(), Zero(Index,Index)
494 : : */
495 : : template<typename Derived>
496 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
497 : : DenseBase<Derived>::Zero(Index size)
498 : : {
499 : : return Constant(size, Scalar(0));
500 : : }
501 : :
502 : : /** \returns an expression of a fixed-size zero matrix or vector.
503 : : *
504 : : * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
505 : : * need to use the variants taking size arguments.
506 : : *
507 : : * Example: \include MatrixBase_zero.cpp
508 : : * Output: \verbinclude MatrixBase_zero.out
509 : : *
510 : : * \sa Zero(Index), Zero(Index,Index)
511 : : */
512 : : template<typename Derived>
513 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
514 : : DenseBase<Derived>::Zero()
515 : : {
516 : : return Constant(Scalar(0));
517 : : }
518 : :
519 : : /** \returns true if *this is approximately equal to the zero matrix,
520 : : * within the precision given by \a prec.
521 : : *
522 : : * Example: \include MatrixBase_isZero.cpp
523 : : * Output: \verbinclude MatrixBase_isZero.out
524 : : *
525 : : * \sa class CwiseNullaryOp, Zero()
526 : : */
527 : : template<typename Derived>
528 : : EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isZero(const RealScalar& prec) const
529 : : {
530 : : typename internal::nested_eval<Derived,1>::type self(derived());
531 : : for(Index j = 0; j < cols(); ++j)
532 : : for(Index i = 0; i < rows(); ++i)
533 : : if(!internal::isMuchSmallerThan(self.coeff(i, j), static_cast<Scalar>(1), prec))
534 : : return false;
535 : : return true;
536 : : }
537 : :
538 : : /** Sets all coefficients in this expression to zero.
539 : : *
540 : : * Example: \include MatrixBase_setZero.cpp
541 : : * Output: \verbinclude MatrixBase_setZero.out
542 : : *
543 : : * \sa class CwiseNullaryOp, Zero()
544 : : */
545 : : template<typename Derived>
546 : 4 : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setZero()
547 : : {
548 : 4 : return setConstant(Scalar(0));
549 : : }
550 : :
551 : : /** Resizes to the given \a size, and sets all coefficients in this expression to zero.
552 : : *
553 : : * \only_for_vectors
554 : : *
555 : : * Example: \include Matrix_setZero_int.cpp
556 : : * Output: \verbinclude Matrix_setZero_int.out
557 : : *
558 : : * \sa DenseBase::setZero(), setZero(Index,Index), class CwiseNullaryOp, DenseBase::Zero()
559 : : */
560 : : template<typename Derived>
561 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
562 : : PlainObjectBase<Derived>::setZero(Index newSize)
563 : : {
564 : : resize(newSize);
565 : : return setConstant(Scalar(0));
566 : : }
567 : :
568 : : /** Resizes to the given size, and sets all coefficients in this expression to zero.
569 : : *
570 : : * \param rows the new number of rows
571 : : * \param cols the new number of columns
572 : : *
573 : : * Example: \include Matrix_setZero_int_int.cpp
574 : : * Output: \verbinclude Matrix_setZero_int_int.out
575 : : *
576 : : * \sa DenseBase::setZero(), setZero(Index), class CwiseNullaryOp, DenseBase::Zero()
577 : : */
578 : : template<typename Derived>
579 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
580 : : PlainObjectBase<Derived>::setZero(Index rows, Index cols)
581 : : {
582 : : resize(rows, cols);
583 : : return setConstant(Scalar(0));
584 : : }
585 : :
586 : : /** Resizes to the given size, changing only the number of columns, and sets all
587 : : * coefficients in this expression to zero. For the parameter of type NoChange_t,
588 : : * just pass the special value \c NoChange.
589 : : *
590 : : * \sa DenseBase::setZero(), setZero(Index), setZero(Index, Index), setZero(Index, NoChange_t), class CwiseNullaryOp, DenseBase::Zero()
591 : : */
592 : : template<typename Derived>
593 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
594 : : PlainObjectBase<Derived>::setZero(NoChange_t, Index cols)
595 : : {
596 : : return setZero(rows(), cols);
597 : : }
598 : :
599 : : /** Resizes to the given size, changing only the number of rows, and sets all
600 : : * coefficients in this expression to zero. For the parameter of type NoChange_t,
601 : : * just pass the special value \c NoChange.
602 : : *
603 : : * \sa DenseBase::setZero(), setZero(Index), setZero(Index, Index), setZero(NoChange_t, Index), class CwiseNullaryOp, DenseBase::Zero()
604 : : */
605 : : template<typename Derived>
606 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
607 : : PlainObjectBase<Derived>::setZero(Index rows, NoChange_t)
608 : : {
609 : : return setZero(rows, cols());
610 : : }
611 : :
612 : : // ones:
613 : :
614 : : /** \returns an expression of a matrix where all coefficients equal one.
615 : : *
616 : : * The parameters \a rows and \a cols are the number of rows and of columns of
617 : : * the returned matrix. Must be compatible with this MatrixBase type.
618 : : *
619 : : * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
620 : : * it is redundant to pass \a rows and \a cols as arguments, so Ones() should be used
621 : : * instead.
622 : : *
623 : : * Example: \include MatrixBase_ones_int_int.cpp
624 : : * Output: \verbinclude MatrixBase_ones_int_int.out
625 : : *
626 : : * \sa Ones(), Ones(Index), isOnes(), class Ones
627 : : */
628 : : template<typename Derived>
629 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
630 : : DenseBase<Derived>::Ones(Index rows, Index cols)
631 : : {
632 : : return Constant(rows, cols, Scalar(1));
633 : : }
634 : :
635 : : /** \returns an expression of a vector where all coefficients equal one.
636 : : *
637 : : * The parameter \a newSize is the size of the returned vector.
638 : : * Must be compatible with this MatrixBase type.
639 : : *
640 : : * \only_for_vectors
641 : : *
642 : : * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
643 : : * it is redundant to pass \a size as argument, so Ones() should be used
644 : : * instead.
645 : : *
646 : : * Example: \include MatrixBase_ones_int.cpp
647 : : * Output: \verbinclude MatrixBase_ones_int.out
648 : : *
649 : : * \sa Ones(), Ones(Index,Index), isOnes(), class Ones
650 : : */
651 : : template<typename Derived>
652 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
653 : : DenseBase<Derived>::Ones(Index newSize)
654 : : {
655 : : return Constant(newSize, Scalar(1));
656 : : }
657 : :
658 : : /** \returns an expression of a fixed-size matrix or vector where all coefficients equal one.
659 : : *
660 : : * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
661 : : * need to use the variants taking size arguments.
662 : : *
663 : : * Example: \include MatrixBase_ones.cpp
664 : : * Output: \verbinclude MatrixBase_ones.out
665 : : *
666 : : * \sa Ones(Index), Ones(Index,Index), isOnes(), class Ones
667 : : */
668 : : template<typename Derived>
669 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
670 : : DenseBase<Derived>::Ones()
671 : : {
672 : : return Constant(Scalar(1));
673 : : }
674 : :
675 : : /** \returns true if *this is approximately equal to the matrix where all coefficients
676 : : * are equal to 1, within the precision given by \a prec.
677 : : *
678 : : * Example: \include MatrixBase_isOnes.cpp
679 : : * Output: \verbinclude MatrixBase_isOnes.out
680 : : *
681 : : * \sa class CwiseNullaryOp, Ones()
682 : : */
683 : : template<typename Derived>
684 : : EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isOnes
685 : : (const RealScalar& prec) const
686 : : {
687 : : return isApproxToConstant(Scalar(1), prec);
688 : : }
689 : :
690 : : /** Sets all coefficients in this expression to one.
691 : : *
692 : : * Example: \include MatrixBase_setOnes.cpp
693 : : * Output: \verbinclude MatrixBase_setOnes.out
694 : : *
695 : : * \sa class CwiseNullaryOp, Ones()
696 : : */
697 : : template<typename Derived>
698 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setOnes()
699 : : {
700 : : return setConstant(Scalar(1));
701 : : }
702 : :
703 : : /** Resizes to the given \a newSize, and sets all coefficients in this expression to one.
704 : : *
705 : : * \only_for_vectors
706 : : *
707 : : * Example: \include Matrix_setOnes_int.cpp
708 : : * Output: \verbinclude Matrix_setOnes_int.out
709 : : *
710 : : * \sa MatrixBase::setOnes(), setOnes(Index,Index), class CwiseNullaryOp, MatrixBase::Ones()
711 : : */
712 : : template<typename Derived>
713 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
714 : : PlainObjectBase<Derived>::setOnes(Index newSize)
715 : : {
716 : : resize(newSize);
717 : : return setConstant(Scalar(1));
718 : : }
719 : :
720 : : /** Resizes to the given size, and sets all coefficients in this expression to one.
721 : : *
722 : : * \param rows the new number of rows
723 : : * \param cols the new number of columns
724 : : *
725 : : * Example: \include Matrix_setOnes_int_int.cpp
726 : : * Output: \verbinclude Matrix_setOnes_int_int.out
727 : : *
728 : : * \sa MatrixBase::setOnes(), setOnes(Index), class CwiseNullaryOp, MatrixBase::Ones()
729 : : */
730 : : template<typename Derived>
731 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
732 : : PlainObjectBase<Derived>::setOnes(Index rows, Index cols)
733 : : {
734 : : resize(rows, cols);
735 : : return setConstant(Scalar(1));
736 : : }
737 : :
738 : : /** Resizes to the given size, changing only the number of rows, and sets all
739 : : * coefficients in this expression to one. For the parameter of type NoChange_t,
740 : : * just pass the special value \c NoChange.
741 : : *
742 : : * \sa MatrixBase::setOnes(), setOnes(Index), setOnes(Index, Index), setOnes(NoChange_t, Index), class CwiseNullaryOp, MatrixBase::Ones()
743 : : */
744 : : template<typename Derived>
745 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
746 : : PlainObjectBase<Derived>::setOnes(Index rows, NoChange_t)
747 : : {
748 : : return setOnes(rows, cols());
749 : : }
750 : :
751 : : /** Resizes to the given size, changing only the number of columns, and sets all
752 : : * coefficients in this expression to one. For the parameter of type NoChange_t,
753 : : * just pass the special value \c NoChange.
754 : : *
755 : : * \sa MatrixBase::setOnes(), setOnes(Index), setOnes(Index, Index), setOnes(Index, NoChange_t) class CwiseNullaryOp, MatrixBase::Ones()
756 : : */
757 : : template<typename Derived>
758 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
759 : : PlainObjectBase<Derived>::setOnes(NoChange_t, Index cols)
760 : : {
761 : : return setOnes(rows(), cols);
762 : : }
763 : :
764 : : // Identity:
765 : :
766 : : /** \returns an expression of the identity matrix (not necessarily square).
767 : : *
768 : : * The parameters \a rows and \a cols are the number of rows and of columns of
769 : : * the returned matrix. Must be compatible with this MatrixBase type.
770 : : *
771 : : * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
772 : : * it is redundant to pass \a rows and \a cols as arguments, so Identity() should be used
773 : : * instead.
774 : : *
775 : : * Example: \include MatrixBase_identity_int_int.cpp
776 : : * Output: \verbinclude MatrixBase_identity_int_int.out
777 : : *
778 : : * \sa Identity(), setIdentity(), isIdentity()
779 : : */
780 : : template<typename Derived>
781 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType
782 : : MatrixBase<Derived>::Identity(Index rows, Index cols)
783 : : {
784 : : return DenseBase<Derived>::NullaryExpr(rows, cols, internal::scalar_identity_op<Scalar>());
785 : : }
786 : :
787 : : /** \returns an expression of the identity matrix (not necessarily square).
788 : : *
789 : : * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
790 : : * need to use the variant taking size arguments.
791 : : *
792 : : * Example: \include MatrixBase_identity.cpp
793 : : * Output: \verbinclude MatrixBase_identity.out
794 : : *
795 : : * \sa Identity(Index,Index), setIdentity(), isIdentity()
796 : : */
797 : : template<typename Derived>
798 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType
799 : 612 : MatrixBase<Derived>::Identity()
800 : : {
801 : : EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
802 : 612 : return MatrixBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_identity_op<Scalar>());
803 : : }
804 : :
805 : : /** \returns true if *this is approximately equal to the identity matrix
806 : : * (not necessarily square),
807 : : * within the precision given by \a prec.
808 : : *
809 : : * Example: \include MatrixBase_isIdentity.cpp
810 : : * Output: \verbinclude MatrixBase_isIdentity.out
811 : : *
812 : : * \sa class CwiseNullaryOp, Identity(), Identity(Index,Index), setIdentity()
813 : : */
814 : : template<typename Derived>
815 : : bool MatrixBase<Derived>::isIdentity
816 : : (const RealScalar& prec) const
817 : : {
818 : : typename internal::nested_eval<Derived,1>::type self(derived());
819 : : for(Index j = 0; j < cols(); ++j)
820 : : {
821 : : for(Index i = 0; i < rows(); ++i)
822 : : {
823 : : if(i == j)
824 : : {
825 : : if(!internal::isApprox(self.coeff(i, j), static_cast<Scalar>(1), prec))
826 : : return false;
827 : : }
828 : : else
829 : : {
830 : : if(!internal::isMuchSmallerThan(self.coeff(i, j), static_cast<RealScalar>(1), prec))
831 : : return false;
832 : : }
833 : : }
834 : : }
835 : : return true;
836 : : }
837 : :
838 : : namespace internal {
839 : :
840 : : template<typename Derived, bool Big = (Derived::SizeAtCompileTime>=16)>
841 : : struct setIdentity_impl
842 : : {
843 : : EIGEN_DEVICE_FUNC
844 : : static EIGEN_STRONG_INLINE Derived& run(Derived& m)
845 : : {
846 : : return m = Derived::Identity(m.rows(), m.cols());
847 : : }
848 : : };
849 : :
850 : : template<typename Derived>
851 : : struct setIdentity_impl<Derived, true>
852 : : {
853 : : EIGEN_DEVICE_FUNC
854 : : static EIGEN_STRONG_INLINE Derived& run(Derived& m)
855 : : {
856 : : m.setZero();
857 : : const Index size = numext::mini(m.rows(), m.cols());
858 : : for(Index i = 0; i < size; ++i) m.coeffRef(i,i) = typename Derived::Scalar(1);
859 : : return m;
860 : : }
861 : : };
862 : :
863 : : } // end namespace internal
864 : :
865 : : /** Writes the identity expression (not necessarily square) into *this.
866 : : *
867 : : * Example: \include MatrixBase_setIdentity.cpp
868 : : * Output: \verbinclude MatrixBase_setIdentity.out
869 : : *
870 : : * \sa class CwiseNullaryOp, Identity(), Identity(Index,Index), isIdentity()
871 : : */
872 : : template<typename Derived>
873 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setIdentity()
874 : : {
875 : : return internal::setIdentity_impl<Derived>::run(derived());
876 : : }
877 : :
878 : : /** \brief Resizes to the given size, and writes the identity expression (not necessarily square) into *this.
879 : : *
880 : : * \param rows the new number of rows
881 : : * \param cols the new number of columns
882 : : *
883 : : * Example: \include Matrix_setIdentity_int_int.cpp
884 : : * Output: \verbinclude Matrix_setIdentity_int_int.out
885 : : *
886 : : * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Identity()
887 : : */
888 : : template<typename Derived>
889 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setIdentity(Index rows, Index cols)
890 : : {
891 : : derived().resize(rows, cols);
892 : : return setIdentity();
893 : : }
894 : :
895 : : /** \returns an expression of the i-th unit (basis) vector.
896 : : *
897 : : * \only_for_vectors
898 : : *
899 : : * \sa MatrixBase::Unit(Index), MatrixBase::UnitX(), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
900 : : */
901 : : template<typename Derived>
902 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::Unit(Index newSize, Index i)
903 : : {
904 : : EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
905 : : return BasisReturnType(SquareMatrixType::Identity(newSize,newSize), i);
906 : : }
907 : :
908 : : /** \returns an expression of the i-th unit (basis) vector.
909 : : *
910 : : * \only_for_vectors
911 : : *
912 : : * This variant is for fixed-size vector only.
913 : : *
914 : : * \sa MatrixBase::Unit(Index,Index), MatrixBase::UnitX(), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
915 : : */
916 : : template<typename Derived>
917 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::Unit(Index i)
918 : : {
919 : : EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
920 : : return BasisReturnType(SquareMatrixType::Identity(),i);
921 : : }
922 : :
923 : : /** \returns an expression of the X axis unit vector (1{,0}^*)
924 : : *
925 : : * \only_for_vectors
926 : : *
927 : : * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
928 : : */
929 : : template<typename Derived>
930 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitX()
931 : : { return Derived::Unit(0); }
932 : :
933 : : /** \returns an expression of the Y axis unit vector (0,1{,0}^*)
934 : : *
935 : : * \only_for_vectors
936 : : *
937 : : * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
938 : : */
939 : : template<typename Derived>
940 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitY()
941 : : { return Derived::Unit(1); }
942 : :
943 : : /** \returns an expression of the Z axis unit vector (0,0,1{,0}^*)
944 : : *
945 : : * \only_for_vectors
946 : : *
947 : : * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
948 : : */
949 : : template<typename Derived>
950 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitZ()
951 : : { return Derived::Unit(2); }
952 : :
953 : : /** \returns an expression of the W axis unit vector (0,0,0,1)
954 : : *
955 : : * \only_for_vectors
956 : : *
957 : : * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
958 : : */
959 : : template<typename Derived>
960 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitW()
961 : : { return Derived::Unit(3); }
962 : :
963 : : /** \brief Set the coefficients of \c *this to the i-th unit (basis) vector
964 : : *
965 : : * \param i index of the unique coefficient to be set to 1
966 : : *
967 : : * \only_for_vectors
968 : : *
969 : : * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Unit(Index,Index)
970 : : */
971 : : template<typename Derived>
972 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setUnit(Index i)
973 : : {
974 : : EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
975 : : eigen_assert(i<size());
976 : : derived().setZero();
977 : : derived().coeffRef(i) = Scalar(1);
978 : : return derived();
979 : : }
980 : :
981 : : /** \brief Resizes to the given \a newSize, and writes the i-th unit (basis) vector into *this.
982 : : *
983 : : * \param newSize the new size of the vector
984 : : * \param i index of the unique coefficient to be set to 1
985 : : *
986 : : * \only_for_vectors
987 : : *
988 : : * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Unit(Index,Index)
989 : : */
990 : : template<typename Derived>
991 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setUnit(Index newSize, Index i)
992 : : {
993 : : EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
994 : : eigen_assert(i<newSize);
995 : : derived().resize(newSize);
996 : : return setUnit(i);
997 : : }
998 : :
999 : : } // end namespace Eigen
1000 : :
1001 : : #endif // EIGEN_CWISE_NULLARY_OP_H
|
