mpqc-html/html/abstract_8h_source.html

//

// abstract.h

//

// Copyright (C) 1996 Limit Point Systems, Inc.

//

// Author: Curtis Janssen <cljanss@limitpt.com>

// Maintainer: LPS

//

// This file is part of the SC Toolkit.

//

// The SC Toolkit is free software; you can redistribute it and/or modify

// it under the terms of the GNU Library General Public License as published by

// the Free Software Foundation; either version 2, or (at your option)

// any later version.

//

// The SC Toolkit is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU Library General Public License for more details.

//

// You should have received a copy of the GNU Library General Public License

// along with the SC Toolkit; see the file COPYING.LIB.  If not, write to

// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

//

// The U.S. Government is granted a limited license as per AL 91-7.

//


#ifndef _math_scmat_abstract_h

#define _math_scmat_abstract_h


#include <util/group/message.h>


#include <util/state/state.h>

#ifdef MPQC_NEW_FEATURES

#  include <util/misc/xml.h>

#endif

#include <math/scmat/dim.h>

#include <math/scmat/block.h>

#include <iostream>


namespace sc {


class SCMatrix;

class SymmSCMatrix;

class DiagSCMatrix;

class SCVector;


class SCElementOp;

class SCElementOp2;

class SCElementOp3;


class RefSCDimension;


class SCMatrixKit: public DescribedClass {

  protected:

    Ref<MessageGrp> grp_;


  public:

    SCMatrixKit();

    SCMatrixKit(const Ref<KeyVal>&);

    ~SCMatrixKit();


    // these members are defined in repl.cc

    static SCMatrixKit* default_matrixkit();

    static void set_default_matrixkit(const Ref<SCMatrixKit> &);


    Ref<MessageGrp> messagegrp() const;


    virtual SCMatrix* matrix(const RefSCDimension&,const RefSCDimension&) = 0;

    virtual SymmSCMatrix* symmmatrix(const RefSCDimension&) = 0;

    virtual DiagSCMatrix* diagmatrix(const RefSCDimension&) = 0;

    virtual SCVector* vector(const RefSCDimension&) = 0;


    SCMatrix* restore_matrix(StateIn&,

                             const RefSCDimension&,

                             const RefSCDimension&);

    SymmSCMatrix* restore_symmmatrix(StateIn&,

                                     const RefSCDimension&);

    DiagSCMatrix* restore_diagmatrix(StateIn&,

                                     const RefSCDimension&);

    SCVector* restore_vector(StateIn&,

                             const RefSCDimension&);

};


class SCVector: public DescribedClass {

  protected:

    RefSCDimension d;

    Ref<SCMatrixKit> kit_;

  public:

    SCVector(const RefSCDimension&, SCMatrixKit *);


    virtual void save(StateOut&);

    virtual void restore(StateIn&);


    Ref<SCMatrixKit> kit() const { return kit_; }


    // concrete functions (some can be overridden)

    virtual SCVector* copy();

    virtual SCVector* clone();


    virtual ~SCVector();

    int n() const { return d->n(); }

    virtual double maxabs() const;

    virtual void normalize();

    virtual void randomize();

    void assign(double val) { assign_val(val); }

    void assign(const double* v) { assign_p(v); }

    void assign(SCVector* v) { assign_v(v); }

    virtual void assign_val(double val);

    virtual void assign_p(const double* v);

    virtual void assign_v(SCVector *v);

    void convert(double* v) const { convert_p(v); }

    void convert(SCVector*v) { convert_v(v); }

    virtual void convert_p(double* v) const;

    virtual void convert_v(SCVector*);

    virtual void convert_accumulate(SCVector*);

    virtual void scale(double val);


    RefSCDimension dim() const { return d; }

    virtual void set_element(int i,double val) = 0;

    virtual void accumulate_element(int,double) = 0;

    virtual double get_element(int i) const = 0;


    void accumulate_product(SymmSCMatrix* m, SCVector* v)

        { accumulate_product_sv(m,v); }


    void accumulate_product(SCMatrix* m, SCVector* v)

        {  accumulate_product_rv(m,v); }

    virtual void accumulate_product_sv(SymmSCMatrix* m, SCVector* v);

    virtual void accumulate_product_rv(SCMatrix* m, SCVector* v) = 0;

    virtual void accumulate(const SCVector*v) = 0;

    virtual void accumulate(const SCMatrix*m) = 0;

    virtual double scalar_product(SCVector*) = 0;

    virtual void element_op(const Ref<SCElementOp>&) = 0;

    virtual void element_op(const Ref<SCElementOp2>&,

                            SCVector*) = 0;

    virtual void element_op(const Ref<SCElementOp3>&,

                            SCVector*,SCVector*) = 0;

    void print(std::ostream&o=ExEnv::out0()) const;

    void print(const char* title=0,std::ostream&out=ExEnv::out0(),int=10) const;

