Ich denke gerade darüber nach die Numerik-Vektor-Klasse von uBLAS ein
wenig anzupassen. (z.B. anderen << Operator). Teoretisch kann ich mir ja was eigenes ableiten und ein paar Sachen überladen:

template<typename T>
class myvector : public boost::numeric::ublas::vector<T>
{};

Und da ich eh' stets double verwende kommt noch:

typedef myvector<double> Vector;

Leider bemeckert das der Compiler. Und selbst wenn er es nicht täte, ist mir nicht ganz wohl bei der Sache.

Was mache ich falsch? Oder ist das generell keine gute Idee?

Vielen Dank,
Stimpy

Vector x; // das ist OK
Vector x(3); // das nicht

Fehlermeldung:

main.cpp:8: error: no matching function for call to `myvector<double>::myvector(int)'
numeric.h:15: note: candidates are: myvector<double>::myvector()
numeric.h:15: note: myvector<double>::myvector(const myvector<double>&)

Wieder was Grundlegendes gelernt.
Vielen Dank!

class Vector : public boost::numeric::ublas::vector<double>
{
public:
	Vector(int size) : boost::numeric::ublas::vector<double>::vector(size) {}
};

Blöd ist nur, daß er jetzt gewisse Konvertierungen offenar nicht mehr hinbekommt.

Vector bb = prod(a,x);

main.cpp:39: error: conversion from `boost::numeric::ublas::matrix_vector_binary1<boost::numeric::ublas::matrix<double, boost::numeric::ublas::basic_row_major<size_t, ptrdiff_t>, boost::numeric::ublas::unbounded_array<double, std::allocator<double> > >, boost::numeric::ublas::vector<double, boost::numeric::ublas::unbounded_array<double, std::allocator<double> > >, boost::numeric::ublas::matrix_vector_prod1<double, double, double> >' to non-scalar type `Vector' requested

Schuld sind wohl die Expression-Templates. Da müßte ich wohl die Konvertierungen auch alle nochmal hinschreiben. Ich schätze mal das ist nicht so ganz trivial...
Das wird mir langsam etwas heftig, oder hat jemand noch einen spontanen Einfall?

class Vector : public boost::numeric::ublas::vector<double>
{
public:
    Vector(int size) : boost::numeric::ublas::vector<double>::vector(size) {}
    Vector(const boost::numeric::ublas::vector<double>& rhs) : boost::numeric::ublas::vector<double>::vector(rhs) {}
    Vector& operator=(const boost::numeric::ublas::vector<double>& rhs)
    { boost::numeric::ublas::vector<double>::operator=(rhs); return *this; }
};

Da forsche ich morgen mal weiter.
Danke erstmal!

class Vector : public boost::numeric::ublas::vector<double>
{
    typedef boost::numeric::ublas::vector<double> base;
public:
    template<typename T>
    Vector(const T& arg) : base(arg) {}
    template<typename T>
    Vector& operator=(const T& rhs)
    {
        base::operator=(rhs);
        return *this;
    }
};

andere funktionen werden ja nicht verdeckt.

die uBLAS Templatezaubereien machen wohl folgendes:

- jede Binäre Operation wird zu einem Objekt erklärt
- wenn jemand das Ergbnis als vector<double> sehen will,
wird der Ausdruck ausgewertet (z.B. im Zuweisungsop.)
- die Umwandlung Operation -> vector<double> ist ein Schritt
und wird daher implizit ausgeführt
- die Umwandlung Operation -> "Mein Vector" hingegen nicht mehr,
da das zwei Schritte sind
- daher glaube ich, daß ich sämtliche Umwandlungen, die uBLAS
vorsieht selbst klöppeln muß (und das sind sicher einige)

Darauf deutet auch die obengenannte Fehlermeldung hin:

error: conversion from `boost::numeric::ublas::matrix_vector_binary1< ...blabla ...>' to non-scalar type `Vector' requested

Oder mir gelingt es, dem Compiler klar zu machen,
daß die zusätzliche Wandlung vom uBLAS vector<double> in meinen 'Vector' kein Problem ist.