overhauled physics engine
This commit is contained in:
Dynamitos
Vendored
+331
@@ -0,0 +1,331 @@
|
||||
/* -------------------------------------------------------------
|
||||
|
||||
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__
|
||||
Reference in New Issue
Block a user