    virtual void vprint(const char*title=0,std::ostream&out=ExEnv::out0(),

                        int=10) const = 0;


    Ref<MessageGrp> messagegrp() const;


    virtual Ref<SCMatrixSubblockIter> local_blocks(

        SCMatrixSubblockIter::Access) = 0;

    virtual Ref<SCMatrixSubblockIter> all_blocks(SCMatrixSubblockIter::Access) = 0;

};


class SCMatrix: public DescribedClass

#ifdef MPQC_NEW_FEATURES

, public XMLWritable

#endif

{

  protected:

    RefSCDimension d1,d2;

    Ref<SCMatrixKit> kit_;

  public:

    enum Transform { NormalTransform = 0, TransposeTransform = 1 };


    // concrete functions (some can be overridden)

    SCMatrix(const RefSCDimension&, const RefSCDimension&, SCMatrixKit *);

    virtual ~SCMatrix();


    virtual void save(StateOut&);

    virtual void restore(StateIn&);


#ifdef MPQC_NEW_FEATURES

    virtual boost::property_tree::ptree& write_xml(boost::property_tree::ptree& parent, const XMLWriter& writer);

#endif


    Ref<SCMatrixKit> kit() const { return kit_; }


    int nrow() const { return d1->n(); }

    int ncol() const { return d2->n(); }

    virtual double maxabs() const;

    virtual void randomize();

    void assign(double val) { assign_val(val); }

    void assign(const double* m) { assign_p(m); }

    void assign(const double** m) { assign_pp(m); }

    void assign(SCMatrix* m) { assign_r(m); }

    virtual void assign_val(double val);

    virtual void assign_p(const double* m);

    virtual void assign_pp(const double** m);

    virtual void assign_r(SCMatrix* m);

    void convert(double*a) const { convert_p(a); }

    void convert(double**a) const { convert_pp(a); }

    void convert(SCMatrix*a) { convert_r(a); }

    virtual void convert_p(double*) const;

    virtual void convert_pp(double**) const;

    virtual void convert_r(SCMatrix*a);

    virtual void convert_accumulate(SCMatrix*);

    virtual void scale(double val);

    virtual void scale_diagonal(double val);

    virtual void shift_diagonal(double val);

    virtual void unit();

    virtual SCMatrix* copy();

    virtual SCMatrix* clone();


    // pure virtual functions

    RefSCDimension rowdim() const { return d1; }

    RefSCDimension coldim() const { return d2; }

    virtual double get_element(int,int) const = 0;

    virtual void set_element(int,int,double) = 0;

    virtual void accumulate_element(int,int,double) = 0;


    virtual SCMatrix * get_subblock(int br, int er, int bc, int ec) =0;


    virtual void assign_subblock(SCMatrix *m, int, int, int, int, int=0, int=0) =0;


    virtual void accumulate_subblock(SCMatrix *m, int br, int er, int bc, int ec,

                                     int source_br = 0, int source_bc = 0) =0;


    virtual SCVector * get_row(int i) =0;

    virtual SCVector * get_column(int i) =0;


    virtual void assign_row(SCVector *v, int i) =0;

    virtual void assign_column(SCVector *v, int i) =0;


    virtual void accumulate_row(SCVector *v, int i) =0;

    virtual void accumulate_column(SCVector *v, int i) =0;


    virtual void accumulate(const SCMatrix* m) = 0;

    virtual void accumulate(const SymmSCMatrix* m) = 0;

    virtual void accumulate(const DiagSCMatrix* m) = 0;

    virtual void accumulate(const SCVector*) = 0;

    virtual void accumulate_outer_product(SCVector*,SCVector*) = 0;

    void accumulate_product(SCMatrix*m1,SCMatrix*m2)

        { accumulate_product_rr(m1,m2); }

    void accumulate_product(SCMatrix*m1,SymmSCMatrix*m2)

        { accumulate_product_rs(m1,m2); }

    void accumulate_product(SCMatrix*m1,DiagSCMatrix*m2)

        { accumulate_product_rd(m1,m2); }

    void accumulate_product(SymmSCMatrix*m1,SCMatrix*m2)

        { accumulate_product_sr(m1,m2); }

    void accumulate_product(DiagSCMatrix*m1,SCMatrix*m2)

        { accumulate_product_dr(m1,m2); }

    void accumulate_product(SymmSCMatrix*m1,SymmSCMatrix*m2)

        { accumulate_product_ss(m1,m2); }

    void accumulate_product(SymmSCMatrix*m1,DiagSCMatrix*m2)

        { accumulate_product_sd(m1,m2); }

    void accumulate_product(DiagSCMatrix*m1,SymmSCMatrix*m2)

        { accumulate_product_ds(m1,m2); }

    virtual void accumulate_product_rr(SCMatrix*,SCMatrix*) = 0;

    virtual void accumulate_product_rs(SCMatrix*,SymmSCMatrix*);

    virtual void accumulate_product_rd(SCMatrix*,DiagSCMatrix*);

    virtual void accumulate_product_sr(SymmSCMatrix*,SCMatrix*);

    virtual void accumulate_product_dr(DiagSCMatrix*,SCMatrix*);

    virtual void accumulate_product_ss(SymmSCMatrix*,SymmSCMatrix*);

    virtual void accumulate_product_sd(SymmSCMatrix*,DiagSCMatrix*);

    virtual void accumulate_product_ds(DiagSCMatrix*,SymmSCMatrix*);

    virtual void transpose_this() = 0;

    virtual double trace() =0;

    virtual double invert_this() = 0;

    virtual double determ_this() = 0;


    virtual void svd_this(SCMatrix *U, DiagSCMatrix *sigma, SCMatrix *V);

    virtual double solve_this(SCVector*) = 0;

    virtual void gen_invert_this(double condition_number_threshold = 1e8);


    virtual void schmidt_orthog(SymmSCMatrix*, int n) =0;


    virtual int schmidt_orthog_tol(SymmSCMatrix*, double tol, double*res=0)=0;


    virtual void element_op(const Ref<SCElementOp>&) = 0;

    virtual void element_op(const Ref<SCElementOp2>&,

                            SCMatrix*) = 0;

    virtual void element_op(const Ref<SCElementOp3>&,

                            SCMatrix*,SCMatrix*) = 0;

    void print(std::ostream&o=ExEnv::out0()) const;

    void print(const char* title=0,std::ostream& out=ExEnv::out0(),

               int =10) const;

    virtual void vprint(const char*title=0,

                        std::ostream&out=ExEnv::out0(),int =10) const = 0;


    Ref<MessageGrp> messagegrp() const;


    virtual Ref<SCMatrixSubblockIter> local_blocks(

        SCMatrixSubblockIter::Access) = 0;

    virtual Ref<SCMatrixSubblockIter> all_blocks(

        SCMatrixSubblockIter::Access) = 0;

};


class SymmSCMatrix: public DescribedClass

#ifdef MPQC_NEW_FEATURES

, public XMLWritable

#endif

{

  protected:

    RefSCDimension d;

    Ref<SCMatrixKit> kit_;

  public:

    SymmSCMatrix(const RefSCDimension&, SCMatrixKit *);

    ~SymmSCMatrix();


    Ref<SCMatrixKit> kit() const { return kit_; }


    virtual void save(StateOut&);

    virtual void restore(StateIn&);


#ifdef MPQC_NEW_FEATURES

    virtual boost::property_tree::ptree& write_xml(boost::property_tree::ptree& parent, const XMLWriter& writer);

#endif


    virtual double maxabs() const;

    virtual void randomize();

    void assign(double val) { assign_val(val); }

    void assign(const double* m) { assign_p(m); }

    void assign(const double** m) { assign_pp(m); }

    void assign(SymmSCMatrix* m) { assign_s(m); }

    virtual void assign_val(double val);

    virtual void assign_p(const double* m);

    virtual void assign_pp(const double** m);

    virtual void assign_s(SymmSCMatrix* m);

    void convert(double*a) const { convert_p(a); }

    void convert(double**a) const { convert_pp(a); }

    void convert(SymmSCMatrix*a) { convert_s(a); }

    virtual void convert_p(double*) const;

    virtual void convert_pp(double**) const;

    virtual void convert_s(SymmSCMatrix*);

    virtual void convert_accumulate(SymmSCMatrix*);

    virtual void scale(double);

    virtual void scale_diagonal(double);

    virtual void shift_diagonal(double);

    virtual void unit();

    int n() const { return d->n(); }

    virtual SymmSCMatrix* copy();

    virtual SymmSCMatrix* clone();


    // pure virtual functions

    RefSCDimension dim() const { return d; }

    virtual double get_element(int,int) const = 0;

    virtual void set_element(int,int,double) = 0;

    virtual void accumulate_element(int,int,double) = 0;


    virtual SCMatrix * get_subblock(int br, int er, int bc, int ec) =0;

    virtual SymmSCMatrix * get_subblock(int br, int er) =0;


    virtual void assign_subblock(SCMatrix *m, int, int, int, int) =0;

    virtual void assign_subblock(SymmSCMatrix *m, int, int) =0;


    virtual void accumulate_subblock(SCMatrix *m, int, int, int, int) =0;

    virtual void accumulate_subblock(SymmSCMatrix *m, int, int) =0;


    virtual SCVector * get_row(int i) =0;


    virtual void assign_row(SCVector *v, int i) =0;


    virtual void accumulate_row(SCVector *v, int i) =0;


    virtual void diagonalize(DiagSCMatrix*d,SCMatrix*m) = 0;

    virtual void eigensystem(SymmSCMatrix*s,DiagSCMatrix*d,SCMatrix*m) = 0;

    virtual void accumulate(const SymmSCMatrix* m) = 0;

    virtual void accumulate_symmetric_sum(SCMatrix* a) = 0;

    virtual void accumulate_symmetric_product(SCMatrix* a);

    virtual void accumulate_transform(SCMatrix*,SymmSCMatrix*,

                            SCMatrix::Transform = SCMatrix::NormalTransform);

    virtual void accumulate_transform(SCMatrix*,DiagSCMatrix*,

                            SCMatrix::Transform = SCMatrix::NormalTransform);

    virtual void accumulate_transform(SymmSCMatrix*,SymmSCMatrix*);

    virtual void accumulate_symmetric_outer_product(SCVector*);

    virtual double scalar_product(SCVector* v);

    virtual double trace() = 0;

    virtual double invert_this() = 0;

    virtual double determ_this() = 0;


    virtual double solve_this(SCVector*) = 0;

    virtual void gen_invert_this(double condition_number_threshold = 1e8) = 0;


    virtual void element_op(const Ref<SCElementOp>&) = 0;

    virtual void element_op(const Ref<SCElementOp2>&,

                            SymmSCMatrix*) = 0;

    virtual void element_op(const Ref<SCElementOp3>&,

                            SymmSCMatrix*,SymmSCMatrix*) = 0;


    void print(std::ostream&o=ExEnv::out0()) const;

    void print(const char* title=0,std::ostream& out=ExEnv::out0(),

               int =10) const;

    virtual void vprint(const char* title=0,

                        std::ostream& out=ExEnv::out0(), int =10) const;


    Ref<MessageGrp> messagegrp() const;


    virtual Ref<SCMatrixSubblockIter> local_blocks(

        SCMatrixSubblockIter::Access) = 0;

    virtual Ref<SCMatrixSubblockIter> all_blocks(

        SCMatrixSubblockIter::Access) = 0;

};


class DiagSCMatrix: public DescribedClass

#ifdef MPQC_NEW_FEATURES

, public XMLWritable

#endif

{

  protected:

    RefSCDimension d;

    Ref<SCMatrixKit> kit_;

  public:

    DiagSCMatrix(const RefSCDimension&, SCMatrixKit *);

    ~DiagSCMatrix();


    Ref<SCMatrixKit> kit() const { return kit_; }


    virtual void save(StateOut&);

    virtual void restore(StateIn&);


#ifdef MPQC_NEW_FEATURES

    virtual boost::property_tree::ptree& write_xml(boost::property_tree::ptree& parent, const XMLWriter& writer);

#endif


    virtual double maxabs() const;

    virtual void randomize();

    void assign(double val) { assign_val(val); }

    void assign(const double*p) { assign_p(p); }

    void assign(DiagSCMatrix*d_a) { assign_d(d_a); }

    virtual void assign_val(double val);

    virtual void assign_p(const double*);

    virtual void assign_d(DiagSCMatrix*);

    void convert(double*a) const { convert_p(a); }

    void convert(DiagSCMatrix*a) { convert_d(a); }

    virtual void convert_p(double*) const;

    virtual void convert_d(DiagSCMatrix*);

    virtual void convert_accumulate(DiagSCMatrix*);

    virtual void scale(double);

    int n() const { return d->n(); }

    virtual DiagSCMatrix* copy();

    virtual DiagSCMatrix* clone();


    // pure virtual functions

    RefSCDimension dim() const { return d; }

    virtual double get_element(int) const = 0;

    virtual void set_element(int,double) = 0;

    virtual void accumulate_element(int,double) = 0;

    virtual void accumulate(const DiagSCMatrix* m) = 0;

    virtual double trace() = 0;

    virtual double determ_this() = 0;

    virtual double invert_this() = 0;

    virtual void gen_invert_this(double condition_number_threshold = 1e8) = 0;

    virtual void element_op(const Ref<SCElementOp>&) = 0;

    virtual void element_op(const Ref<SCElementOp2>&,

                            DiagSCMatrix*) = 0;

    virtual void element_op(const Ref<SCElementOp3>&,

                            DiagSCMatrix*,DiagSCMatrix*) = 0;

    void print(std::ostream&o=ExEnv::out0()) const;

    void print(const char* title=0,

               std::ostream& out=ExEnv::out0(), int =10) const;

    virtual void vprint(const char* title=0,

                        std::ostream& out=ExEnv::out0(), int =10) const;


    Ref<MessageGrp> messagegrp() const;


    virtual Ref<SCMatrixSubblockIter> local_blocks(

        SCMatrixSubblockIter::Access) = 0;

    virtual Ref<SCMatrixSubblockIter> all_blocks(

        SCMatrixSubblockIter::Access) = 0;

};


}


