Rotation given by a cosine-sine pair. More...

Public Types
typedef NumTraits< Scalar >::Real	RealScalar

Public Member Functions
JacobiRotation	adjoint () const

Scalar &	c ()

Scalar	c () const

	JacobiRotation ()

	JacobiRotation (const Scalar &c, const Scalar &s)

void	makeGivens (const Scalar &p, const Scalar &q, Scalar *r=0)

template<typename Derived >
bool	makeJacobi (const MatrixBase< Derived > &, Index p, Index q)

bool	makeJacobi (const RealScalar &x, const Scalar &y, const RealScalar &z)

JacobiRotation	operator* (const JacobiRotation &other)

Scalar &	s ()

Scalar	s () const

JacobiRotation	transpose () const

Protected Member Functions
void	makeGivens (const Scalar &p, const Scalar &q, Scalar *r, internal::false_type)

void	makeGivens (const Scalar &p, const Scalar &q, Scalar *r, internal::true_type)

Protected Attributes
Scalar	m_c

Scalar	m_s

Detailed Description

template<typename Scalar>
class Eigen::JacobiRotation< Scalar >

Rotation given by a cosine-sine pair.

This is defined in the Jacobi module.

#include <Eigen/Jacobi>

Jacobi

This class represents a Jacobi or Givens rotation. This is a 2D rotation in the plane J of angle \( \theta \) defined by its cosine c and sine s as follow: \( J = \left ( \begin{array}{cc} c & \overline s \\ -s & \overline c \end{array} \right ) \)

You can apply the respective counter-clockwise rotation to a column vector v by applying its adjoint on the left: \( v = J^* v \) that translates to the following Eigen code:

v.applyOnTheLeft(J.adjoint());

v

Array< int, Dynamic, 1 > v

Definition: Array_initializer_list_vector_cxx11.cpp:1

J

JacobiRotation< float > J

Definition: Jacobi_makeJacobi.cpp:3

See also: MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()

Definition at line 36 of file Jacobi.h.

Member Typedef Documentation

◆ RealScalar

template<typename Scalar >

typedef NumTraits<Scalar>::Real Eigen::JacobiRotation< Scalar >::RealScalar

Definition at line 39 of file Jacobi.h.

Constructor & Destructor Documentation

◆ JacobiRotation() [1/2]

template<typename Scalar >

Eigen::JacobiRotation< Scalar >::JacobiRotation ( )

inline

Default constructor without any initialization.

Definition at line 43 of file Jacobi.h.

43 {}

◆ JacobiRotation() [2/2]

template<typename Scalar >

Eigen::JacobiRotation< Scalar >::JacobiRotation	(	const Scalar &	c,
		const Scalar &	s
	)

inline

Construct a planar rotation from a cosine-sine pair (c, s).

Definition at line 47 of file Jacobi.h.

47 : m_c(c), m_s(s) {}

Eigen::JacobiRotation::s

Scalar & s()

Definition: Jacobi.h:51

Eigen::JacobiRotation::m_c

Scalar m_c

Definition: Jacobi.h:86

Eigen::JacobiRotation::m_s

Scalar m_s

Definition: Jacobi.h:86

Eigen::JacobiRotation::c

Scalar & c()

Definition: Jacobi.h:49

Member Function Documentation

◆ adjoint()

template<typename Scalar >

JacobiRotation Eigen::JacobiRotation< Scalar >::adjoint ( ) const

inline

Returns the adjoint transformation

Definition at line 69 of file Jacobi.h.

69 { using numext::conj; return JacobiRotation(conj(m_c), -m_s); }

Eigen::JacobiRotation::JacobiRotation

JacobiRotation()

Definition: Jacobi.h:43

Eigen::conj

const Eigen::CwiseUnaryOp< Eigen::internal::scalar_conjugate_op< typename Derived::Scalar >, const Derived > conj(const Eigen::ArrayBase< Derived > &x)

◆ c() [1/2]

template<typename Scalar >

Scalar& Eigen::JacobiRotation< Scalar >::c ( )

inline

Definition at line 49 of file Jacobi.h.

49 { return m_c; }

◆ c() [2/2]

template<typename Scalar >

Scalar Eigen::JacobiRotation< Scalar >::c ( ) const

inline

Definition at line 50 of file Jacobi.h.

50 { return m_c; }

◆ makeGivens() [1/3]

template<typename Scalar >

void Eigen::JacobiRotation< Scalar >::makeGivens	(	const Scalar &	p,
		const Scalar &	q,
		Scalar *	r,
		internal::false_type
	)

protected

