First thank you for help, but I still find it very hard to use the ublas (yes I am somewhat between an oldie and newbie). I tried to find out what is happening in the case: matrix<double> foo() { matrix<double> r(3); return r; } ... r1 = foo(); The matrix (that was constructed on the stack) is copied twice when used in this manner. One copy for the returned temporary, a second copy for the assignment. (I am using MSVC debug mode) And this definitely is not a cheap operation. Both in terms of memory _and_ execution time. Also a second question comes to me now: Can I define a LHS that can be the target of an arbitrary size matrix? I.e.: matrix<double> lhs; matrix<doubel> rhs(3,3); lhs = rhs; will give a runtime exeception because of different size. Can I do anything about this? I have the feeling, that I still do not well understand the overall semantics of the matrix and vector classes. Are there any books/examples which I can study to get a better understanding? Thank you again, Roland

Hi Ivan, you've been faster again ;-). You wrote:

<speedsnaii@yahoo.de> wrote in message news:b2nq2e+jht8@eGroups.com... | I tried to find out what is happening in the case: | | matrix<double> foo() | { | matrix<double> r(3); | return r; | } ... | r1 = foo(); | | The matrix (that was constructed on the stack) is copied twice when | used in this manner. One copy for the returned temporary, a second | copy for the assignment. (I am using MSVC debug mode) And this | definitely is not a cheap operation. Both in terms of memory _and_ | execution time.

The first copy indicates that MSVC (6?) could not apply the NRVO optimization. It may support the RVO optimization though: you could try using direct returns when possible: return matrix<double>(3);

The second copy will be avoided by the compiler if you use construction of a new variable instead of assignment: matrix<double> r1 = foo(); // shall avoid 2nd copy or: matrix<double> const& r2 = foo(); // always optimized // but can trigger a VC7 bug

I agree these alternatives are not fully equivalent, but they are coding style tricks that can be useful to improve performance.

Besides the question, when which compiler uses RVO: if Roland needs uttermost performance using similar interfaces, we'll either have to add the mojo protocol or he should try to extend the expression template machinery.

| Also a second question comes to me now: | Can I define a LHS that can be the target of an arbitrary size matrix? | I.e.: | matrix<double> lhs; | matrix<doubel> rhs(3,3); | | lhs = rhs; | | will give a runtime exeception because of different size. Can I do | anything about this?

Yes. Four ways: 1. matrix<double> lhs(3,3); matrix<double> rhs(3,3); lhs = rhs; 2. matrix<double> rhs(3,3); matrix<double> lhs(rhs); 3. matrix<double> lhs; matrix<double> rhs(3,3); lhs.resize(3,3); lhs = rhs; 4. matrix<double> lhs; matrix<double> rhs(3,3); lhs.reset(rhs);

I'm not a UBLAS expert. But here also, declaring variables where they are initialized would solve the problem, and provide best performance: matrix<double> const lhs = rhs; // drop the 'const' if required

This is the usually recommended C++ style. And to go back to your original question, it requires that toutines *return* their result instead of taking output parameters. ( but I cannot certify that boost's UBLAS was developed with this in mind )

| I have the feeling, that I still do not well understand the overall | semantics of the matrix and vector classes.

uBLAS assumes that vectors and matrices in an assignment have conforming dimensions. Copy semantics are deep.

|Are there any | books/examples which I can study to get a better understanding?

There probably are no books about this. For examples one could look into Michael Stevens' Bayesian Filters at www.sf.net/projects/bayesclasses or Paul C. Leopardi's Clifford Algebras at www.sf.net/projects/glucat

I won't be of much help here. I admit I don't use UBLAS personally. ( I use small fixed-size matrices in my current applications ). But, I home some of the suggestions above may still help...

Thanks, Joerg [Non-text portions of this message have been removed]

"Toon Knapen" <toon.knapen@si-lab.org> wrote in message news:200302181202.36464.toon.knapen@si-lab.org... | On Monday 17 February 2003 19:21, Ivan Vecerina wrote: | > matrix<double> const& r2 = foo(); // always optimized | > // but can trigger a VC7 bug | | Here you're taking a const-reference to a temporary. | From the moment you're using r2 you have 'undefined behaviour' IMHO. Not at all ! When a temporary is bound to a const-reference, its lifetime is extended to the lifetime of that reference. This is clearly specified in the C++ standard at 12.2/5. For a discussion of this feature (and beyond) by the C++ working group back in 1993, see: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/1993/N0345.pdf This had already been decided in 1993, VC6 supports the behavior correctly. Unfortunately, in recent trials I made with VC7, it seems that support for this C++ feature is broken (in some complex functions, premature re-use of the memory allocated to the temporary seemed to occur). This feature is useful to help avoid unnecessary copies of the value returned by an expression. It also allows the safe conversion of functions returning a const reference to a function returning a temporary (if needed during refactoring). Best regards, -- Ivan Vecerina, Dr. med. <> http://www.post1.com/~ivec Soft Dev Manger, xitact <> http://www.xitact.com Brainbench MVP for C++ <> http://www.brainbench.com