332 lines
10 KiB
C++
332 lines
10 KiB
C++
/* -------------------------------------------------------------
|
|
|
|
This file is a component of SDPA
|
|
Copyright (C) 2004-2013 SDPA Project
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
------------------------------------------------------------- */
|
|
|
|
#ifndef __sdpa_linear_h__
|
|
#define __sdpa_linear_h__
|
|
|
|
#include "sdpa_struct.h"
|
|
|
|
namespace sdpa {
|
|
|
|
class Lal
|
|
{
|
|
public:
|
|
// calculate the minimum eigenvalue of lMat*xMat*(lMat^T)
|
|
// by Lanczos metnod
|
|
static double getMinEigen(DenseMatrix& lMat, DenseMatrix& xMat,
|
|
DenseMatrix& Q,
|
|
Vector& out, Vector& b, Vector& r,
|
|
Vector& q, Vector& qold,
|
|
Vector& w, Vector& tmp,
|
|
Vector& diagVec, Vector& diagVec2,
|
|
Vector& workVec, char charTranspose='N');
|
|
|
|
// caluculate all eigenvalues of aMat by QR method
|
|
static double getMinEigenValue(DenseMatrix& aMat,
|
|
Vector& eigenVec,
|
|
Vector& workVec);
|
|
// calculate Lanzcos for cholmod_sparse
|
|
static double getMinEigenValue(CholmodMatrix& cholmodMatrix);
|
|
|
|
static double getOneNorm(Vector& b);
|
|
static double getOneNorm(SparseMatrix& C);
|
|
static double getOneNorm(SparseLinearSpace& C);
|
|
static double getOneNorm(CompMatrix& C);
|
|
static double getOneNorm(CompSpace& C);
|
|
|
|
static double getTwoNorm(Vector& b);
|
|
static double getTwoNorm(DenseMatrix& X);
|
|
static double getTwoNorm(DenseLinearSpace& X);
|
|
|
|
|
|
static bool getInnerProduct(double& ret,
|
|
Vector& aVec, Vector& bVec);
|
|
static bool getInnerProduct(double& ret,
|
|
BlockVector& aVec,
|
|
BlockVector& bVec);
|
|
static bool getInnerProduct(double& ret,
|
|
DenseMatrix& aMat,
|
|
DenseMatrix& bMat);
|
|
static bool getInnerProduct(double& ret,
|
|
SparseMatrix& aMat,
|
|
DenseMatrix& bMat);
|
|
|
|
static bool getCholesky(DenseMatrix& retMat, DenseMatrix& aMat);
|
|
|
|
// nakata 2004/12/01
|
|
// diagonal part of Cholesky matrix is set these inverse.
|
|
static bool getCholesky(SparseMatrix& aMat, int* diagonalIndex);
|
|
|
|
static bool getInvLowTriangularMatrix(DenseMatrix& retMat,
|
|
DenseMatrix& aMat);
|
|
static bool getSymmetrize(DenseMatrix& aMat);
|
|
|
|
static bool getTranspose(DenseMatrix& retMat,
|
|
DenseMatrix& aMat);
|
|
|
|
static int rdpotf2_(char*uplo, int *n, double *a, int *lda, int *info);
|
|
static int rdpotrf_(char *uplo, int *n, double *a, int *lda, int *info);
|
|
static bool choleskyFactorWithAdjust(DenseMatrix& aMat);
|
|
|
|
static bool solveSystems(Vector& xVec,
|
|
DenseMatrix& aMat, Vector& bVec);
|
|
// solve aMat * xVec = bVec
|
|
// aMat must be Cholesky Factorized.
|
|
|
|
// nakata 2004/12/01
|
|
static bool solveSystems(Vector& xVec,
|
|
SparseMatrix& aMat, Vector& bVec);
|
|
// solve aMat * xVec = bVec
|
|
// aMat must be Cholesky Factorized.
|
|
|
|
static bool getSymmetrize(DenseLinearSpace& aMat);
|
|
|
|
static bool getTranspose(DenseLinearSpace& retMat,
|
|
DenseLinearSpace& aMat);
|
|
|
|
static bool multiply(DenseMatrix& retMat,
|
|
DenseMatrix& aMat, DenseMatrix& bMat,
|
|
double* scalar = NULL);
|
|
static bool multiply(DenseMatrix& retMat,
|
|
SparseMatrix& aMat, DenseMatrix& bMat,
|
|
double* scalar = NULL);
|
|
static bool multiply(DenseMatrix& retMat,
|
|
DenseMatrix& aMat, SparseMatrix& bMat,
|
|
double* scalar = NULL);
|
|
static bool multiply(DenseMatrix& retMat,
|
|
DenseMatrix& aMat, double* scalar = NULL);
|
|
static bool multiply(Vector& retVec,
|
|
Vector& aVec, double* scalar = NULL);
|
|
static bool multiply(BlockVector& retVec,
|
|
BlockVector& aVec,
|
|
double* scalar = NULL);
|
|
static bool multiply(Vector& retVec,
|
|
DenseMatrix& aMat, Vector& bVec,
|
|
double* scalar = NULL);
|
|
// ret = aMat**T * bMat
|
|
static bool tran_multiply(DenseMatrix& retMat,
|
|
DenseMatrix& aMat, DenseMatrix& bMat,
|
|
double* scalar = NULL);
|
|
// ret = aMat * bMat**T
|
|
static bool multiply_tran(DenseMatrix& retMat,
|
|
DenseMatrix& aMat, DenseMatrix& bMat,
|
|
double* scalar = NULL);
|
|
// ret = a + (*scalar)*b
|
|
static bool plus(Vector& retVec, Vector& aVec,
|
|
Vector& bVec, double* scalar = NULL);
|
|
static bool plus(DenseMatrix& retMat,
|
|
DenseMatrix& aMat, DenseMatrix& bMat,
|
|
double* scalar = NULL);
|
|
static bool plus(DenseMatrix& retMat,
|
|
SparseMatrix& aMat, DenseMatrix& bMat,
|
|
double* scalar = NULL);
|
|
static bool plus(DenseMatrix& retMat,
|
|
DenseMatrix& aMat, SparseMatrix& bMat,
|
|
double* scalar = NULL);
|
|
|
|
static bool plus(BlockVector& retVec,
|
|
BlockVector& aVec,
|
|
BlockVector& bVec, double* scalar = NULL);
|
|
|
|
// ret = a '*' (*scalar)
|
|
static bool let(Vector& retVec, const char eq,
|
|
Vector& aVec, const char op,
|
|
double* scalar = NULL);
|
|
|
|
// ret = a '*' (*scalar)
|
|
static bool let(BlockVector& retVec, const char eq,
|
|
BlockVector& aVec, const char op,
|
|
double* scalar = NULL);
|
|
|
|
// ret = a '*' (*scalar)
|
|
static bool let(DenseMatrix& retMat, const char eq,
|
|
DenseMatrix& aMat, const char op,
|
|
double* scalar = NULL);
|
|
|
|
// ret = a '+' '-' b*(*scalar)
|
|
static bool let(Vector& retVec, const char eq,
|
|
Vector& aVec, const char op,
|
|
Vector& bVec, double* scalar = NULL);
|
|
|
|
// ret = a '+' '-' '*' 't' 'T' b*(*scalar)
|
|
static bool let(DenseMatrix& retMat, const char eq,
|
|
DenseMatrix& aMat, const char op,
|
|
DenseMatrix& bMat, double* scalar = NULL);
|
|
|
|
// ret = a '+' '-' '*' b*(*scalar)
|
|
static bool let(DenseMatrix& retMat, const char eq,
|
|
SparseMatrix& aMat, const char op,
|
|
DenseMatrix& bMat, double* scalar = NULL);
|
|
|
|
// ret = a '+' '-' '*' b*(*scalar)
|
|
static bool let(DenseMatrix& retMat, const char eq,
|
|
DenseMatrix& aMat, const char op,
|
|
SparseMatrix& bMat, double* scalar = NULL);
|
|
|
|
// ret = aMat '*' '/' bVec
|
|
static bool let(Vector& rVec, const char eq,
|
|
DenseMatrix& aMat, const char op,
|
|
Vector& bVec);
|
|
|
|
// nakata 2004/12/01
|
|
// ret = aMat '/' bVec
|
|
static bool let(Vector& rVec, const char eq,
|
|
SparseMatrix& aMat, const char op,
|
|
Vector& bVec);
|
|
|
|
// ret = inner_product(a,b) // op = '.'
|
|
static bool let(double& ret, const char eq,
|
|
Vector& aVec, const char op,
|
|
Vector& bVec);
|
|
|
|
// ret = inner_product(a,b) // op = '.'
|
|
static bool let(double& ret, const char eq,
|
|
DenseMatrix& aMat, const char op,
|
|
DenseMatrix& bMat);
|
|
|
|
// ret = inner_product(a,b) // op = '.'
|
|
static bool let(double& ret, const char eq,
|
|
DenseMatrix& aMat, const char op,
|
|
SparseMatrix& bMat);
|
|
|
|
// ret = inner_product(a,b) // op = '.'
|
|
static bool let(double& ret, const char eq,
|
|
SparseMatrix& aMat, const char op,
|
|
DenseMatrix& bMat);
|
|
|
|
// ret = inner_product(a,b) // op = '.'
|
|
static bool let(double& ret, const char eq,
|
|
BlockVector& aVec, const char op,
|
|
BlockVector& bVec);
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
static bool getInnerProduct(double& ret,
|
|
DenseLinearSpace& aMat,
|
|
DenseLinearSpace& bMat);
|
|
|
|
static bool getInnerProduct(double& ret,
|
|
SparseLinearSpace& aMat,
|
|
DenseLinearSpace& bMat);
|
|
|
|
// ret = a (*scalar)*b
|
|
static bool multiply(DenseLinearSpace& retMat,
|
|
DenseLinearSpace& aMat,
|
|
double* scalar = NULL);
|
|
// ret = a + (*scalar)*b
|
|
static bool plus(DenseLinearSpace& retMat,
|
|
DenseLinearSpace& aMat,
|
|
DenseLinearSpace& bMat,
|
|
double* scalar = NULL);
|
|
// CAUTION!!! We don't initialize retMat to zero matrix for efficiently.
|
|
static bool plus(DenseLinearSpace& retMat,
|
|
SparseLinearSpace& aMat,
|
|
DenseLinearSpace& bMat,
|
|
double* scalar = NULL);
|
|
// CAUTION!!! We don't initialize retMat to zero matrix for efficiently.
|
|
static bool plus(DenseLinearSpace& retMat,
|
|
DenseLinearSpace& aMat,
|
|
SparseLinearSpace& bMat,
|
|
double* scalar = NULL);
|
|
|
|
// retMat(Cholmod->A) = retMat(Cholmod->A) + aMat*(*scalar);
|
|
static void plus(CholmodMatrix& retMat,
|
|
CompMatrix& aMat,
|
|
double* scalar = NULL);
|
|
|
|
// retMat(Cholmod->A) = retMat(Cholmod->A) + aMat*(*scalar);
|
|
static void plus(CholmodSpace& retMat,
|
|
CompSpace& aMat,
|
|
double* scalar = NULL);
|
|
|
|
// ret = a '*' (*scalar)
|
|
static bool let(DenseLinearSpace& retMat, const char eq,
|
|
DenseLinearSpace& aMat, const char op,
|
|
double* scalar = NULL);
|
|
|
|
// ret = a '+' '-' b*(*scalar)
|
|
static bool let(DenseLinearSpace& retMat, const char eq,
|
|
DenseLinearSpace& aMat, const char op,
|
|
DenseLinearSpace& bMat, double* scalar = NULL);
|
|
|
|
// ret = a '+' '-' b*(*scalar)
|
|
static bool let(DenseLinearSpace& retMat, const char eq,
|
|
SparseLinearSpace& aMat, const char op,
|
|
DenseLinearSpace& bMat, double* scalar = NULL);
|
|
|
|
// ret = a '+' '-' '*' b*(*scalar)
|
|
static bool let(DenseLinearSpace& retMat, const char eq,
|
|
DenseLinearSpace& aMat, const char op,
|
|
SparseLinearSpace& bMat, double* scalar = NULL);
|
|
|
|
// ret = inner_product(a,b) // op = '.'
|
|
static bool let(double& ret, const char eq,
|
|
DenseLinearSpace& aMat, const char op,
|
|
DenseLinearSpace& bMat);
|
|
|
|
// ret = inner_product(a,b) // op = '.'
|
|
static bool let(double& ret, const char eq,
|
|
SparseLinearSpace& aMat, const char op,
|
|
DenseLinearSpace& bMat);
|
|
|
|
// ret = inner_product(a,b) // op = '.'
|
|
static bool let(double& ret, const char eq,
|
|
DenseLinearSpace& aMat, const char op,
|
|
SparseLinearSpace& bMat);
|
|
|
|
|
|
//=======================================================================
|
|
// for SDPA-C
|
|
//=======================================================================
|
|
|
|
static void getInnerProduct(double& ret,
|
|
CompMatrix& A,
|
|
CliqueMatrix& X,
|
|
OrderingMatrix& order);
|
|
|
|
static void getInnerProduct(double& ret,
|
|
cholmod_sparse* Z,
|
|
CliqueMatrix& X,
|
|
OrderingMatrix& order,
|
|
int* Z_blockNumber, int* Z_blockIndex);
|
|
|
|
static void getInnerProduct(double& ret,
|
|
CompSpace& A,
|
|
CliqueSpace& X,
|
|
OrderingSpace& order);
|
|
|
|
static void getInnerProduct(double& ret,
|
|
CompMatrix& A,
|
|
double* aVec,
|
|
double* bVec);
|
|
|
|
static void getInnerProduct(double& ret,
|
|
cholmod_sparse* A,
|
|
double* aVec,
|
|
double* bVec);
|
|
|
|
|
|
};
|
|
|
|
} // end of namespace 'sdpa'
|
|
|
|
#endif // __sdpa_linear_h__
|