#endif


// Local Variables:

// mode: c++

// c-file-style: "CLJ"

// End:

sc::DescribedClass
Classes which need runtime information about themselves and their relationship to other classes can v...
Definition class.h:233

sc::DiagSCMatrix
The SymmSCMatrix class is the abstract base class for diagonal double valued matrices.
Definition abstract.h:555

sc::DiagSCMatrix::all_blocks
virtual Ref< SCMatrixSubblockIter > all_blocks(SCMatrixSubblockIter::Access)=0
Returns iterators for the all blocks used in this matrix.

sc::DiagSCMatrix::randomize
virtual void randomize()
Assign each element to a random number between -1 and 1.

sc::DiagSCMatrix::invert_this
virtual double invert_this()=0
Invert this.

sc::DiagSCMatrix::kit
Ref< SCMatrixKit > kit() const
Return the SCMatrixKit used to create this object.
Definition abstract.h:564

sc::DiagSCMatrix::trace
virtual double trace()=0
Return the trace.

sc::DiagSCMatrix::dim
RefSCDimension dim() const
Return the dimension.
Definition abstract.h:606

sc::DiagSCMatrix::convert
void convert(double *a) const
Like the assign member, but this writes values to the argument.
Definition abstract.h:590

sc::DiagSCMatrix::scale
virtual void scale(double)
Multiply all elements by val.

