eigen Archives - Robotics with ROS

Eigen unaryExpr (Function Pointer, Lambda Expression) Example

Leave a Comment / C++, Linear Algebra, Tutorials / admin

double ramp(double x)
{
    if (x > 0)
        return x;
    else
        return 0;
}

void unaryExprExample()
{
    //unaryExpr is a const function so it will not give you the possibility to modify values in place
    Eigen::ArrayXd x = Eigen::ArrayXd::Random(5);
    std::cout<<x <<std::endl;
    x = x.unaryExpr([](double elem) // changed type of parameter
    {
        return elem < 0.0 ? 0.0 : 1.0; // return instead of assignment
    });
    std::cout<<x <<std::endl;
    std::cout << x.unaryExpr(std::ptr_fun(ramp)) << std::endl;

}

double ramp(double x)

{

if (x > 0)

return x;

else

return 0;

}

void unaryExprExample()

{

//unaryExpr is a const function so it will not give you the possibility to modify values in place

Eigen::ArrayXd x = Eigen::ArrayXd::Random(5);

std::cout<<x <<std::endl;

x = x.unaryExpr([](double elem) // changed type of parameter

{

return elem < 0.0 ? 0.0 : 1.0; // return instead of assignment

});

std::cout<<x <<std::endl;

std::cout << x.unaryExpr(std::ptr_fun(ramp)) << std::endl;

}

Eigen unaryExpr (Function Pointer, Lambda Expression) Example Read More »

Matrix Decomposition with Eigen: QR, Cholesky Decomposition LU, UL

Leave a Comment / C++, Linear Algebra, Tutorials / admin

void qRDecomposition(Eigen::MatrixXd &A,Eigen::MatrixXd &Q, Eigen::MatrixXd &R)
{
    /*
        A=QR
        Q: is orthogonal matrix-> columns of Q are orthonormal
        R: is upper triangulate matrix

        this is possible when columns of A are linearly indipendent

    */

    Eigen::MatrixXd thinQ(A.rows(),A.cols() ), q(A.rows(),A.rows());

    Eigen::HouseholderQR<Eigen::MatrixXd> householderQR(A);
    q = householderQR.householderQ();
    thinQ.setIdentity();
    Q = householderQR.householderQ() * thinQ;
    R=Q.transpose()*A;
}

void qRExample()
{

    Eigen::MatrixXd A;
    A.setRandom(3,4);

    std::cout<<"A" <<std::endl;
    std::cout<<A <<std::endl;
    Eigen::MatrixXd Q(A.rows(),A.rows());
    Eigen::MatrixXd R(A.rows(),A.cols());

    /////////////////////////////////HouseholderQR////////////////////////
    Eigen::MatrixXd thinQ(A.rows(),A.cols() ), q(A.rows(),A.rows());

    Eigen::HouseholderQR<Eigen::MatrixXd> householderQR(A);
    q = householderQR.householderQ();
    thinQ.setIdentity();
    Q = householderQR.householderQ() * thinQ;

    std::cout << "HouseholderQR" <<std::endl;

    std::cout << "Q" <<std::endl;
    std::cout << Q <<std::endl;

    R = householderQR.matrixQR().template  triangularView<Eigen::Upper>();
    std::cout << R<<std::endl;
    std::cout << R.rows()<<std::endl;
    std::cout << R.cols()<<std::endl;


    R=Q.transpose()*A;
// 	std::cout << "R" <<std::endl;
// 	std::cout << R<<std::endl;

    std::cout << "A-Q*R" <<std::endl;
    std::cout << A-Q*R <<std::endl;

    /////////////////////////////////ColPivHouseholderQR////////////////////////
    Eigen::ColPivHouseholderQR<Eigen::MatrixXd> colPivHouseholderQR(A.rows(), A.cols());
    colPivHouseholderQR.compute(A);
    //R = colPivHouseholderQR.matrixR().template triangularView<Upper>();
    R = colPivHouseholderQR.matrixR();
    Q = colPivHouseholderQR.matrixQ();

    std::cout << "ColPivHouseholderQR" <<std::endl;

    std::cout << "Q" <<std::endl;
    std::cout << Q <<std::endl;

    std::cout << "R" <<std::endl;
    std::cout << R <<std::endl;

    std::cout << "A-Q*R" <<std::endl;
    std::cout << A-Q*R <<std::endl;

    /////////////////////////////////FullPivHouseholderQR////////////////////////
    std::cout << "FullPivHouseholderQR" <<std::endl;

    Eigen::FullPivHouseholderQR<Eigen::MatrixXd> fullPivHouseholderQR(A.rows(), A.cols());
    fullPivHouseholderQR.compute(A);
    Q=fullPivHouseholderQR.matrixQ();
    R=fullPivHouseholderQR.matrixQR().template  triangularView<Eigen::Upper>();

    std::cout << "Q" <<std::endl;
    std::cout << Q <<std::endl;

    std::cout << "R" <<std::endl;
    std::cout << R <<std::endl;

    std::cout << "A-Q*R" <<std::endl;
    std::cout << A-Q*R <<std::endl;

}

void lDUDecomposition()
{
/*

    L: lower triangular matrix L
    U: upper triangular matrix U
    D: is a diagonal matrix
    A=LDU


*/
}

void lUDecomposition()
{
/*
    L: lower triangular matrix L
    U: upper triangular matrix U
    A=LU
*/
}

double exp(double x) // the functor we want to apply
{
    std::setprecision(5);
        return std::trunc(x);
}

