---

matrixSD.h

Go to the documentation of this file.

#ifndef MATRIXSD_H
#define MATRIXSD_H
/*------------------------------------------------------------------------------
 * matrixSD.h   A simple, easy to use and efficient Matrix library.
 *              Definition and partial implementation of class MatrixSD.
 *              
 *              Copyright 1997,1998,1999,2000 Roland Krause
 * -----------------------------------------------------------------------------
 * RCS/CVS history of changes
 *  
 * $Log: matrixSD.h,v $
 * Revision 1.3  2000/11/09 18:41:31  rokrau
 * The first commit to the sourceforge repostory. Update of all
 * intermediate changes makes this the official repository from now on.
 *
 * Revision 1.3  2000/11/09 17:51:54  rokrau
 * Removed one of the redundant multiplication methods.
 *
 * Revision 1.2  2000/10/27 17:08:09  rokrau
 * some fixes for integer matrices
 *
 * Revision 1.1  2000/10/24 06:03:04  rokrau
 * Split header files, made Ref constructor private w/ some drastic consequences for
 * Ref operators. A lot of minor changes.
 *
 * -----------------------------------------------------------------------------
 * $Date: 2000/11/09 18:41:31 $
 * $Revision: 1.3 $
 * $Author: rokrau $
 * $State: Exp $
 * -----------------------------------------------------------------------------
 */
// standard includes
// project includes
#include    "matrix.h"
#define MAT_CS(M,NR,I,J) (M[((J)*(2*(NR)-(J)+1)/2)+(I)-(J)])
#define REF_CS(A,I,J) MAT_CS(((A).D)->m,((A).D)->nrow,I,J)
#define THIS_CS(I,J) REF_CS(*this,I,J)

#ifdef USE_NAMESPACE_LINAL
namespace LinAl {
#endif

class MatrixSD:public MatrixC<double>
{
public:


    explicit MatrixSD () : MatrixC<double>() {}
    explicit MatrixSD (const int nr, const double value=0.0) :
        MatrixC<double>(nr*(nr+1)/2,1,value) {D->nrow=D->ncol=nr;}
    MatrixSD (const MatrixSD& B) : MatrixC<double>(B) {} ;
    ~MatrixSD () {} ;
    MatrixSD& operator = (const double value)
        {this->MatrixC<double>::operator=(value); return *this;}



    void resize (const int nr, const double value=0.0) ;
    virtual int nr() const {return D->nrow;}
    virtual int nr(const int i) const {return D->nrow-i;}
    virtual int nc() const {return D->nrow;}
    virtual int nc(const int i) const {return i+1;}
    virtual Ref<double> operator () (const int i, const int j=0) {return MatrixC<double>::operator()(i,j);}
    virtual double operator () (const int i, const int j=0) const {assert(i>=j);return THIS_CS(i,j);}


    virtual void stream(ostream& s);


    MatrixSD transpose() const ;
    /*
     * Multiplication of two symmetric matrices destroys the symmetry. Therefore
     * it doesnt quite make sense. Instead multiplication of a symmetric
     * matrix with a full matrix is implemented as a member function of
     * the full matrix class.
     */
    void multiply(const MatrixSD& A, const MatrixSD& B,
                            const char TRANSA='N', const char TRANSB='N')
    {
        cout <<
        "Multiplication of two symmetric matrices destroys the symmetry. \n" <<
        "Therefore it doesnt quite make sense. Instead multiplication of \n" <<
        "a symmetric matrix with a full matrix is implemented as a member\n" <<
        "function of the full matrix class.\n" ;
    }
    void multiply(const double value);
    void multiply(const VectorD& x, VectorD& y, const double ALPHA=1.0, const double BETA=0.0) const;
    void CHdecompose() ;
    void CHsubstitute(MatrixC<double>& B) ;
    void CHsolve(MatrixC<double>& B) ;
    void CHinvert() ;
protected:
    virtual double* ref(const int i, const int j) const {assert(i>=j);return &THIS_CS(i,j);}
    virtual double read(const int i, const int j) const {assert(i>=j);return THIS_CS(i,j);}
    virtual void write(const int i, const int j, const double v) {assert(i>=j);D=D->get_own_copy();THIS_CS(i,j)=v;}
    virtual void add(const int i, const int j, const double v) {assert(i>=j); D=D->get_own_copy();THIS_CS(i,j)+=v;}
    virtual void sub(const int i, const int j, const double v) {assert(i>=j); D=D->get_own_copy();THIS_CS(i,j)-=v;}
    virtual void mul(const int i, const int j, const double v) {assert(i>=j); D=D->get_own_copy();THIS_CS(i,j)*=v;}
    virtual void div(const int i, const int j, const double v) {assert(i>=j); D=D->get_own_copy();THIS_CS(i,j)/=v;}
};
#ifdef USE_NAMESPACE_LINAL
} // namespace LinAl
#endif
#endif // #ifndef MATRIXSD_H

---