sc::DiagSCMatrix::print
void print(std::ostream &o=ExEnv::out0()) const
Print out the matrix.

sc::DiagSCMatrix::maxabs
virtual double maxabs() const
Return the maximum absolute value element of this vector.

sc::DiagSCMatrix::assign
void assign(DiagSCMatrix *d_a)
Make this have the same elements as m.
Definition abstract.h:584

sc::DiagSCMatrix::assign
void assign(double val)
Set all elements to val.
Definition abstract.h:579

sc::DiagSCMatrix::messagegrp
Ref< MessageGrp > messagegrp() const
Returns the message group used by the matrix kit.

sc::DiagSCMatrix::clone
virtual DiagSCMatrix * clone()
Return a matrix with the same dimension but uninitialized memory.

sc::DiagSCMatrix::get_element
virtual double get_element(int) const =0
Return or modify an element.

sc::DiagSCMatrix::copy
virtual DiagSCMatrix * copy()
Return a matrix with the same dimension and same elements.

sc::DiagSCMatrix::assign
void assign(const double *p)
Assign element i, i to m[i].
Definition abstract.h:581

sc::DiagSCMatrix::gen_invert_this
virtual void gen_invert_this(double condition_number_threshold=1e8)=0
Return the generalized inverse of this using SVD decomposition.