void gramSchmidtOrthogonalization(Eigen::MatrixXd &matrix,Eigen::MatrixXd &orthonormalMatrix)
{
/*
    In this method you make every column perpendicular to it's previous columns,
    here if a and b are representation vector of two columns, c=b-((b.a)/|a|).a
        ^
       /
    b /
     /
    /
    ---------->
        a

        ^
       /|
    b / |
     /  | c
    /   |
    ---------->
        a

    you just have to normilze every vector after make it perpendicular to previous columns
    so:
    q1=a.normalized();
    q2=b-(b.q1).q1
    q2=q2.normalized();
    q3=c-(c.q1).q1 - (c.q2).q2
    q3=q3.normalized();


    Now we have Q, but we want A=QR so we just multiply both side by Q.transpose(), since Q is orthonormal, Q*Q.transpose() is I
    A=QR;
    Q.transpose()*A=R;
*/
    Eigen::VectorXd col;
    for(int i=0;i<matrix.cols();i++)
    {
        col=matrix.col(i);
        col=col.normalized();
        for(int j=0;j<i-1;j++)
        {
            //orthonormalMatrix.col(i)
        }

        orthonormalMatrix.col(i)=col;
    }
    Eigen::MatrixXd A(4,3);

    A<<1,2,3,-1,1,1,1,1,1,1,1,1;
    Eigen::Vector4d a=A.col(0);
    Eigen::Vector4d b=A.col(1);
    Eigen::Vector4d c=A.col(2);

    Eigen::Vector4d q1=  a.normalized();
    Eigen::Vector4d q2=b-(b.dot(q1))*q1;
    q2=q2.normalized();

    Eigen::Vector4d q3=c-(c.dot(q1))*q1 - (c.dot(q2))*q2;
    q3=q3.normalized();

    std::cout<< "q1:"<<std::endl;
    std::cout<< q1<<std::endl;
    std::cout<< "q2"<<std::endl;
    std::cout<< q2<<std::endl;
    std::cout<< "q3:"<<std::endl;
    std::cout<< q3<<std::endl;

    Eigen::MatrixXd Q(4,3);
    Q.col(0)=q1;
    Q.col(1)=q2;
    Q.col(2)=q3;

    Eigen::MatrixXd R(3,3);
    R=Q.transpose()*(A);


    std::cout<<"Q"<<std::endl;
    std::cout<< Q<<std::endl;


    std::cout<<"R"<<std::endl;
    std::cout<< R.unaryExpr(std::ptr_fun(exp))<<std::endl;



    //MatrixXd A(4,3), thinQ(4,3), Q(4,4);

    Eigen::MatrixXd thinQ(4,3), q(4,4);

    //A.setRandom();
    Eigen::HouseholderQR<Eigen::MatrixXd> qr(A);
    q = qr.householderQ();
    thinQ.setIdentity();
    thinQ = qr.householderQ() * thinQ;
    std::cout << "Q computed by Eigen" << "\n\n" << thinQ << "\n\n";
    std::cout << q << "\n\n" << thinQ << "\n\n";


}

void gramSchmidtOrthogonalizationExample()
{
    Eigen::MatrixXd matrix(3,4),orthonormalMatrix(3,4) ;
    matrix=Eigen::MatrixXd::Random(3,4);////A.setRandom();


    gramSchmidtOrthogonalization(matrix,orthonormalMatrix);
}

