Either use

matrix_column v (m.column (2)); // proxy[1]

or

vector<double> v (m.column (2)); // copy

Thank you so much. That seems to be exactly what I was looking for. BTW.: It seems that "matrix_column c "can be used as a reference to any other 'vector-like' type, as the following also works: c = v; // v beeing a vector; c = m.row(2); c = m.col(0); There is still an interesting point: While it is possible to assign a row to the matrix_column it is not possible to supply a row in the constructor call. What is the rationale behind this? If the constructor also would accept a row I could use it as a parameter type for function calls when I want to express, that only 'data' types are expected and 'expressions' are not wanted. (Sorry for the sloppy formulation, I am not sure how to express this more concise.)

...

*) Second question: ...

matrix_column::iterator it;

This is clear to me now. I've RTFM'd ;-) and found the example using the free column() functions. Roland

The constructor constructs the proxy, the assignment operator assigns to the proxied elements.

Oh yes, I can see now, thank you.

...

If the constructor also would accept a row I could use it as a parameter type for function calls when I want to express, that only 'data' types are expected and 'expressions' are not wanted. (Sorry for the sloppy formulation, I am not sure how to express

this

...

more concise.)

I hope, we'll be able to solve this, too.

I am not sure about your last statement. Do you mean a kind of 'vector_proxy' that can act as a placeholder to a row/column or another vector? Roland

Hi, [snip]

...

...

If the constructor also would accept a row I could use it as a parameter type for function calls when I want to express, that only 'data' types are expected and 'expressions' are not wanted. (Sorry for the sloppy formulation, I am not sure how to express this more concise.)

I hope, we'll be able to solve this, too.

I am not sure about your last statement. Do you mean a kind of 'vector_proxy' that can act as a placeholder to a row/column or another vector?

No, I basically meant, I hope that you'll find appropriate signatures for your functions. I still believe you'll either have to use 'expressions' or have to enumerate all overloads for your 'data' types (and that could be many ;-). Sorry for the confusion, Joerg

Hi, [snip]

...

...

I am not sure about your last statement. Do you mean a kind of 'vector_proxy' that can act as a placeholder to a row/column or another vector?

No, I basically meant, I hope that you'll find appropriate signatures for your functions. I still believe you'll either have to use 'expressions' or have to enumerate all overloads for your 'data' types (and that could be many ;-).

So in a certain sense I can see the 'expression' that is stored in my functor as a 'reference' to my container data? I.e when the data of the container changes the evaluation of the expression will retrieve the current data?

Hm, more or less yes

Sorry for my slow uptake on the matter. I think this comes from the fact that I still do not have a sound idea of what an 'expression' is to me from a point of usage. Can I see it as a bundle of funtions having certain parameter lists?

I'd tend to see it as the root of an expression tree build from class objects (at compile time).

What 'really' happens when I "e()(i,j)" ?

The expression is interpreted (at compile time ;-) Best, Joerg

Hi Roland, you wrote:

...

...

If the constructor also would accept a row I could use it as a parameter type for function calls when I want to express, that only 'data' types are expected and 'expressions' are not wanted. (Sorry for the sloppy formulation, I am not sure how to express this more concise.)

I hope, we'll be able to solve this, too.

Finally I found a solution that works with expressions, without the burden of template parameter specification. I took up your suggestion and blended it with boost::function. I would be glad if you could have a look on it and perhaps comment. ==================================================================== #include <iostream> #include #include #include #include #include using namespace boost::numeric::ublas;

// this is the class that implements the functor // it also could be parameterized on more than one expression // (this is what Joerg suggested) template class func_impl { public: func_impl(const vector_expression<E> &e) : e_ (e) {}

func_impl(const vector_expression<E> &e) : e_ (e ()) {}

T operator() (const T& x){ // algorithm goes here ... return e_()(0)*x; // just for demonstration } private: const vector_expression<E> &e_;

// Storing the closure type should prevent some subtle lifetime issues // when chaining functions for example... typename E::const_closure_type e_;

};

// this is the user part of the functor // the constructor is used to act as a generator for the // implementation type. template<class T> class func : public boost::function1 { public: template<class E> func(const vector_expression<E>& e) : boost::function1(func_impl(e)) {} };

int main(int argc, char* argv[]) { matrix<double> m (3,3); vector<double> v (3); func<double> f(m.row(0)); // notice: no need to know the type of m.row

m(0,0) = 0.0; m(0,1) = 0.1; m(0,2) = 0.2; m(1,0) = 1.0; m(1,1) = 1.1; m(1,2) = 1.2; m(2,0) = 2.0; m(2,1) = 2.1; m(2,2) = 2.2;

std::cout << f(1.0) << std::endl; // outputs: 0

m(0,0) = 47.11; // change the referenced matrix std::cout << f(1.0) << std::endl; // outputs: 47.11

// other argument types ... func<double> f1(m.column(2)); std::cout << f1(1.0) << std::endl; // outputs: 0.2 m(0,2) = 13; std::cout << f1(1.0) << std::endl; // outputs: 13

// similar with vector ... func<double> f2(v);

return 0; } ====================================================================

Of course this involves an indirection since I am using the functiom.hpp from boost as base class. But I think this is not avoidable in principle, since this is what a reference is all about, isn't it?

Impressed-by-this-nice-combination-of-different-libraries-ly y'rs Joerg