Re: [eigen] Confusion about MatrixBase::multiply() and MatrixBase::leftmultiply()

sidenote: with eigen1, to construct a matrix from a row-major array, use readRows().
```
with eigen2 you could do:
A << 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 5,
0, 0, 0, 1;
or you could specify that your matrix itself is row-major.

Cheers,
Benoit

Quoting jacob@xxxxxxxxxxxxxxx:

```
```aaah everything is suddenly more clear...

the "matrix" array is row-major, not column-major.

But the Matrix::Matrix(array) constructor expects a column-major array.

So the matrix that you're effectively constructing, is the transpose of
what you wanted.

Cheers,
Benoit

PS. Any reason you do all these "new" ? Also, Eigen does provide
operator<< to easily print a matrix or vector; and you don't need to
include both matrix.h and vector.h. And, let me encourage you to switch
to eigen2 :)

Quoting Michael <michaelvsk@xxxxxx>:

```
```1. Yes the 5 in the matrix have to be positive.

2. Here is a small example to test the functions:

#include <iostream>
#include <eigen/matrix.h>
#include <eigen/vector.h>
using namespace Eigen;
int main(int argc, char** argv)
{
Vector4f *v = new Vector4f(0.0f, 0.0f, -5.0f, 1.0f);
Vector4f *result = new Vector4f();

float matrix[] = { 1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 5.0f,
0.0f, 0.0f, 0.0f, 1.0f};

Matrix4f *A = new Matrix4f(matrix);

A->multiply(*v, result);
std::cout << "Result is: [" << result->x() << " " << result ->y()
<< " " << result->z() << " " << result->w() << "]\n";

A->leftmultiply(*v, result);
std::cout << "Result is: [" << result->x() << " " << result ->y()
<< " " << result->z() << " " << result->w() << "]\n";
}

I get this result:

Result is: [0 0 -5 -24]
Result is: [0 0 0 1]

Regards,

Michael

jacob@xxxxxxxxxxxxxxx schrieb:
```
```Hi,

Please, could you send me a selfcontained, compiling test case?

```
```A = [1..0..0..0]
....[0..1..0..0]
....[0..0..1.-5]
....[0..0..0..1]

and the vector v = [0 0 -5 1]^T
```
```
we have:
A*v = (0 0 -10 1)
so A.multiply(v, &result) should set result to (0 0 -10 1),

and we have:
v*A = (0 0 -5 26)
so A.leftmultiply(v, &result) should set result to (0 0 -5 26).

```
From the values that you give it seems that you meant +5 somewhere instead of -5.
```
Cheers,
Benoit

Quoting Michael <michaelvsk@xxxxxx>:

```
```Hi,
and thanks for your reply. At first I also thought that this is the
problem but then I tested it with a separate result vector and the
results are exactly the same.

Greetings
Michael

jacob@xxxxxxxxxxxxxxx schrieb:
```
```Hello,

The problem here is that multiply(vector, result) and
leftmultiply(vector, result) assume that vector is different from
*result. In your case you tried to apply these methods with the same
vector on both sides, and that produces a wrong result because the
vector has been partly updated when it is used again to compute the
rest of the product. This is called an aliasing effect.

I can see that I forgot to mention that in the documentation.

Please consider to port to Eigen2, as this issue is one of the many
that were fixed. With Eigen2, there is no multiply() and leftmultiply()
functions anymore, there is only * and *=, so you just do vec *= matrix
or vec = vec * matrix, and it automatically handles aliasing; moreover
if you know that there is no aliasing involved here (because the source
and destination vectors are distinct) then you can do: dest_vec =
(src_vec * matrix).lazy() to force lazy-evaluation i.e. remove the
temporary variable and compute the product in place like eigen1's
multiply() and leftmultiply() did.

Cheers,
Benoit

Quoting Michael <michaelvsk@xxxxxx>:

```
```Hello,
I have a problem with Eigen 1.05 and the functions
MatrixBase::multiply() and MatrixBase::leftmultiply().

The help says that MatrixBase::multiply() computes *this * vector.
and MatrixBase::leftmultiply() cumputes vector * *this (where vector
will be transposed).

But if I have the matrix

A = [1..0..0..0]
....[0..1..0..0]
....[0..0..1.-5]
....[0..0..0..1]

and the vector v = [0 0 -5 1]^T

then A.multiply(*v, v) is [0 0 -5 24]^T but it should be [0 0 0 1]^T.

And A.leftmultiply(*v, v) is [0 0 0 1]but it should be [0 0 -5 24]^T.

```
If it possible that someone has confound something here? Or is it my mistake?!
```
Greetings

Michael
```
```

----------------------------------------------------------------
This message was sent using IMP, the Internet Messaging Program.

---

```
```
---
```
```

----------------------------------------------------------------
This message was sent using IMP, the Internet Messaging Program.

---

```
```
---
```
```

----------------------------------------------------------------
This message was sent using IMP, the Internet Messaging Program.

---
```
```

----------------------------------------------------------------
This message was sent using IMP, the Internet Messaging Program.

---
```

• Follow-Ups:
• References:

 Mail converted by MHonArc 2.6.19+ http://listengine.tuxfamily.org/