void choleskyDecompositionExample()
{
/*
Positive-definite matrix:
    Matrix Mnxn is said to be positive definite if the scalar zTMz is strictly positive for every non-zero
    column vector z n real numbers. zTMz>0


Hermitian matrix:
    Matrix Mnxn is said to be positive definite if the scalar z*Mz is strictly positive for every non-zero
    column vector z n real numbers. z*Mz>0
    z* is the conjugate transpose of z.

Positive semi-definite same as above except zTMz>=0 or  z*Mz>=0


    Example:
            ┌2  -1  0┐
        M=	|-1  2 -1|
            |0 - 1  2|
            └        ┘
          ┌ a ┐
        z=| b |
          | c |
          └	  ┘
        zTMz=a^2 +c^2+ (a-b)^2+ (b-c)^2

Cholesky decomposition:
Cholesky decomposition of a Hermitian positive-definite matrix A is:
    A=LL*

    L is a lower triangular matrix with real and positive diagonal entries
    L* is the conjugate transpose of L
*/

    Eigen::MatrixXd A(3,3);
    A << 6, 0, 0, 0, 4, 0, 0, 0, 7;
    Eigen::MatrixXd L( A.llt().matrixL() );
    Eigen::MatrixXd L_T=L.adjoint();//conjugate transpose

    std::cout << "L" << std::endl;
    std::cout << L << std::endl;
    std::cout << "L_T" << std::endl;
    std::cout << L_T << std::endl;
    std::cout << "A" << std::endl;
    std::cout << A << std::endl;
    std::cout << "L*L_T" << std::endl;
    std::cout << L*L_T << std::endl;

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

void qRDecomposition(Eigen::MatrixXd &A,Eigen::MatrixXd &Q, Eigen::MatrixXd &R)

{

A=QR

Q: is orthogonal matrix-> columns of Q are orthonormal

R: is upper triangulate matrix

this is possible when columns of A are linearly indipendent

Eigen::MatrixXd thinQ(A.rows(),A.cols() ), q(A.rows(),A.rows());

Eigen::HouseholderQR<Eigen::MatrixXd> householderQR(A);

q = householderQR.householderQ();

thinQ.setIdentity();

Q = householderQR.householderQ() * thinQ;

R=Q.transpose()*A;

}

void qRExample()

{

Eigen::MatrixXd A;

A.setRandom(3,4);

std::cout<<"A" <<std::endl;

std::cout<<A <<std::endl;

Eigen::MatrixXd Q(A.rows(),A.rows());

Eigen::MatrixXd R(A.rows(),A.cols());

/////////////////////////////////HouseholderQR////////////////////////

Eigen::MatrixXd thinQ(A.rows(),A.cols() ), q(A.rows(),A.rows());

Eigen::HouseholderQR<Eigen::MatrixXd> householderQR(A);

q = householderQR.householderQ();

thinQ.setIdentity();

Q = householderQR.householderQ() * thinQ;

std::cout << "HouseholderQR" <<std::endl;

std::cout << "Q" <<std::endl;

std::cout << Q <<std::endl;

R = householderQR.matrixQR().template triangularView<Eigen::Upper>();

std::cout << R<<std::endl;

std::cout << R.rows()<<std::endl;

std::cout << R.cols()<<std::endl;

R=Q.transpose()*A;

// std::cout << "R" <<std::endl;

// std::cout << R<<std::endl;

std::cout << "A-Q*R" <<std::endl;

std::cout << A-Q*R <<std::endl;

/////////////////////////////////ColPivHouseholderQR////////////////////////

Eigen::ColPivHouseholderQR<Eigen::MatrixXd> colPivHouseholderQR(A.rows(), A.cols());

colPivHouseholderQR.compute(A);

//R = colPivHouseholderQR.matrixR().template triangularView<Upper>();

R = colPivHouseholderQR.matrixR();

Q = colPivHouseholderQR.matrixQ();

std::cout << "ColPivHouseholderQR" <<std::endl;

std::cout << "Q" <<std::endl;

std::cout << Q <<std::endl;

std::cout << "R" <<std::endl;

std::cout << R <<std::endl;

std::cout << "A-Q*R" <<std::endl;

std::cout << A-Q*R <<std::endl;

/////////////////////////////////FullPivHouseholderQR////////////////////////

std::cout << "FullPivHouseholderQR" <<std::endl;

Eigen::FullPivHouseholderQR<Eigen::MatrixXd> fullPivHouseholderQR(A.rows(), A.cols());

fullPivHouseholderQR.compute(A);

Q=fullPivHouseholderQR.matrixQ();

R=fullPivHouseholderQR.matrixQR().template triangularView<Eigen::Upper>();

std::cout << "Q" <<std::endl;

std::cout << Q <<std::endl;

std::cout << "R" <<std::endl;

std::cout << R <<std::endl;

std::cout << "A-Q*R" <<std::endl;

std::cout << A-Q*R <<std::endl;

}

void lDUDecomposition()

{

L: lower triangular matrix L

U: upper triangular matrix U

D: is a diagonal matrix

A=LDU

}

void lUDecomposition()

{

L: lower triangular matrix L

U: upper triangular matrix U

A=LU

}

double exp(double x) // the functor we want to apply

{

std::setprecision(5);

return std::trunc(x);

}

void gramSchmidtOrthogonalization(Eigen::MatrixXd &matrix,Eigen::MatrixXd &orthonormalMatrix)

{

In this method you make every column perpendicular to it's previous columns,

here if a and b are representation vector of two columns, c=b-((b.a)/|a|).a

b /

---------->

b / |

/ | c

/ |

---------->

you just have to normilze every vector after make it perpendicular to previous columns

so:

q1=a.normalized();

q2=b-(b.q1).q1

q2=q2.normalized();

q3=c-(c.q1).q1 - (c.q2).q2

q3=q3.normalized();

Now we have Q, but we want A=QR so we just multiply both side by Q.transpose(), since Q is orthonormal, Q*Q.transpose() is I

A=QR;

Q.transpose()*A=R;

Eigen::VectorXd col;

for(int i=0;i<matrix.cols();i++)

{

col=matrix.col(i);

col=col.normalized();

for(int j=0;j<i-1;j++)

{

//orthonormalMatrix.col(i)

}

orthonormalMatrix.col(i)=col;

}

Eigen::MatrixXd A(4,3);

A<<1,2,3,-1,1,1,1,1,1,1,1,1;

Eigen::Vector4d a=A.col(0);

Eigen::Vector4d b=A.col(1);

Eigen::Vector4d c=A.col(2);

Eigen::Vector4d q1= a.normalized();

Eigen::Vector4d q2=b-(b.dot(q1))*q1;

q2=q2.normalized();

Eigen::Vector4d q3=c-(c.dot(q1))*q1 - (c.dot(q2))*q2;

q3=q3.normalized();

std::cout<< "q1:"<<std::endl;

std::cout<< q1<<std::endl;

std::cout<< "q2"<<std::endl;

std::cout<< q2<<std::endl;

std::cout<< "q3:"<<std::endl;

std::cout<< q3<<std::endl;

Eigen::MatrixXd Q(4,3);

Q.col(0)=q1;

Q.col(1)=q2;

Q.col(2)=q3;

Eigen::MatrixXd R(3,3);

R=Q.transpose()*(A);

std::cout<<"Q"<<std::endl;

std::cout<< Q<<std::endl;

std::cout<<"R"<<std::endl;

std::cout<< R.unaryExpr(std::ptr_fun(exp))<<std::endl;

//MatrixXd A(4,3), thinQ(4,3), Q(4,4);

Eigen::MatrixXd thinQ(4,3), q(4,4);

//A.setRandom();

Eigen::HouseholderQR<Eigen::MatrixXd> qr(A);

q = qr.householderQ();

thinQ.setIdentity();

thinQ = qr.householderQ() * thinQ;

std::cout << "Q computed by Eigen" << "\n\n" << thinQ << "\n\n";

std::cout << q << "\n\n" << thinQ << "\n\n";

}

void gramSchmidtOrthogonalizationExample()

{

Eigen::MatrixXd matrix(3,4),orthonormalMatrix(3,4) ;

matrix=Eigen::MatrixXd::Random(3,4);////A.setRandom();

gramSchmidtOrthogonalization(matrix,orthonormalMatrix);

}

void choleskyDecompositionExample()

{

Positive-definite matrix:

Matrix Mnxn is said to be positive definite if the scalar zTMz is strictly positive for every non-zero

column vector z n real numbers. zTMz>0

Hermitian matrix:

Matrix Mnxn is said to be positive definite if the scalar z*Mz is strictly positive for every non-zero

column vector z n real numbers. z*Mz>0

z* is the conjugate transpose of z.

Positive semi-definite same as above except zTMz>=0 or z*Mz>=0

Example:

┌2 -1 0┐

M= |-1 2 -1|

|0 - 1 2|

└ ┘

┌ a ┐

z=| b |

| c |

└ ┘

zTMz=a^2 +c^2+ (a-b)^2+ (b-c)^2

Cholesky decomposition:

Cholesky decomposition of a Hermitian positive-definite matrix A is:

A=LL*

L is a lower triangular matrix with real and positive diagonal entries

L* is the conjugate transpose of L

Eigen::MatrixXd A(3,3);

A << 6, 0, 0, 0, 4, 0, 0, 0, 7;

Eigen::MatrixXd L( A.llt().matrixL() );

Eigen::MatrixXd L_T=L.adjoint();//conjugate transpose

std::cout << "L" << std::endl;

std::cout << L << std::endl;

std::cout << "L_T" << std::endl;

std::cout << L_T << std::endl;

std::cout << "A" << std::endl;

std::cout << A << std::endl;

std::cout << "L*L_T" << std::endl;

std::cout << L*L_T << std::endl;

}

Matrix Decomposition with Eigen: QR, Cholesky Decomposition LU, UL Read More »

Eigen Memory Mapping

Leave a Comment / C++, Tutorials / admin

struct point {
    double a;
    double b;
};

void EigenMapExample()
{
    ////////////////////////////////////////First Example/////////////////////////////////////////
    Eigen::VectorXd solutionVec(12,1);
    solutionVec<<1,2,3,4,5,6,7,8,9,10,11,12;
    Eigen::Map<Eigen::MatrixXd> solutionColMajor(solutionVec.data(),4,3);

    Eigen::Map<Eigen::Matrix<double, 3, 4, Eigen::RowMajor> >solutionRowMajor (solutionVec.data());


    std::cout << "solutionColMajor: "<< std::endl;
    std::cout << solutionColMajor<< std::endl;

    std::cout << "solutionRowMajor"<< std::endl;
    std::cout << solutionRowMajor<< std::endl;

    ////////////////////////////////////////Second Example/////////////////////////////////////////

    // https://stackoverflow.com/questions/49813340/stdvectoreigenvector3d-to-eigenmatrixxd-eigen

    int array[9];
    for (int i = 0; i < 9; ++i) {
        array[i] = i;
    }

    Eigen::MatrixXi a(9, 1);
    a = Eigen::Map<Eigen::Matrix3i>(array);
    std::cout << a << std::endl;

    std::vector<point> pointsVec;
    point point1, point2, point3;

    point1.a = 1.0;
    point1.b = 1.5;

    point2.a = 2.4;
    point2.b = 3.5;

    point3.a = -1.3;
    point3.b = 2.4;

    pointsVec.push_back(point1);
    pointsVec.push_back(point2);
    pointsVec.push_back(point3);

    Eigen::Matrix2Xd pointsMatrix2d = Eigen::Map<Eigen::Matrix2Xd>(
        reinterpret_cast<double*>(pointsVec.data()), 2,  long(pointsVec.size()));

    Eigen::MatrixXd pointsMatrixXd = Eigen::Map<Eigen::MatrixXd>(
        reinterpret_cast<double*>(pointsVec.data()), 2, long(pointsVec.size()));

    std::cout << pointsMatrix2d << std::endl;
    std::cout << "==============================" << std::endl;
    std::cout << pointsMatrixXd << std::endl;
    std::cout << "==============================" << std::endl;

    std::vector<Eigen::Vector3d> eigenPointsVec;
    eigenPointsVec.push_back(Eigen::Vector3d(2, 4, 1));
    eigenPointsVec.push_back(Eigen::Vector3d(7, 3, 9));
    eigenPointsVec.push_back(Eigen::Vector3d(6, 1, -1));
    eigenPointsVec.push_back(Eigen::Vector3d(-6, 9, 8));

    Eigen::MatrixXd pointsMatrix = Eigen::Map<Eigen::MatrixXd>(eigenPointsVec[0].data(), 3, long(eigenPointsVec.size()));

    std::cout << pointsMatrix << std::endl;
    std::cout << "==============================" << std::endl;

    pointsMatrix = Eigen::Map<Eigen::MatrixXd>(reinterpret_cast<double*>(eigenPointsVec.data()), 3, long(eigenPointsVec.size()));

    std::cout << pointsMatrix << std::endl;

    std::vector<double> aa = { 1, 2, 3, 4 };
    Eigen::VectorXd b = Eigen::Map<Eigen::VectorXd, Eigen::Unaligned>(aa.data(), long(aa.size()));
}

struct point {

double a;

double b;

};

void EigenMapExample()

{

////////////////////////////////////////First Example/////////////////////////////////////////

Eigen::VectorXd solutionVec(12,1);

solutionVec<<1,2,3,4,5,6,7,8,9,10,11,12;

Eigen::Map<Eigen::MatrixXd> solutionColMajor(solutionVec.data(),4,3);

Eigen::Map<Eigen::Matrix<double, 3, 4, Eigen::RowMajor> >solutionRowMajor (solutionVec.data());

std::cout << "solutionColMajor: "<< std::endl;

std::cout << solutionColMajor<< std::endl;

std::cout << "solutionRowMajor"<< std::endl;

std::cout << solutionRowMajor<< std::endl;

////////////////////////////////////////Second Example/////////////////////////////////////////

// https://stackoverflow.com/questions/49813340/stdvectoreigenvector3d-to-eigenmatrixxd-eigen

int array[9];

for (int i = 0; i < 9; ++i) {

array[i] = i;

}

Eigen::MatrixXi a(9, 1);

a = Eigen::Map<Eigen::Matrix3i>(array);

std::cout << a << std::endl;

std::vector<point> pointsVec;

point point1, point2, point3;

point1.a = 1.0;

point1.b = 1.5;

point2.a = 2.4;

point2.b = 3.5;

point3.a = -1.3;

point3.b = 2.4;

pointsVec.push_back(point1);

pointsVec.push_back(point2);

pointsVec.push_back(point3);

Eigen::Matrix2Xd pointsMatrix2d = Eigen::Map<Eigen::Matrix2Xd>(

reinterpret_cast<double*>(pointsVec.data()), 2, long(pointsVec.size()));

Eigen::MatrixXd pointsMatrixXd = Eigen::Map<Eigen::MatrixXd>(

reinterpret_cast<double*>(pointsVec.data()), 2, long(pointsVec.size()));

std::cout << pointsMatrix2d << std::endl;

std::cout << "==============================" << std::endl;

std::cout << pointsMatrixXd << std::endl;

std::cout << "==============================" << std::endl;

std::vector<Eigen::Vector3d> eigenPointsVec;

eigenPointsVec.push_back(Eigen::Vector3d(2, 4, 1));

eigenPointsVec.push_back(Eigen::Vector3d(7, 3, 9));

eigenPointsVec.push_back(Eigen::Vector3d(6, 1, -1));

eigenPointsVec.push_back(Eigen::Vector3d(-6, 9, 8));

Eigen::MatrixXd pointsMatrix = Eigen::Map<Eigen::MatrixXd>(eigenPointsVec[0].data(), 3, long(eigenPointsVec.size()));

std::cout << pointsMatrix << std::endl;

std::cout << "==============================" << std::endl;

pointsMatrix = Eigen::Map<Eigen::MatrixXd>(reinterpret_cast<double*>(eigenPointsVec.data()), 3, long(eigenPointsVec.size()));

std::cout << pointsMatrix << std::endl;

std::vector<double> aa = { 1, 2, 3, 4 };

Eigen::VectorXd b = Eigen::Map<Eigen::VectorXd, Eigen::Unaligned>(aa.data(), long(aa.size()));

}

Eigen Memory Mapping Read More »

Eigen Arrays, Matrices and Vectors: Definition, Initialization Resizing, Populating and Coefficient Wise Operations

Leave a Comment / C++, Linear Algebra, Tutorials / admin

    std::cout <<"/////////////////Definition////////////////"<<std::endl;

/*
    Definition of vectors and matrices in Eigen comes in the following form:

    Eigen::MatrixSizeType
    Eigen::VectorSizeType
    Eigen::ArraySizeType

    Size can be 2,3,4 for fixed size square matrices or X for dynamic size
    Type can be:
    i for integer,
    f for float,
    d for double,
    c for complex,
    cf for complex float,
    cd for complex double.
*/

    // Vector3f is a fixed column vector of 3 floats:
    Eigen::Vector3f objVector3f;

    // RowVector2i is a fixed row vector of 3 integer:
    Eigen::RowVector2i objRowVector2i;

    // VectorXf is a column vector of size 10 floats:
    Eigen::VectorXf objv(10);


    Eigen::Matrix4d m; // 4x4 double

    Eigen::Matrix4cd objMatrix4cd; // 4x4 double complex


    //a is a 3x3 matrix, with a static float[9] array of uninitialized coefficients,
    Eigen::Matrix3f a;

    //b is a dynamic-size matrix whose size is currently 0x0, and whose array of coefficients hasn't yet been allocated at all.
    Eigen::MatrixXf b;

    //A is a 10x15 dynamic-size matrix, with allocated but currently uninitialized coefficients.
    Eigen::MatrixXf A(10, 15);

    //V is a dynamic-size vector of size 30, with allocated but currently uninitialized coefficients.
    Eigen::VectorXf V(30);


    //Template style definition
    // Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>  &matrix

    Eigen::Matrix<double, 2, 3> my_matrix;
    my_matrix << 1, 2, 3, 4, 5, 6;

    // ArrayXf
    Eigen::Array<float, Eigen::Dynamic, 1> a1;
    // Array3f
    Eigen::Array<float, 3, 1> a2;
    // ArrayXXd
    Eigen::Array<double, Eigen::Dynamic, Eigen::Dynamic> a3;
    // Array33d
    Eigen::Array<double, 3, 3> a4;
    Eigen::Matrix3d matrix_from_array = a4.matrix();


    std::cout <<"///////////////////Initialization//////////////////"<< std::endl;

    Eigen::Matrix2d a_2d;
    a_2d.setRandom();

    a_2d.setConstant(4.3);

    Eigen::MatrixXd identity=Eigen::MatrixXd::Identity(6,6);

    Eigen::MatrixXd zeros=Eigen::MatrixXd::Zero(3, 3);

    Eigen::ArrayXXf table(10, 4);
    table.col(0) = Eigen::ArrayXf::LinSpaced(10, 0, 90);


    std::cout <<"/////////////Matrix Coefficient Wise Operations///////////////////"<< std::endl;
    int i,j;
    std::cout << my_matrix << std::endl;
    std::cout << my_matrix.transpose()<< std::endl;

    std::cout<<my_matrix.minCoeff(&i, &j)<<std::endl;
    std::cout<<my_matrix.maxCoeff(&i, &j)<<std::endl;
    std::cout<<my_matrix.prod()<<std::endl;
    std::cout<<my_matrix.sum()<<std::endl;
    std::cout<<my_matrix.mean()<<std::endl;
    std::cout<<my_matrix.trace()<<std::endl;
    std::cout<<my_matrix.colwise().mean()<<std::endl;
    std::cout<<my_matrix.rowwise().maxCoeff()<<std::endl;
    std::cout<<my_matrix.lpNorm<2>()<<std::endl;
    std::cout<<my_matrix.lpNorm<Eigen::Infinity>()<<std::endl;
    std::cout<<(my_matrix.array()>0).all()<<std::endl;// if all elemnts are positive
    std::cout<<(my_matrix.array()>2).any()<<std::endl;//if any element is greater than 2
    std::cout<<(my_matrix.array()>1).count()<<std::endl;// count the number of elements greater than 1
    std::cout << my_matrix.array() - 2 << std::endl;
    std::cout << my_matrix.array().abs() << std::endl;
    std::cout << my_matrix.array().square() << std::endl;
    std::cout << my_matrix.array() * my_matrix.array() << std::endl;
    std::cout << my_matrix.array().exp() << std::endl;
    std::cout << my_matrix.array().log() << std::endl;
    std::cout << my_matrix.array().sqrt() << std::endl;

    std::cout <<"//////////////////Block Elements Access////////////////////"<< std::endl;
    //Block of size (p,q), starting at (i,j)	matrix.block(i,j,p,q)
    Eigen::MatrixXf mat(4, 4);
    mat << 1, 2, 3, 4,
        5, 6, 7, 8,
        9, 10, 11, 12,
        13, 14, 15, 16;
    std::cout << "Block in the middle" << std::endl;
    std::cout << mat.block<2, 2>(1, 1) << std::endl;

    for (int i = 1; i <= 3; ++i)
    {
        std::cout << "Block of size " << i << "x" << i << std::endl;
        std::cout << mat.block(0, 0, i, i) << std::endl;
    }


    /////////////build matrix from vector, resizing matrix, dynamic size ////////////////
    Eigen::MatrixXd dynamicMatrix;
    int rows, cols;
    rows=3;
    cols=2;
    dynamicMatrix.resize(rows,cols);
    dynamicMatrix<<-1,7,3,4,5,1;

    //If you want a conservative variant of resize() which does not change the coefficients, use conservativeResize()
    dynamicMatrix.conservativeResize(dynamicMatrix.rows(), dynamicMatrix.cols()+1);
    dynamicMatrix.col(dynamicMatrix.cols()-1) = Eigen::Vector3d(1, 4, 0);

    dynamicMatrix.conservativeResize(dynamicMatrix.rows(), dynamicMatrix.cols()+1);
    dynamicMatrix.col(dynamicMatrix.cols()-1) = Eigen::Vector3d(5, -8, 6);
/*
    you should expect this:
     1  7  1  5
     3  4  4 -8
     5  1  0  6

*/
    std::cout<< dynamicMatrix<<std::endl;

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

std::cout <<"/////////////////Definition////////////////"<<std::endl;

Definition of vectors and matrices in Eigen comes in the following form:

Eigen::MatrixSizeType

Eigen::VectorSizeType

Eigen::ArraySizeType

Size can be 2,3,4 for fixed size square matrices or X for dynamic size

Type can be:

i for integer,

f for float,

d for double,

c for complex,

cf for complex float,

cd for complex double.

// Vector3f is a fixed column vector of 3 floats:

Eigen::Vector3f objVector3f;

// RowVector2i is a fixed row vector of 3 integer:

Eigen::RowVector2i objRowVector2i;

// VectorXf is a column vector of size 10 floats:

Eigen::VectorXf objv(10);

Eigen::Matrix4d m; // 4x4 double

Eigen::Matrix4cd objMatrix4cd; // 4x4 double complex

//a is a 3x3 matrix, with a static float[9] array of uninitialized coefficients,

Eigen::Matrix3f a;

//b is a dynamic-size matrix whose size is currently 0x0, and whose array of coefficients hasn't yet been allocated at all.

Eigen::MatrixXf b;

//A is a 10x15 dynamic-size matrix, with allocated but currently uninitialized coefficients.

Eigen::MatrixXf A(10, 15);

//V is a dynamic-size vector of size 30, with allocated but currently uninitialized coefficients.

Eigen::VectorXf V(30);

//Template style definition

// Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> &matrix

Eigen::Matrix<double, 2, 3> my_matrix;

my_matrix << 1, 2, 3, 4, 5, 6;

// ArrayXf

Eigen::Array<float, Eigen::Dynamic, 1> a1;

// Array3f

Eigen::Array<float, 3, 1> a2;

// ArrayXXd

Eigen::Array<double, Eigen::Dynamic, Eigen::Dynamic> a3;

// Array33d

Eigen::Array<double, 3, 3> a4;

Eigen::Matrix3d matrix_from_array = a4.matrix();

std::cout <<"///////////////////Initialization//////////////////"<< std::endl;

Eigen::Matrix2d a_2d;

a_2d.setRandom();

a_2d.setConstant(4.3);

Eigen::MatrixXd identity=Eigen::MatrixXd::Identity(6,6);

Eigen::MatrixXd zeros=Eigen::MatrixXd::Zero(3, 3);

Eigen::ArrayXXf table(10, 4);

table.col(0) = Eigen::ArrayXf::LinSpaced(10, 0, 90);

std::cout <<"/////////////Matrix Coefficient Wise Operations///////////////////"<< std::endl;

int i,j;

std::cout << my_matrix << std::endl;

std::cout << my_matrix.transpose()<< std::endl;

std::cout<<my_matrix.minCoeff(&i, &j)<<std::endl;

std::cout<<my_matrix.maxCoeff(&i, &j)<<std::endl;

std::cout<<my_matrix.prod()<<std::endl;

std::cout<<my_matrix.sum()<<std::endl;

std::cout<<my_matrix.mean()<<std::endl;

std::cout<<my_matrix.trace()<<std::endl;

std::cout<<my_matrix.colwise().mean()<<std::endl;

std::cout<<my_matrix.rowwise().maxCoeff()<<std::endl;

std::cout<<my_matrix.lpNorm<2>()<<std::endl;

std::cout<<my_matrix.lpNorm<Eigen::Infinity>()<<std::endl;

std::cout<<(my_matrix.array()>0).all()<<std::endl;// if all elemnts are positive

std::cout<<(my_matrix.array()>2).any()<<std::endl;//if any element is greater than 2

std::cout<<(my_matrix.array()>1).count()<<std::endl;// count the number of elements greater than 1

std::cout << my_matrix.array() - 2 << std::endl;

std::cout << my_matrix.array().abs() << std::endl;

std::cout << my_matrix.array().square() << std::endl;

std::cout << my_matrix.array() * my_matrix.array() << std::endl;

std::cout << my_matrix.array().exp() << std::endl;

std::cout << my_matrix.array().log() << std::endl;

std::cout << my_matrix.array().sqrt() << std::endl;

std::cout <<"//////////////////Block Elements Access////////////////////"<< std::endl;

//Block of size (p,q), starting at (i,j) matrix.block(i,j,p,q)

Eigen::MatrixXf mat(4, 4);

mat << 1, 2, 3, 4,

5, 6, 7, 8,

9, 10, 11, 12,

13, 14, 15, 16;

std::cout << "Block in the middle" << std::endl;

std::cout << mat.block<2, 2>(1, 1) << std::endl;

for (int i = 1; i <= 3; ++i)

{

std::cout << "Block of size " << i << "x" << i << std::endl;

std::cout << mat.block(0, 0, i, i) << std::endl;

}

/////////////build matrix from vector, resizing matrix, dynamic size ////////////////

Eigen::MatrixXd dynamicMatrix;

int rows, cols;

rows=3;

cols=2;

dynamicMatrix.resize(rows,cols);

dynamicMatrix<<-1,7,3,4,5,1;

//If you want a conservative variant of resize() which does not change the coefficients, use conservativeResize()

dynamicMatrix.conservativeResize(dynamicMatrix.rows(), dynamicMatrix.cols()+1);

dynamicMatrix.col(dynamicMatrix.cols()-1) = Eigen::Vector3d(1, 4, 0);

dynamicMatrix.conservativeResize(dynamicMatrix.rows(), dynamicMatrix.cols()+1);

dynamicMatrix.col(dynamicMatrix.cols()-1) = Eigen::Vector3d(5, -8, 6);

you should expect this:

1 7 1 5

3 4 4 -8

5 1 0 6

std::cout<< dynamicMatrix<<std::endl;

Eigen Arrays, Matrices and Vectors: Definition, Initialization Resizing, Populating and Coefficient Wise Operations Read More »

Finding roll, pitch yaw from 3X3 rotation matrix with Eigen

Leave a Comment / C++, ROS, Tutorials / admin

/*  http://planning.cs.uiuc.edu/node103.html

    |r11 r12 r13 |
    |r21 r22 r23 |
    |r31 r32 r33 |

    yaw: alpha=arctan(r21/r11)
    pitch: beta=arctan(-r31/sqrt( r32^2+r33^2 ) )
    roll: gamma=arctan(r32/r33)
*/
    double roll, pitch, yaw;
    roll=M_PI/3;
    pitch=M_PI/4;
    yaw=M_PI/6;
    Eigen::AngleAxisd rollAngle(roll, Eigen::Vector3d::UnitX());
    Eigen::AngleAxisd pitchAngle(pitch, Eigen::Vector3d::UnitY());
    Eigen::AngleAxisd yawAngle(yaw, Eigen::Vector3d::UnitZ());

    Eigen::Quaternion<double> q =  yawAngle*pitchAngle *rollAngle;
    Eigen::Matrix3d rotationMatrix = q.matrix();



    std::cout<<"roll is Pi/" <<M_PI/atan2( rotationMatrix(2,1),rotationMatrix(2,2) ) <<std::endl;
    std::cout<<"pitch: Pi/" <<M_PI/atan2( -rotationMatrix(2,0), std::pow( rotationMatrix(2,1)*rotationMatrix(2,1) +rotationMatrix(2,2)*rotationMatrix(2,2) ,0.5  )  ) <<std::endl;
    std::cout<<"yaw is Pi/" <<M_PI/atan2( rotationMatrix(1,0),rotationMatrix(0,0) ) <<std::endl;

/* http://planning.cs.uiuc.edu/node103.html

|r11 r12 r13 |

|r21 r22 r23 |

|r31 r32 r33 |

yaw: alpha=arctan(r21/r11)

pitch: beta=arctan(-r31/sqrt( r32^2+r33^2 ) )

roll: gamma=arctan(r32/r33)

double roll, pitch, yaw;

roll=M_PI/3;

pitch=M_PI/4;

yaw=M_PI/6;

Eigen::AngleAxisd rollAngle(roll, Eigen::Vector3d::UnitX());

Eigen::AngleAxisd pitchAngle(pitch, Eigen::Vector3d::UnitY());

Eigen::AngleAxisd yawAngle(yaw, Eigen::Vector3d::UnitZ());

Eigen::Quaternion<double> q = yawAngle*pitchAngle *rollAngle;

Eigen::Matrix3d rotationMatrix = q.matrix();

std::cout<<"roll is Pi/" <<M_PI/atan2( rotationMatrix(2,1),rotationMatrix(2,2) ) <<std::endl;

std::cout<<"pitch: Pi/" <<M_PI/atan2( -rotationMatrix(2,0), std::pow( rotationMatrix(2,1)*rotationMatrix(2,1) +rotationMatrix(2,2)*rotationMatrix(2,2) ,0.5 ) ) <<std::endl;

std::cout<<"yaw is Pi/" <<M_PI/atan2( rotationMatrix(1,0),rotationMatrix(0,0) ) <<std::endl;

Finding roll, pitch yaw from 3X3 rotation matrix with Eigen Read More »

Roll, pitch, yaw using Eigen and KDL Frame

Leave a Comment / C++, Linear Algebra, ROS, Tutorials / admin

/*
yaw:
    A yaw is a counterclockwise rotation of alpha about the  z-axis. The rotation matrix is given by

    R_z

    |cos(alpha) -sin(alpha) 0|
    |sin(apha)   cos(alpha) 0|
    |    0            0     1|

pitch:
    R_y
    A pitch is a counterclockwise rotation of  beta about the  y-axis. The rotation matrix is given by

    |cos(beta)  0   sin(beta)|
    |0          1       0    |
    |-sin(beta) 0   cos(beta)|

roll:
    A roll is a counterclockwise rotation of  gamma about the  x-axis. The rotation matrix is given by
    R_x
    |1          0           0|
    |0 cos(gamma) -sin(gamma)|
    |0 sin(gamma)  cos(gamma)|



    It is important to note that   R_z R_y R_x performs the roll first, then the pitch, and finally the yaw
    Roration matrix: R_z*R_y*R_x
*/

    double roll, pitch, yaw;
    roll=M_PI/3;
    pitch=M_PI/4;
    yaw=M_PI/6;
    Eigen::AngleAxisd rollAngle(roll, Eigen::Vector3d::UnitX());
    Eigen::AngleAxisd pitchAngle(pitch, Eigen::Vector3d::UnitY());
    Eigen::AngleAxisd yawAngle(yaw, Eigen::Vector3d::UnitZ());




    Eigen::Quaternion<double> q =  yawAngle*pitchAngle *rollAngle;

    Eigen::Matrix3d rotationMatrix = q.matrix();
    std::cout<<rotationMatrix <<std::endl;

yaw:

A yaw is a counterclockwise rotation of alpha about the z-axis. The rotation matrix is given by

R_z

|cos(alpha) -sin(alpha) 0|

|sin(apha) cos(alpha) 0|

| 0 0 1|

pitch:

R_y

A pitch is a counterclockwise rotation of beta about the y-axis. The rotation matrix is given by

|cos(beta) 0 sin(beta)|

|0 1 0 |

|-sin(beta) 0 cos(beta)|

roll:

A roll is a counterclockwise rotation of gamma about the x-axis. The rotation matrix is given by

R_x

|1 0 0|

|0 cos(gamma) -sin(gamma)|

|0 sin(gamma) cos(gamma)|

It is important to note that R_z R_y R_x performs the roll first, then the pitch, and finally the yaw

Roration matrix: R_z*R_y*R_x

double roll, pitch, yaw;

roll=M_PI/3;

pitch=M_PI/4;

yaw=M_PI/6;

Eigen::AngleAxisd rollAngle(roll, Eigen::Vector3d::UnitX());

Eigen::AngleAxisd pitchAngle(pitch, Eigen::Vector3d::UnitY());

Eigen::AngleAxisd yawAngle(yaw, Eigen::Vector3d::UnitZ());

Eigen::Quaternion<double> q = yawAngle*pitchAngle *rollAngle;

Eigen::Matrix3d rotationMatrix = q.matrix();

std::cout<<rotationMatrix <<std::endl;

From Eigen documentation: If you are working with OpenGL 4×4 matrices then Affine3f and Affine3d are what you want. Since Eigen defaults to column-major storage, you can directly use the Transform::data() method to pass your transformation matrix to OpenGL. construct a Transform:

Transform t(AngleAxis(angle,axis));

1	Transform t(AngleAxis(angle,axis));

or like this:

Transform t;
t = AngleAxis(angle,axis);

1 2	Transform t; t = AngleAxis(angle,axis);

But note that unfortunately, because of

Roll, pitch, yaw using Eigen and KDL Frame Read More »

Generating multivariate normal distribution samples using C++11 and Eigen library.

Leave a Comment / C++, Linear Algebra, Machine Learning / admin

Eigen is a great tool for matrix operations, here I found a small piece of code in Github that enables you to generate multivariate normal distribution samples using C++11 and Eigen library. The below is an example:

#include <fstream>
#include <Eigen/Eigen>
#include <Eigen/Core>
#include <Eigen/Dense>
#include "eigenmvn.h"



int main(int argc, char ** argv)
{
	//number of columns
	const uint n_cols = 2; 
	// number of rows
	const uint n_rows = 5000; 

	Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> total_gaussian_data_eigen, first_gaussian_data_eigen,second_gaussian_data_eigen;
	first_gaussian_data_eigen.setZero(n_rows,n_cols);
	second_gaussian_data_eigen.setZero(n_rows,n_cols);
	//2*n_rows since we want to concat first and second and put it in this matrix
	total_gaussian_data_eigen.setZero(2*n_rows,n_cols);



	Eigen::Vector2f mean;
	Eigen::Matrix2f covar;
	float theta;

	mean << 0,0; // Set the mean
	
	/* our covar matrix:
	|10  0|
	|0   1|
	*/
	covar <<10,0,0,1;

	//first gaussian
	Eigen::EigenMultivariateNormal<float> normX_solver1(mean,covar);
	first_gaussian_data_eigen<< normX_solver1.samples(n_rows).transpose() ;
	
	
	//secodn gaussian
	mean << 4,4; // Set the mean
// 	Create a covariance matrix rotated clockwise by theta
	theta=M_PI/4.0;
	covar=genCovar(1,4,theta);
	
	Eigen::EigenMultivariateNormal<float> normX_solver2(mean,covar);
	second_gaussian_data_eigen<<normX_solver2.samples(n_rows).transpose() ;


	//concating two gaussians
	total_gaussian_data_eigen<<first_gaussian_data_eigen,second_gaussian_data_eigen;

	
	//writing data into output in csv format
    std::cout<<"x,y\n";
    for (uint i = 0; i < total_gaussian_data_eigen.rows(); i++)
    {
        for (uint h = 0; h < n_cols-1; h++)
        {
                    std::cout<<total_gaussian_data_eigen(i,h);
                    std::cout<<",";
        }
        std::cout<<total_gaussian_data_eigen(i,n_cols-1);
        std::cout<<std::endl;
    }

}

#include <fstream>

#include <Eigen/Eigen>

#include <Eigen/Core>

#include <Eigen/Dense>

#include "eigenmvn.h"

int main(int argc, char ** argv)

{

//number of columns

const uint n_cols = 2;

// number of rows

const uint n_rows = 5000;

Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> total_gaussian_data_eigen, first_gaussian_data_eigen,second_gaussian_data_eigen;

first_gaussian_data_eigen.setZero(n_rows,n_cols);

second_gaussian_data_eigen.setZero(n_rows,n_cols);

//2*n_rows since we want to concat first and second and put it in this matrix

total_gaussian_data_eigen.setZero(2*n_rows,n_cols);

Eigen::Vector2f mean;

Eigen::Matrix2f covar;

float theta;

mean << 0,0; // Set the mean

/* our covar matrix:

|10 0|

|0 1|

covar <<10,0,0,1;

//first gaussian

Eigen::EigenMultivariateNormal<float> normX_solver1(mean,covar);

first_gaussian_data_eigen<< normX_solver1.samples(n_rows).transpose() ;

//secodn gaussian

mean << 4,4; // Set the mean

// Create a covariance matrix rotated clockwise by theta

theta=M_PI/4.0;

covar=genCovar(1,4,theta);

Eigen::EigenMultivariateNormal<float> normX_solver2(mean,covar);

second_gaussian_data_eigen<<normX_solver2.samples(n_rows).transpose() ;

//concating two gaussians

total_gaussian_data_eigen<<first_gaussian_data_eigen,second_gaussian_data_eigen;

//writing data into output in csv format

std::cout<<"x,y\n";

for (uint i = 0; i < total_gaussian_data_eigen.rows(); i++)

{

for (uint h = 0; h < n_cols-1; h++)

{

std::cout<<total_gaussian_data_eigen(i,h);

std::cout<<",";

}

std::cout<<total_gaussian_data_eigen(i,n_cols-1);

std::cout<<std::endl;

}

Generating multivariate normal distribution samples using C++11 and Eigen library. Read More »

Cookie	Duration	Description
cookielawinfo-checbox-analytics	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Analytics".
cookielawinfo-checbox-functional	11 months	The cookie is set by GDPR cookie consent to record the user consent for the cookies in the category "Functional".
cookielawinfo-checbox-others	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Other.
cookielawinfo-checkbox-necessary	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookies is used to store the user consent for the cookies in the category "Necessary".
cookielawinfo-checkbox-performance	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Performance".
viewed_cookie_policy	11 months	The cookie is set by the GDPR Cookie Consent plugin and is used to store whether or not user has consented to the use of cookies. It does not store any personal data.