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

NAME

       ssk - symmetric skyline matrix format

DESCRIPTION

        The class implements a symmetric matrix Choleski factorization.
        Let a be a square invertible matrix in
        csr format (see csr(3)).

               csr<Float> a;

        We get the factorization by:

               ssk<Float> m = ldlt(a);

        Each call to the direct solver for a*x = b writes either:

               vec<Float> x = m.solve(b);

        or

               m.solve(b,x);

DATA STRUCTURE

        The storage is either skyline, multi-file or
        chevron.
        This alternative depends upon the configuration
        (see .  Installing}').
        The chevron data structure is related to the multifrontal
        algorithm and is implemented by using the spooles library.
        The multi-file data structure refers to the out-of-core
        algorithm and is implemented by using the taucs library.
        If such a library is not available, the ssk class
        implements a skyline storage scheme and the profil storage of the
        ssk matrix is optimized by optimizing the renumbering,
        by using the Gibbs, Pooles and Stockmeyer algorithm available
        via the permutation class
        (see permutation(3)).
        @quotation  Algorithm  582,  collected  Algorithms  from ACM.  Algorithm appeared in ACM-
       Trans. Math. Software, vol.8, no. 2, Jun., 1982, p. 190.
        @end quotation
        When implementing the skyline data structure,
        we can go back to the csr format, for the
        pupose of pretty-printing:

               cout << ps << color << logscale << csr<Float>(m);

IMPLEMENTATION

       template<class T>
       class ssk : smart_pointer<spooles_rep<T> > {
       public:
       // typedefs:

               typedef          T                          element_type;
               typedef typename spooles_rep<T>::size_type  size_type;

       // allocators/deallocators:

               ssk ();
               explicit ssk<T> (const csr<T>&);

       // accessors:

               size_type nrow () const;
               size_type ncol () const;
               size_type nnz  () const;

       // factorisation and solver:

               void solve(const vec<T>& b, vec<T>& x) const;
               vec<T> solve(const vec<T>& b) const;
               void factorize_ldlt();
       protected:
               const spooles_rep<T>& data() const {
                       return smart_pointer<spooles_rep<T> >::data();
               }
               spooles_rep<T>& data() {
                       return smart_pointer<spooles_rep<T> >::data();
               }
       };
       template <class T>
       ssk<T> ldlt (const csr<T>& m);

IMPLEMENTATION

       template<class T>
       class ssk : smart_pointer<umfpack_rep<T> > {
       public:
       // typedefs:

               typedef          T                          element_type;
               typedef typename umfpack_rep<T>::size_type  size_type;

       // allocators/deallocators:

               ssk ();
               explicit ssk<T> (const csr<T>&);

       // accessors:

               size_type nrow () const;
               size_type ncol () const;
               size_type nnz  () const;

       // factorisation and solver:

               void solve(const vec<T>& b, vec<T>& x) const;
               vec<T> solve(const vec<T>& b) const;
               void factorize_ldlt();
               void factorize_lu();
       protected:
               const umfpack_rep<T>& data() const {
                       return smart_pointer<umfpack_rep<T> >::data();
               }
               umfpack_rep<T>& data() {
                       return smart_pointer<umfpack_rep<T> >::data();
               }
       };
       template <class T>
       ssk<T> ldlt (const csr<T>& m);

SEE ALSO

       csr(3), permutation(3)