sc::DiagSCMatrix::local_blocks
virtual Ref< SCMatrixSubblockIter > local_blocks(SCMatrixSubblockIter::Access)=0
Returns iterators for the local (rapidly accessible) blocks used in this matrix.

sc::DiagSCMatrix::save
virtual void save(StateOut &)
Save and restore this in an implementation independent way.

sc::DiagSCMatrix::accumulate
virtual void accumulate(const DiagSCMatrix *m)=0
Sum m into this.

sc::DiagSCMatrix::determ_this
virtual double determ_this()=0
Return the determinant of this. this is overwritten.

sc::DiagSCMatrix::element_op
virtual void element_op(const Ref< SCElementOp > &)=0
Perform the element operation op on each element of this.

sc::DiagSCMatrix::assign_val
virtual void assign_val(double val)
Overridden to implement the assign members.

sc::DiagSCMatrix::n
int n() const
Return the dimension.
Definition abstract.h:598

sc::ExEnv::out0
static std::ostream & out0()
Return an ostream that writes from node 0.

sc::RefSCDimension
The RefSCDimension class is a smart pointer to an SCDimension specialization.
Definition dim.h:152

sc::Ref
A template class that maintains references counts.
Definition ref.h:361

sc::SCMatrixKit
The SCMatrixKit abstract class acts as a factory for producing matrices.
Definition abstract.h:57

sc::SCMatrixKit::set_default_matrixkit
static void set_default_matrixkit(const Ref< SCMatrixKit > &)
change the default matrix kit

sc::SCMatrixKit::default_matrixkit
static SCMatrixKit * default_matrixkit()
This returns the default matrix kit.

sc::SCMatrixKit::restore_matrix
SCMatrix * restore_matrix(StateIn &, const RefSCDimension &, const RefSCDimension &)
Given the dimensions and a StateIn object, restore matrices or vectors.

sc::SCMatrixKit::matrix
virtual SCMatrix * matrix(const RefSCDimension &, const RefSCDimension &)=0
Given the dimensions, create matrices or vectors.

sc::SCMatrix
The SCMatrix class is the abstract base class for general double valued n by m matrices.
Definition abstract.h:199

sc::SCMatrix::invert_this
virtual double invert_this()=0
Invert this.

sc::SCMatrix::randomize
virtual void randomize()
Assign each element to a random number between -1 and 1.