Definition at line 233 of file Jacobi.h.

 {
   using std::sqrt;
   using std::abs;
   if(numext::is_exactly_zero(q))
   {
     m_c = p<Scalar(0) ? Scalar(-1) : Scalar(1);
     m_s = Scalar(0);
     if(r) *r = abs(p);
   }
   else if(numext::is_exactly_zero(p))
   {
     m_c = Scalar(0);
     m_s = q<Scalar(0) ? Scalar(1) : Scalar(-1);
     if(r) *r = abs(q);
   }
   else if(abs(p) > abs(q))
   {
     Scalar t = q/p;
     Scalar u = sqrt(Scalar(1) + numext::abs2(t));
     if(p<Scalar(0))
       u = -u;
     m_c = Scalar(1)/u;
     m_s = -t * m_c;
     if(r) *r = p * u;
   }
   else
   {
     Scalar t = p/q;
     Scalar u = sqrt(Scalar(1) + numext::abs2(t));
     if(q<Scalar(0))
       u = -u;
     m_s = -Scalar(1)/u;
     m_c = -t * m_s;
     if(r) *r = q * u;
   }
  
 }

◆ makeGivens() [2/3]

template<typename Scalar >

void Eigen::JacobiRotation< Scalar >::makeGivens	(	const Scalar &	p,
		const Scalar &	q,
		Scalar *	r,
		internal::true_type
	)

protected

Definition at line 173 of file Jacobi.h.

 {
   using std::sqrt;
   using std::abs;
   using numext::conj;
  
   if(q==Scalar(0))
   {
     m_c = numext::real(p)<0 ? Scalar(-1) : Scalar(1);
     m_s = 0;
     if(r) *r = m_c * p;
   }
   else if(p==Scalar(0))
   {
     m_c = 0;
     m_s = -q/abs(q);
     if(r) *r = abs(q);
   }
   else
   {
     RealScalar p1 = numext::norm1(p);
     RealScalar q1 = numext::norm1(q);
     if(p1>=q1)
     {
       Scalar ps = p / p1;
       RealScalar p2 = numext::abs2(ps);
       Scalar qs = q / p1;
       RealScalar q2 = numext::abs2(qs);
  
       RealScalar u = sqrt(RealScalar(1) + q2/p2);
       if(numext::real(p)<RealScalar(0))
         u = -u;
  
       m_c = Scalar(1)/u;
       m_s = -qs*conj(ps)*(m_c/p2);
       if(r) *r = p * u;
     }
     else
     {
       Scalar ps = p / q1;
       RealScalar p2 = numext::abs2(ps);
       Scalar qs = q / q1;
       RealScalar q2 = numext::abs2(qs);
  
       RealScalar u = q1 * sqrt(p2 + q2);
       if(numext::real(p)<RealScalar(0))
         u = -u;
  
       p1 = abs(p);
       ps = p/p1;
       m_c = p1/u;
       m_s = -conj(ps) * (q/u);
       if(r) *r = ps * u;
     }
   }
 }

◆ makeGivens() [3/3]

template<typename Scalar >

void Eigen::JacobiRotation< Scalar >::makeGivens	(	const Scalar &	p,
		const Scalar &	q,
		Scalar *	r = `0`
	)

Makes *this as a Givens rotation G such that applying \( G^* \) to the left of the vector \( V = \left ( \begin{array}{c} p \\ q \end{array} \right )\) yields: \( G^* V = \left ( \begin{array}{c} r \\ 0 \end{array} \right )\).

The value of r is returned if r is not null (the default is null). Also note that G is built such that the cosine is always real.

Example:

Vector2f v = Vector2f::Random();
JacobiRotation<float> G;
G.makeGivens(v.x(), v.y());
cout << "Here is the vector v:" << endl << v << endl;
v.applyOnTheLeft(0, 1, G.adjoint());
cout << "Here is the vector J' * v:" << endl << v << endl;

Output:

Here is the vector v:
  0.68
-0.211
Here is the vector J' * v:
0.712
    0

This function implements the continuous Givens rotation generation algorithm found in Anderson (2000), Discontinuous Plane Rotations and the Symmetric Eigenvalue Problem. LAPACK Working Note 150, University of Tennessee, UT-CS-00-454, December 4, 2000.

See also: MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()

Definition at line 164 of file Jacobi.h.

 {
   makeGivens(p, q, r, std::conditional_t<NumTraits<Scalar>::IsComplex, internal::true_type, internal::false_type>());
 }

◆ makeJacobi() [1/2]

template<typename Scalar >

template<typename Derived >

bool Eigen::JacobiRotation< Scalar >::makeJacobi	(	const MatrixBase< Derived > &	m,
		Index	p,
		Index	q
	)

inline

Makes *this as a Jacobi rotation J such that applying J on both the right and left sides of the 2x2 selfadjoint matrix \( B = \left ( \begin{array}{cc} \text{this}_{pp} & \text{this}_{pq} \\ (\text{this}_{pq})^* & \text{this}_{qq} \end{array} \right )\) yields a diagonal matrix \( A = J^* B J \)

