Provided by: librheolef-dev_5.93-2_amd64 bug

NAME

       basic_diag - diagonal matrix

DESCRIPTION

        The class implements a diagonal matrix.
        A declaration whithout any parametrers correspond to a null size matrix:

               basic_diag<Float> d;

        The constructor can be invocated whith a size parameter:

               basic_diag<Float> d(n);

        or an initialiser, either a vector (see vec(3)):

               basic_diag<Float> d = basic_diag(v);

        or a csr matrix see csr(3):

               basic_diag<Float> d = basic_diag(a);

        The conversion from basic_diag to
        vec or csr is explicit.

        When a diagonal matrix is constructed from a csr matrix,
        the definition of the diagonal of matrix is @emph{always} a vector of size
        nrow
        which contains the elements in rows 1 to nrow of
        the matrix that are contained in the diagonal.
        If the diagonal element falls outside the matrix,
        i.e. ncol < nrow then it is
        defined as a zero entry.

NOTE

        Since the basic_diag class derives from the
        vec,  the basic_diag class
        present also a STL-like interface.

IMPLEMENTATION

       template<class T>
       class basic_diag : public vec<T> {
       public:

       // typedefs:

           typedef typename vec<T>::element_type element_type;
           typedef typename vec<T>::size_type    size_type;
           typedef typename vec<T>::iterator     iterator;

       // allocators/deallocators:

           explicit basic_diag (size_type sz = 0);
           explicit basic_diag (const vec<T>& u);
           explicit basic_diag (const csr<T>& a);

       // assignment:

           basic_diag<T> operator = (const T& lambda);

       // accessors:

           size_type nrow () const { return vec<T>::size(); }
           size_type ncol () const { return vec<T>::size(); }

       // basic_diag as a preconditionner: solves D.x=b

           vec<T> solve (const vec<T>& b) const;
           vec<T> trans_solve (const vec<T>& b) const;
       };
       template <class T>
       basic_diag<T> dcat (const basic_diag<T>& a1, const basic_diag<T>& a2);

       template <class T>
       basic_diag<T> operator / (const T& lambda, const basic_diag<T>& d);

       template <class T>
       vec<T>
       operator * (const basic_diag<T>& d, const vec<T>& x);

       template<class T>
       vec<T> left_div (const vec<T>& x, const basic_diag<T>& d);

SEE ALSO

       vec(3), csr(3)