---

LSquares.H

Go to the documentation of this file.

/* _______              __
  / ___/ /  ___  __ _  / /  ___
 / /__/ _ \/ _ \/  ' \/ _ \/ _ \
 \___/_//_/\___/_/_/_/_.__/\___/ 
*/
//
// This software is copyright (C) by the Lawrence Berkeley
// National Laboratory.  Permission is granted to reproduce
// this software for non-commercial purposes provided that
// this notice is left intact.
// 
// It is acknowledged that the U.S. Government has rights to
// this software under Contract DE-AC03-765F00098 between
// the U.S.  Department of Energy and the University of
// California.
//
// This software is provided as a professional and academic
// contribution for joint exchange. Thus it is experimental,
// is provided ``as is'', with no warranties of any kind
// whatsoever, no support, no promise of updates, or printed
// documentation. By using this software, you acknowledge
// that the Lawrence Berkeley National Laboratory and
// Regents of the University of California shall have no
// liability with respect to the infringement of other
// copyrights by any part of this software.
#ifndef _LSquares_H_
#define _LSquares_H_

class LSquares
{
public: 
  void LeastSquares(Real** A,
                    Vector<Real>&x,
                    const Vector<Real>&rhs);

  int gaussElim(Real**A,
                Vector<Real>& rhs);

  void swapRows(Real** A,
                const int& rowi,
                const int& rowj, 
                const int&numberOfCols);

  void swapRows(Vector<Real>& rhs, 
                const int& currRow,
                const int& pivot);

  int findPivot(Real** A,
                const int& currCol,
                const int& currRow, 
                const int& numRows,
                int& pivot);

  void addRows(Vector<Real>& rhs,
               const int& rowi,
               const Real& alpha,
               const int& rowj);
               
  void addRows(Real** A,
               const int& rowi,
               const Real& alpha,
               const int& rowj, 
               const int& numberOfCols);

  void timesBeta(Vector<Real>&rhs,
                 const int& currRow,
                 const Real& Beta);

  void timesBeta(Real** A,
                 const int& rowi,
                 const Real& Beta, 
                 const int& numberOfcols);

  void transpose(Real** a_A,
                 Real ** a_Atrans, 
                 const int& a_numRows, 
                 const int& a_numCols);

  void matMul(Real** a_A,
              Real** a_B,
              Real** a_C,
              const int& a_numRowsA, 
              const int& a_numColsA,
              const int& a_numColsB);
  
  void backSolve(Real** a_A, 
                 const Vector<Real>& a_rhs, 
                 const int& a_numArows,
                 Vector<Real>& a_x);

  void AtimesX(Real** A,
               const Vector<Real>&x,
               const int& numRowsA,
               Vector<Real>& Ax);

  void allocArray(const int& rows,
                  const int& cols, 
                  Real**& A);

  void freeArray(const int& rows,
                 const int& cols, 
                 Real**& A);

  void output(const int& rows,
              const int& cols, 
              Real**& A,
              char* name);
};

#endif

---