Example:

Matrix2f m = Matrix2f::Random();
m = (m + m.adjoint()).eval();
JacobiRotation<float> J;
J.makeJacobi(m, 0, 1);
cout << "Here is the matrix m:" << endl << m << endl;
m.applyOnTheLeft(0, 1, J.adjoint());
m.applyOnTheRight(0, 1, J);
cout << "Here is the matrix J' * m * J:" << endl << m << endl;

Output:

Here is the matrix m:
 1.36 0.355
0.355  1.19
Here is the matrix J' * m * J:
 1.64     0
    0 0.913

See also: JacobiRotation::makeJacobi(RealScalar, Scalar, RealScalar), MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()

Definition at line 141 of file Jacobi.h.

 {
   return makeJacobi(numext::real(m.coeff(p,p)), m.coeff(p,q), numext::real(m.coeff(q,q)));
 }

◆ makeJacobi() [2/2]

template<typename Scalar >

bool Eigen::JacobiRotation< Scalar >::makeJacobi	(	const RealScalar &	x,
		const Scalar &	y,
		const RealScalar &	z
	)

Makes *this as a Jacobi rotation J such that applying J on both the right and left sides of the selfadjoint 2x2 matrix \( B = \left ( \begin{array}{cc} x & y \\ \overline y & z \end{array} \right )\) yields a diagonal matrix \( A = J^* B J \)

See also: MatrixBase::makeJacobi(const MatrixBase<Derived>&, Index, Index), MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()

Definition at line 96 of file Jacobi.h.

 {
   using std::sqrt;
   using std::abs;
  
   RealScalar deno = RealScalar(2)*abs(y);
   if(deno < (std::numeric_limits<RealScalar>::min)())
   {
     m_c = Scalar(1);
     m_s = Scalar(0);
     return false;
   }
   else
   {
     RealScalar tau = (x-z)/deno;
     RealScalar w = sqrt(numext::abs2(tau) + RealScalar(1));
     RealScalar t;
     if(tau>RealScalar(0))
     {
       t = RealScalar(1) / (tau + w);
     }
     else
     {
       t = RealScalar(1) / (tau - w);
     }
     RealScalar sign_t = t > RealScalar(0) ? RealScalar(1) : RealScalar(-1);
     RealScalar n = RealScalar(1) / sqrt(numext::abs2(t)+RealScalar(1));
     m_s = - sign_t * (numext::conj(y) / abs(y)) * abs(t) * n;
     m_c = n;
     return true;
   }
 }

◆ operator*()

template<typename Scalar >

JacobiRotation Eigen::JacobiRotation< Scalar >::operator* ( const JacobiRotation< Scalar > & other )

inline

Concatenates two planar rotation

Definition at line 56 of file Jacobi.h.

     {
       using numext::conj;
       return JacobiRotation(m_c * other.m_c - conj(m_s) * other.m_s,
                             conj(m_c * conj(other.m_s) + conj(m_s) * conj(other.m_c)));
     }

◆ s() [1/2]

template<typename Scalar >

Scalar& Eigen::JacobiRotation< Scalar >::s ( )

inline

Definition at line 51 of file Jacobi.h.

51 { return m_s; }

◆ s() [2/2]

template<typename Scalar >

Scalar Eigen::JacobiRotation< Scalar >::s ( ) const

inline

Definition at line 52 of file Jacobi.h.

52 { return m_s; }

◆ transpose()

template<typename Scalar >

JacobiRotation Eigen::JacobiRotation< Scalar >::transpose ( ) const

inline

Returns the transposed transformation

Definition at line 65 of file Jacobi.h.

65 { using numext::conj; return JacobiRotation(m_c, -conj(m_s)); }

Member Data Documentation

◆ m_c

template<typename Scalar >

Scalar Eigen::JacobiRotation< Scalar >::m_c

protected

Definition at line 86 of file Jacobi.h.

◆ m_s

template<typename Scalar >

Scalar Eigen::JacobiRotation< Scalar >::m_s

protected

Definition at line 86 of file Jacobi.h.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

template<typename Scalar> class Eigen::JacobiRotation< Scalar >

Member Typedef Documentation

◆ RealScalar

Constructor & Destructor Documentation

◆ JacobiRotation() [1/2]

◆ JacobiRotation() [2/2]

Member Function Documentation

◆ adjoint()

◆ c() [1/2]

◆ c() [2/2]

◆ makeGivens() [1/3]

◆ makeGivens() [2/3]

◆ makeGivens() [3/3]

◆ makeJacobi() [1/2]

◆ makeJacobi() [2/2]

◆ operator*()

◆ s() [1/2]

◆ s() [2/2]

◆ transpose()

Member Data Documentation

◆ m_c

◆ m_s

template<typename Scalar>
class Eigen::JacobiRotation< Scalar >