sc::SCMatrix::messagegrp
Ref< MessageGrp > messagegrp() const
Returns the message group used by the matrix kit.

sc::SCMatrix::accumulate_subblock
virtual void accumulate_subblock(SCMatrix *m, int br, int er, int bc, int ec, int source_br=0, int source_bc=0)=0
Sum m into a subblock of this.

sc::SCMatrix::convert
void convert(double *a) const
Like the assign members, but these write values to the arguments.
Definition abstract.h:245

sc::SCMatrix::accumulate_outer_product
virtual void accumulate_outer_product(SCVector *, SCVector *)=0
Sum into this the products of various vectors or matrices.

sc::SCMatrix::rowdim
RefSCDimension rowdim() const
Return the row or column dimension.
Definition abstract.h:267

sc::SCMatrix::Transform
Transform
types of matrix transforms. Only real-valued matrices are assumed.
Definition abstract.h:205

sc::SCMatrix::schmidt_orthog_tol
virtual int schmidt_orthog_tol(SymmSCMatrix *, double tol, double *res=0)=0
Schmidt orthogonalize this.

sc::SCMatrix::schmidt_orthog
virtual void schmidt_orthog(SymmSCMatrix *, int n)=0
Schmidt orthogonalize this.

sc::SCMatrix::local_blocks
virtual Ref< SCMatrixSubblockIter > local_blocks(SCMatrixSubblockIter::Access)=0
Returns iterators for the local (rapidly accessible) blocks used in this matrix.

sc::SCMatrix::determ_this
virtual double determ_this()=0
Return the determinant of this. this is overwritten.

sc::SCMatrix::assign_subblock
virtual void assign_subblock(SCMatrix *m, int, int, int, int, int=0, int=0)=0
Assign m to a subblock of this.

sc::SCMatrix::scale_diagonal
virtual void scale_diagonal(double val)
Scale the diagonal elements by val.

sc::SCMatrix::copy
virtual SCMatrix * copy()
Return a matrix with the same dimension and same elements.

sc::SCMatrix::get_subblock
virtual SCMatrix * get_subblock(int br, int er, int bc, int ec)=0
Return a subblock of this.

sc::SCMatrix::element_op
virtual void element_op(const Ref< SCElementOp > &)=0
Perform the element operation op on each element of this.

sc::SCMatrix::assign_val
virtual void assign_val(double val)
Overridden to implement to assign members.

sc::SCMatrix::assign
void assign(const double *m)
Assign element i, j to m[ir*nrow()+j].
Definition abstract.h:233

sc::SCMatrix::svd_this
virtual void svd_this(SCMatrix *U, DiagSCMatrix *sigma, SCMatrix *V)
Compute the singular value decomposition for this, possibly destroying this.

sc::SCMatrix::clone
virtual SCMatrix * clone()
Return a matrix with the same dimension but uninitialized memory.

sc::SCMatrix::kit
Ref< SCMatrixKit > kit() const
Return the SCMatrixKit used to create this object.
Definition abstract.h:220

sc::SCMatrix::assign
void assign(double val)
Set all elements to val.
Definition abstract.h:231

sc::SCMatrix::accumulate_row
virtual void accumulate_row(SCVector *v, int i)=0
Sum v to a row or column of this.

sc::SCMatrix::all_blocks
virtual Ref< SCMatrixSubblockIter > all_blocks(SCMatrixSubblockIter::Access)=0
Returns iterators for the all blocks used in this matrix.

sc::SCMatrix::unit
virtual void unit()
Make this equal to the unit matrix.

sc::SCMatrix::get_element
virtual double get_element(int, int) const =0
Return or modify an element.

sc::SCMatrix::assign
void assign(const double **m)
Assign element i, j to m[i][j].
Definition abstract.h:235

sc::SCMatrix::maxabs
virtual double maxabs() const
Return the maximum absolute value element.

sc::SCMatrix::get_row
virtual SCVector * get_row(int i)=0
Return a row or column of this.

sc::SCMatrix::trace
virtual double trace()=0
Return the trace.

sc::SCMatrix::assign
void assign(SCMatrix *m)
Make this have the same elements as m. The dimensions must match.
Definition abstract.h:237

sc::SCMatrix::nrow
int nrow() const
Return the number of rows.
Definition abstract.h:223

sc::SCMatrix::print
void print(std::ostream &o=ExEnv::out0()) const
Print out the matrix.

sc::SCMatrix::shift_diagonal
virtual void shift_diagonal(double val)
Shift the diagonal elements by val.

sc::SCMatrix::ncol
int ncol() const
Return the number of columns.
Definition abstract.h:225

sc::SCMatrix::transpose_this
virtual void transpose_this()=0
Transpose this.

sc::SCMatrix::gen_invert_this
virtual void gen_invert_this(double condition_number_threshold=1e8)
Return the generalized inverse of this using SVD decomposition.

