Eigen  5.0.1-dev+master
 
Loading...
Searching...
No Matches
Scaling.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// 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// SPDX-License-Identifier: MPL-2.0
10
11#ifndef EIGEN_SCALING_H
12#define EIGEN_SCALING_H
13
14// IWYU pragma: private
15#include "./InternalHeaderCheck.h"
16
17namespace Eigen {
18
36
37namespace internal {
38// This helper helps nvcc+MSVC to properly parse this file.
39// See bug 1412.
40template <typename Scalar, int Dim, int Mode>
41struct uniformscaling_times_affine_returntype {
42 enum { NewMode = int(Mode) == int(Isometry) ? Affine : Mode };
43 using type = Transform<Scalar, Dim, NewMode>;
44};
45} // namespace internal
46
47template <typename Scalar_>
49 public:
51 using Scalar = Scalar_;
52
53 protected:
54 Scalar m_factor;
55
56 public:
58 EIGEN_DEVICE_FUNC UniformScaling() {}
60 EIGEN_DEVICE_FUNC explicit inline UniformScaling(const Scalar& s) : m_factor(s) {}
61
62 EIGEN_DEVICE_FUNC inline const Scalar& factor() const { return m_factor; }
63 EIGEN_DEVICE_FUNC inline Scalar& factor() { return m_factor; }
64
66 EIGEN_DEVICE_FUNC inline UniformScaling operator*(const UniformScaling& other) const {
67 return UniformScaling(m_factor * other.factor());
68 }
69
71 template <int Dim>
72 EIGEN_DEVICE_FUNC inline Transform<Scalar, Dim, Affine> operator*(const Translation<Scalar, Dim>& t) const;
73
75 template <int Dim, int Mode, int Options>
76 EIGEN_DEVICE_FUNC inline typename internal::uniformscaling_times_affine_returntype<Scalar, Dim, Mode>::type operator*(
78 typename internal::uniformscaling_times_affine_returntype<Scalar, Dim, Mode>::type res = t;
79 res.prescale(factor());
80 return res;
81 }
82
84 // TODO: return an expression instead of a dense matrix.
85 template <typename Derived>
86 EIGEN_DEVICE_FUNC inline typename Eigen::internal::plain_matrix_type<Derived>::type operator*(
87 const MatrixBase<Derived>& other) const {
88 return other * m_factor;
89 }
90
91 template <typename Derived, int Dim>
92 EIGEN_DEVICE_FUNC inline Matrix<Scalar, Dim, Dim> operator*(const RotationBase<Derived, Dim>& r) const {
93 return r.toRotationMatrix() * m_factor;
94 }
95
97 EIGEN_DEVICE_FUNC inline UniformScaling inverse() const { return UniformScaling(Scalar(1) / m_factor); }
98
104 template <typename NewScalarType>
105 EIGEN_DEVICE_FUNC inline UniformScaling<NewScalarType> cast() const {
106 return UniformScaling<NewScalarType>(NewScalarType(m_factor));
107 }
108
110 template <typename OtherScalarType>
111 EIGEN_DEVICE_FUNC inline explicit UniformScaling(const UniformScaling<OtherScalarType>& other) {
112 m_factor = Scalar(other.factor());
113 }
114
119 bool isApprox(const UniformScaling& other,
120 const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const {
121 return internal::isApprox(m_factor, other.factor(), prec);
122 }
123};
124
127
131// NOTE this operator is defined in MatrixBase and not as a friend function
132// of UniformScaling to fix an internal crash of Intel's ICC
133template <typename Derived, typename Scalar>
134EIGEN_DEVICE_FUNC EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived, Scalar, internal::scalar_product_op) operator*(
135 const MatrixBase<Derived>& matrix, const UniformScaling<Scalar>& s) {
136 return matrix.derived() * s.factor();
137}
138
140EIGEN_DEVICE_FUNC inline UniformScaling<float> Scaling(float s) { return UniformScaling<float>(s); }
142EIGEN_DEVICE_FUNC inline UniformScaling<double> Scaling(double s) { return UniformScaling<double>(s); }
144template <typename RealScalar>
145EIGEN_DEVICE_FUNC inline UniformScaling<std::complex<RealScalar> > Scaling(const std::complex<RealScalar>& s) {
147}
148
150template <typename Scalar>
151EIGEN_DEVICE_FUNC inline DiagonalMatrix<Scalar, 2> Scaling(const Scalar& sx, const Scalar& sy) {
152 return DiagonalMatrix<Scalar, 2>(sx, sy);
153}
155template <typename Scalar>
156EIGEN_DEVICE_FUNC inline DiagonalMatrix<Scalar, 3> Scaling(const Scalar& sx, const Scalar& sy, const Scalar& sz) {
157 return DiagonalMatrix<Scalar, 3>(sx, sy, sz);
158}
159
163template <typename Derived>
164EIGEN_DEVICE_FUNC inline const DiagonalWrapper<const Derived> Scaling(const MatrixBase<Derived>& coeffs) {
165 return coeffs.asDiagonal();
166}
167
169template <typename Derived>
170EIGEN_DEVICE_FUNC inline typename DiagonalWrapper<const Derived>::PlainObject Scaling(MatrixBase<Derived>&& coeffs) {
171 return typename DiagonalWrapper<const Derived>::PlainObject(std::move(coeffs.derived()));
172}
173
175using AlignedScaling2f = DiagonalMatrix<float, 2>;
177using AlignedScaling2d = DiagonalMatrix<double, 2>;
179using AlignedScaling3f = DiagonalMatrix<float, 3>;
181using AlignedScaling3d = DiagonalMatrix<double, 3>;
183
184template <typename Scalar>
185template <int Dim>
187 const Translation<Scalar, Dim>& t) const {
189 res.matrix().setZero();
190 res.linear().diagonal().fill(factor());
191 res.translation() = factor() * t.vector();
192 res(Dim, Dim) = Scalar(1);
193 return res;
194}
195
196} // end namespace Eigen
197
198#endif // EIGEN_SCALING_H
Represents a diagonal matrix with its storage.
Definition DiagonalMatrix.h:233
Expression of a diagonal matrix.
Definition DiagonalMatrix.h:400
Base class for all dense matrices, vectors, and expressions.
Definition MatrixBase.h:53
The matrix class, also used for vectors and row-vectors.
Definition Matrix.h:188
Common base class for compact rotation representations.
Definition RotationBase.h:33
RotationMatrixType toRotationMatrix() const
Definition RotationBase.h:48
Represents an homogeneous transformation in a N dimensional space.
Definition Transform.h:222
ConstLinearPart linear() const
Definition Transform.h:418
ConstTranslationPart translation() const
Definition Transform.h:428
const MatrixType & matrix() const
Definition Transform.h:413
Represents a translation transformation.
Definition Translation.h:34
Represents a generic uniform scaling transformation.
Definition Scaling.h:48
UniformScaling inverse() const
Definition Scaling.h:97
Scalar_ Scalar
Definition Scaling.h:51
bool isApprox(const UniformScaling &other, const typename NumTraits< Scalar >::Real &prec=NumTraits< Scalar >::dummy_precision()) const
Definition Scaling.h:119
UniformScaling operator*(const UniformScaling &other) const
Definition Scaling.h:66
UniformScaling()
Definition Scaling.h:58
Eigen::internal::plain_matrix_type< Derived >::type operator*(const MatrixBase< Derived > &other) const
Definition Scaling.h:86
UniformScaling(const Scalar &s)
Definition Scaling.h:60
internal::uniformscaling_times_affine_returntype< Scalar, Dim, Mode >::type operator*(const Transform< Scalar, Dim, Mode, Options > &t) const
Definition Scaling.h:76
UniformScaling< NewScalarType > cast() const
Definition Scaling.h:105
UniformScaling(const UniformScaling< OtherScalarType > &other)
Definition Scaling.h:111
@ Affine
Definition Constants.h:475
@ Isometry
Definition Constants.h:472