sc::SCMatrix::accumulate
virtual void accumulate(const SCMatrix *m)=0
Sum m into this.

sc::SCMatrix::scale
virtual void scale(double val)
Multiply all elements by val.

sc::SCMatrix::save
virtual void save(StateOut &)
Save and restore this in an implementation independent way.

sc::SCMatrix::assign_row
virtual void assign_row(SCVector *v, int i)=0
Assign v to a row or column of this.

sc::SCVector
The SCVector class is the abstract base class for double valued vectors.
Definition abstract.h:97

sc::SCVector::local_blocks
virtual Ref< SCMatrixSubblockIter > local_blocks(SCMatrixSubblockIter::Access)=0
Returns iterators for the local (rapidly accessible) blocks used in this vector.

sc::SCVector::all_blocks
virtual Ref< SCMatrixSubblockIter > all_blocks(SCMatrixSubblockIter::Access)=0
Returns iterators for the all blocks used in this vector.

sc::SCVector::randomize
virtual void randomize()
Assign each element to a random number between -1 and 1.

sc::SCVector::accumulate_element
virtual void accumulate_element(int, double)=0
Add val to element i.

sc::SCVector::normalize
virtual void normalize()
Normalize this.

sc::SCVector::maxabs
virtual double maxabs() const
Return the maximum absolute value element of this vector.

sc::SCVector::dim
RefSCDimension dim() const
Return the RefSCDimension corresponding to this vector.
Definition abstract.h:147

sc::SCVector::scale
virtual void scale(double val)
Multiply each element by val.

sc::SCVector::accumulate
virtual void accumulate(const SCVector *v)=0
Sum v into this.

sc::SCVector::copy
virtual SCVector * copy()
Return a vector with the same dimension and same elements.

sc::SCVector::clone
virtual SCVector * clone()
Return a vector with the same dimension but uninitialized memory.

sc::SCVector::assign_val
virtual void assign_val(double val)
Overridden to implement the assign functions.

sc::SCVector::get_element
virtual double get_element(int i) const =0
Return the value of element i.

sc::SCVector::assign
void assign(const double *v)
Assign element i to v[i] for all i.
Definition abstract.h:129

sc::SCVector::accumulate
virtual void accumulate(const SCMatrix *m)=0
Sum m into this. One of m's dimensions must be 1.

sc::SCVector::print
void print(std::ostream &o=ExEnv::out0()) const
Print out the vector.

sc::SCVector::kit
Ref< SCMatrixKit > kit() const
Return the SCMatrixKit used to create this object.
Definition abstract.h:109

sc::SCVector::save
virtual void save(StateOut &)
Save and restore this in an implementation independent way.

sc::SCVector::set_element
virtual void set_element(int i, double val)=0
Set element i to val.

sc::SCVector::element_op
virtual void element_op(const Ref< SCElementOp > &)=0
Perform the element operation op on each element of this.

sc::SCVector::scalar_product
virtual double scalar_product(SCVector *)=0
Return the dot product.

sc::SCVector::accumulate_product
void accumulate_product(SymmSCMatrix *m, SCVector *v)
Sum the result of m times v into this.
Definition abstract.h:155

sc::SCVector::messagegrp
Ref< MessageGrp > messagegrp() const
Returns the message group used by the matrix kit.

sc::SCVector::n
int n() const
Return the length of the vector.
Definition abstract.h:119

sc::SCVector::assign
void assign(SCVector *v)
Make this have the same elements as v.
Definition abstract.h:132

sc::SCVector::assign
void assign(double val)
Assign all elements of this to val.
Definition abstract.h:127

sc::SCVector::convert
void convert(double *v) const
Assign v[i] to element i for all i.
Definition abstract.h:138

sc::StateIn
Restores fundamental and user-defined types from images created with StateOut.
Definition statein.h:79

sc::StateOut
Serializes fundamental and user-defined types.
Definition stateout.h:71

sc::SymmSCMatrix
The SymmSCMatrix class is the abstract base class for symmetric double valued matrices.
Definition abstract.h:389

sc::SymmSCMatrix::unit
virtual void unit()
Make this equal to the unit matrix.

sc::SymmSCMatrix::determ_this
virtual double determ_this()=0
Return the determinant of this. this is overwritten.

sc::SymmSCMatrix::scale
virtual void scale(double)
Multiply all elements by val.

sc::SymmSCMatrix::accumulate_subblock
virtual void accumulate_subblock(SCMatrix *m, int, int, int, int)=0
Sum m into a subblock of this.

sc::SymmSCMatrix::assign
void assign(SymmSCMatrix *m)
Make this have the same elements as m.
Definition abstract.h:420

sc::SymmSCMatrix::n
int n() const
Return the dimension.
Definition abstract.h:443

sc::SymmSCMatrix::randomize
virtual void randomize()
Assign each element to a random number between -1 and 1.

sc::SymmSCMatrix::assign
void assign(double val)
Set all elements to val.
Definition abstract.h:413

sc::SymmSCMatrix::maxabs
virtual double maxabs() const
Return the maximum absolute value element of this vector.

sc::SymmSCMatrix::local_blocks
virtual Ref< SCMatrixSubblockIter > local_blocks(SCMatrixSubblockIter::Access)=0
Returns iterators for the local (rapidly accessible) blocks used in this matrix.

sc::SymmSCMatrix::eigensystem
virtual void eigensystem(SymmSCMatrix *s, DiagSCMatrix *d, SCMatrix *m)=0
Solve generalized eigensystem for this with metric s, placing the eigenvalues in d and the eigenvecto...

sc::SymmSCMatrix::print
void print(std::ostream &o=ExEnv::out0()) const
Print out the matrix.

sc::SymmSCMatrix::accumulate_symmetric_sum
virtual void accumulate_symmetric_sum(SCMatrix *a)=0
Sum into a + a.t()

sc::SymmSCMatrix::element_op
virtual void element_op(const Ref< SCElementOp > &)=0
only applied to the unique elements of this.

sc::SymmSCMatrix::scale_diagonal
virtual void scale_diagonal(double)
Scale the diagonal elements by val.

sc::SymmSCMatrix::accumulate
virtual void accumulate(const SymmSCMatrix *m)=0
Sum m into this.

sc::SymmSCMatrix::assign_val
virtual void assign_val(double val)
Overridden to implement the assign functions.

sc::SymmSCMatrix::assign
void assign(const double *m)
Assign element i, j to m[i*(i+1)/2+j].
Definition abstract.h:415

sc::SymmSCMatrix::all_blocks
virtual Ref< SCMatrixSubblockIter > all_blocks(SCMatrixSubblockIter::Access)=0
Returns iterators for the all blocks used in this matrix.

sc::SymmSCMatrix::accumulate_row
virtual void accumulate_row(SCVector *v, int i)=0
Sum v to a row of this.

sc::SymmSCMatrix::get_row
virtual SCVector * get_row(int i)=0
Return a row of this.

sc::SymmSCMatrix::convert
void convert(double *a) const
Like the assign members, but these write values to the arguments.
Definition abstract.h:427

sc::SymmSCMatrix::clone
virtual SymmSCMatrix * clone()
Return a matrix with the same dimension but uninitialized memory.

sc::SymmSCMatrix::kit
Ref< SCMatrixKit > kit() const
Return the SCMatrixKit object that created this object.
Definition abstract.h:398

sc::SymmSCMatrix::diagonalize
virtual void diagonalize(DiagSCMatrix *d, SCMatrix *m)=0
Diagonalize this, placing the eigenvalues in d and the eigenvectors in m.

sc::SymmSCMatrix::assign_subblock
virtual void assign_subblock(SCMatrix *m, int, int, int, int)=0
Assign m to a subblock of this.

sc::SymmSCMatrix::scalar_product
virtual double scalar_product(SCVector *v)
Return the scalar obtained by multiplying this on the left and right by v.

sc::SymmSCMatrix::accumulate_symmetric_product
virtual void accumulate_symmetric_product(SCMatrix *a)
Sum into this a * a.t()

sc::SymmSCMatrix::dim
RefSCDimension dim() const
Return the dimension.
Definition abstract.h:451

sc::SymmSCMatrix::save
virtual void save(StateOut &)
Save and restore this in an implementation independent way.

sc::SymmSCMatrix::messagegrp
Ref< MessageGrp > messagegrp() const
Returns the message group used by the matrix kit.

sc::SymmSCMatrix::invert_this
virtual double invert_this()=0
Invert this.

sc::SymmSCMatrix::get_subblock
virtual SCMatrix * get_subblock(int br, int er, int bc, int ec)=0
Return a subblock of this.

sc::SymmSCMatrix::copy
virtual SymmSCMatrix * copy()
Return a matrix with the same dimension and same elements.

sc::SymmSCMatrix::trace
virtual double trace()=0
Return the trace.

sc::SymmSCMatrix::gen_invert_this
virtual void gen_invert_this(double condition_number_threshold=1e8)=0
Return the generalized inverse of this using SVD decomposition.

sc::SymmSCMatrix::get_element
virtual double get_element(int, int) const =0
Return or modify an element.

sc::SymmSCMatrix::assign
void assign(const double **m)
Assign element i, j to m[i][j].
Definition abstract.h:417

sc::SymmSCMatrix::assign_row
virtual void assign_row(SCVector *v, int i)=0
Assign v to a row of this.

sc::SymmSCMatrix::shift_diagonal
virtual void shift_diagonal(double)
Shift the diagonal elements by val.

sc::XMLWritable
Definition xml.h:44

sc::XMLWriter
Definition xmlwriter.h:223

sc
Contains all MPQC code up to version 3.
Definition mpqcin.h:14