int InvertMatrix ( double * A, int n){
int INFO;
int N;
static int * IPIV=NULL;
static int LWORK=0;
static double * WORK=NULL;
static int last_n=0;
N = n;
if ( n>last_n){
if (NULL==IPIV){
WORK = malloc(sizeof(double));
} else {
free(IPIV);
}
LWORK = -1;
dgetri_ (&N,A,&N,IPIV,WORK,&LWORK,&INFO);
LWORK=(int)WORK[0];
free(WORK);
WORK = malloc(LWORK*sizeof(double));
IPIV = malloc(n*sizeof(int));
last_n = n;
}
dgetrf_ (&N,&N,A,&N,IPIV,&INFO);
if ( INFO==0){
dgetri_ (&N,A,&N,IPIV,WORK,&LWORK,&INFO);
}
if (INFO!=0)
return -1;
return 0;
}
/* on output, A is replaced by A^{-1} */
int
lapack_inverse(gsl_matrix *A)
{
int s = 0;
int M = A->size1;
int N = A->size2;
int lda = N;
int *ipiv;
int lwork;
double *work;
double q[1];
ipiv = malloc(N * sizeof(int));
dgetrf_(&M, &N, A->data, &lda, ipiv, &s);
if (s != 0)
{
fprintf(stderr, "lapack_inverse: error: %d\n", s);
return s;
}
lwork = -1;
dgetri_(&N, A->data, &lda, ipiv, q, &lwork, &s);
lwork = (int) q[0];
work = malloc(lwork * sizeof(double));
/* compute inverse */
dgetri_(&N, A->data, &lda, ipiv, work, &lwork, &s);
free(ipiv);
free(work);
return s;
}
int matrix_inv( matrix_type * A ) {
matrix_lapack_assert_square( A );
{
int dgetrf_info;
int info;
int n = matrix_get_columns( A );
int * ipiv = util_malloc( n * sizeof * ipiv );
matrix_dgetrf__( A , ipiv , &dgetrf_info );
{
int lda = matrix_get_column_stride( A );
double * work = util_malloc( sizeof * work );
int work_size;
/* First call: determine optimal worksize: */
work_size = -1;
dgetri_( &n , matrix_get_data( A ), &lda , ipiv , work , &work_size , &info);
if (info == 0) {
work_size = (int) work[0];
work = util_realloc( work , sizeof * work * work_size );
dgetri_( &n , matrix_get_data( A ), &lda , ipiv , work , &work_size , &info);
} else
util_abort("%s: dgetri_ returned info:%d \n",__func__ , info);
free( work );
}
free( ipiv );
return info;
}
}
long benchmark(int size) {
int m = sqrt(size);
long requestStart, requestEnd;
// random matrices are full rank (and can always be inverted if square)
// http://www.sciencedirect.com/science/article/pii/S0096300306009040
double* a = random_array(m * m);
int bSize = m * m;
double* b = calloc(bSize, sizeof(double));
int* p = calloc(m, sizeof(int));
int info = 0;
requestStart = currentTimeNanos();
// calling raw fortran because OS X doesn't have LAPACKE
dgetrf_( &m, &m, a, &m, p, &info );
dgetri_( &m, a, &m, p, b, &bSize, &info );
requestEnd = currentTimeNanos();
free(a);
free(b);
free(p);
return (requestEnd - requestStart);
}
/* Main function to be called */
void errbars (int numparams, double *p, struct kslice *ks, double **covar)
{
int ii, ij, ik;
lapack_int n, lda, info, worksize;
char c;
double *fish, *work, *rscale, *cscale;
double row, col, amax;
int *piv;
c = 'U';
fish = malloc(numparams*numparams*sizeof(double));
piv = malloc(numparams*numparams*sizeof(int));
rscale = malloc(numparams*sizeof(double));
cscale = malloc(numparams*sizeof(double));
/* compute fisher information matrix */
fisher(numparams, p, ks, fish);
n = numparams;
lda = numparams;
dgeequ_(&n, &n, fish, &lda, rscale, cscale, &row, &col, &amax, &info);
/*
for (ii=0; ii<numparams; ii++)
for (ij=0; ij<numparams; ij++)
fish[ii*numparams+ij] *= rscale[ii]*cscale[ij];
*/
n = numparams;
lda = numparams;
dgetrf_(&n, &n, fish, &lda, piv, &info);
// printf("\tLU decomp status: %d\n", info);
worksize = 32*n;
work = malloc(worksize*sizeof(double));
dgetri_(&n, fish, &lda, piv, work, &worksize, &info);
// printf("\tInversion status: %d\n", info);
/*
for (ii=0; ii<numparams; ii++)
for (ij=0; ij<numparams; ij++)
fish[ii*numparams+ij] *= rscale[ij]*cscale[ii];
*/
/* compute inverse of fisher information matrix */
/*
for (ii=0; ii<numparams; ii++)
{
for (ij=0; ij<numparams; ij++)
printf("%d\t%d\t%e\n", ii, ij, (fish[ii*numparams+ij]));
printf("\n");
}
*/
/* return */
*covar = fish;
/* free local memory */
free(work);
free(piv);
free(rscale);
free(cscale);
}
static long
dgetri(long N, double *A, long LDA, long *IPIV, double *WORK, long LWORK)
{
extern void dgetri_(const long *N, double *A, const long *LDA, long *IPIV,
double *WORK, long *LWORK, long *infop);
long info;
dgetri_(&N, A, &LDA, IPIV, WORK, &LWORK, &info);
return info;
}
void QuasiNewton<double>::symmNonHerDiag(int NTrial, ostream &output){
char JOBVL = 'N';
char JOBVR = 'V';
int TwoNTrial = 2*NTrial;
int *IPIV = new int[TwoNTrial];
int INFO;
RealCMMap SSuper(this->SSuperMem, TwoNTrial,TwoNTrial);
RealCMMap ASuper(this->ASuperMem, TwoNTrial,TwoNTrial);
RealCMMap SCPY(this->SCPYMem, TwoNTrial,TwoNTrial);
RealCMMap NHrProd(this->NHrProdMem,TwoNTrial,TwoNTrial);
SCPY = SSuper; // Copy of original matrix to use for re-orthogonalization
// Invert the metric (maybe not needed?)
dgetrf_(&TwoNTrial,&TwoNTrial,this->SSuperMem,&TwoNTrial,IPIV,&INFO);
dgetri_(&TwoNTrial,this->SSuperMem,&TwoNTrial,IPIV,this->WORK,&this->LWORK,&INFO);
delete [] IPIV;
NHrProd = SSuper * ASuper;
//cout << endl << "PROD" << endl << NHrProd << endl;
dgeev_(&JOBVL,&JOBVR,&TwoNTrial,NHrProd.data(),&TwoNTrial,this->ERMem,this->EIMem,
this->SSuperMem,&TwoNTrial,this->SSuperMem,&TwoNTrial,this->WORK,&this->LWORK,
&INFO);
// Sort eigensystem using Bubble Sort
RealVecMap ER(this->ERMem,TwoNTrial);
RealVecMap EI(this->EIMem,TwoNTrial);
RealCMMap VR(this->SSuperMem,TwoNTrial,TwoNTrial);
// cout << endl << ER << endl;
this->eigSrt(VR,ER);
// cout << endl << ER << endl;
// Grab the "positive paired" roots (throw away other element of the pair)
this->ERMem += NTrial;
new (&ER ) RealVecMap(this->ERMem,NTrial);
new (&SSuper) RealCMMap(this->SSuperMem+2*NTrial*NTrial,2*NTrial,NTrial);
/*
* Re-orthogonalize the eigenvectors with respect to the metric S(R)
* because DSYGV orthogonalzies the vectors with respect to E(R)
* because we solve the opposite problem.
*
* Gramm-Schmidt
*/
this->metBiOrth(SSuper,SCPY);
// Separate the eigenvectors into gerade and ungerade parts
RealCMMap XTSigmaR(this->XTSigmaRMem,NTrial,NTrial);
RealCMMap XTSigmaL(this->XTSigmaLMem,NTrial,NTrial);
XTSigmaR = SSuper.block(0, 0,NTrial,NTrial);
XTSigmaL = SSuper.block(NTrial,0,NTrial,NTrial);
//cout << endl << "ER" << endl << ER << endl << endl;
//cout << endl << "CR" << endl << XTSigmaR << endl << endl;
//cout << endl << "CR" << endl << XTSigmaL << endl << endl;
// CErr();
}
int32_t invert_matrix(__CLPK_integer dim, double* matrix, MATRIX_INVERT_BUF1_TYPE* int_1d_buf, double* dbl_2d_buf) {
// dgetrf_/dgetri_ is more efficient than dpotrf_/dpotri_ on OS X.
__CLPK_integer lwork = dim * dim;
__CLPK_integer info;
dgetrf_(&dim, &dim, matrix, &dim, int_1d_buf, &info);
dgetri_(&dim, matrix, &dim, int_1d_buf, dbl_2d_buf, &lwork, &info);
if (info) {
return 1;
}
return 0;
}
/* Matrix Inverse */
void THLapack_(getri)(int n, real *a, int lda, int *ipiv, real *work, int lwork, int* info)
{
#ifdef USE_LAPACK
#if defined(TH_REAL_IS_DOUBLE)
dgetri_(&n, a, &lda, ipiv, work, &lwork, info);
#else
sgetri_(&n, a, &lda, ipiv, work, &lwork, info);
#endif
#else
THError("getri : Lapack library not found in compile time\n");
#endif
}
// lapack_square_inverse inverts a square matrix.
// Return codes:
// 0 : no problems
// 1 : make_int failed
// 2 : LU factorization failed
// 3 : inversion failed
int lapack_square_inverse(double *Ai, long m_long, double *A) {
// matrix size
int m;
int info = make_int(&m, m_long);
if (info != 0) return 1;
// copy A into Ai
int i = 0;
for (i=0; i<m*m; ++i) Ai[i] = A[i];
// auxiliary variable
int * ipiv = (int*)malloc(m * sizeof(int));
// factorization
dgetrf_(&m, // M
&m, // N
Ai, // double * A
&m, // LDA
ipiv, // Pivot indices
&info); // INFO
// clean-up and check
if (info != 0) {
free(ipiv);
return 2;
}
// auxiliary variables
int NB = 8; // Optimal blocksize ?
int lwork = m*NB; // Dimension of work >= max(1,m), optimal=m*NB
double * work = (double*)malloc(lwork * sizeof(double)); // Work
// inversion
dgetri_(&m, // N
Ai, // double * A
&m, // LDA
ipiv, // Pivot indices
work, // work
&lwork, // dimension of work
&info); // INFO
// clean up
free(ipiv);
free(work);
// check
if (info != 0) return 3;
return 0;
}
/*******************************************************************
Subroutine to compute the Inverse Matrix
by using CLAPACK subroutine - dgetri_() and dgetrf_()
matrix *A: the pointer to the matrix
matrix *InvA: the pointer to the inverse matrix
return value: '1' - successfully exit
'0' - inverse matrix does not exist
*******************************************************************/
int inv(matrix *A, matrix *InvA)
{
integer m, n, lda, lwork, info1, info2, i, j, size;
double *AT;
double *work;
integer *ipiv;
m = A->m;
n = A->n;
if (m != n) {
printf(" Warning: inv() is failed since the matrix is not square matrix. \n");
return 0;
}
lda = m;
lwork = 5*n;
size = m*n;
AT = new double[size];
work = new double[5*n];
ipiv = new integer[n];
// to call a Fortran routine from C we have to transform the matrix
for (i=0; i<m; i++) {
for (j=0; j<n; j++) {
AT[n*i+j] = *(A->pr+m*j+i);
}
}
dgetrf_(&m, &n, AT, &lda, ipiv, &info1);
dgetri_(&n, AT, &lda, ipiv, work, &lwork, &info2);
if ((info1 != 0) || (info2 != 0)) {
printf(" Warning: Inv() is failed. \n");
return 0;
}
// to output a Fortran matrix to C we have to transform the matrix
for (i=0; i<m; i++) {
for (j=0; j<n; j++) {
*(InvA->pr+n*i+j) = AT[m*j+i];
}
}
return 1;
}
DLLEXPORT MKL_INT d_lu_inverse(MKL_INT n, double a[], double work[], MKL_INT lwork)
{
MKL_INT* ipiv = new MKL_INT[n];
MKL_INT info = 0;
dgetrf_(&n,&n,a,&n,ipiv,&info);
if (info != 0){
delete[] ipiv;
return info;
}
dgetri_(&n,a,&n,ipiv,work,&lwork,&info);
delete[] ipiv;
return info;
}
void matrix_invert_inplace(int n, double *A) {
int m = n;
int lda = n;
int info;
int *ipiv = malloc(sizeof(int) * n);
int lwork = n * 512;
double *work = malloc(sizeof(double) * lwork);
/* Make calls to FORTRAN routines */
dgetrf_(&m, &n, A, &lda, ipiv, &info);
dgetri_(&n, A, &lda, ipiv, work, &lwork, &info);
free(ipiv);
free(work);
}
DLLEXPORT MKL_INT d_lu_inverse_factored(MKL_INT n, double a[], MKL_INT ipiv[], double work[], MKL_INT lwork)
{
MKL_INT i;
for(i = 0; i < n; ++i ){
ipiv[i] += 1;
}
MKL_INT info = 0;
dgetri_(&n,a,&n,ipiv,work,&lwork,&info);
for(i = 0; i < n; ++i ){
ipiv[i] -= 1;
}
return info;
}
DLLEXPORT int d_lu_inverse(int n, double a[], double work[], int lwork)
{
int* ipiv = new int[n];
int info = 0;
dgetrf_(&n,&n,a,&n,ipiv,&info);
if (info != 0){
delete[] ipiv;
return info;
}
dgetri_(&n,a,&n,ipiv,work,&lwork,&info);
delete[] ipiv;
return info;
}
DLLEXPORT int d_lu_inverse_factored(int n, double a[], int ipiv[], double work[], int lwork)
{
int i;
for(i = 0; i < n; ++i ){
ipiv[i] += 1;
}
int info = 0;
dgetri_(&n,a,&n,ipiv,work,&lwork,&info);
for(i = 0; i < n; ++i ){
ipiv[i] -= 1;
}
return info;
}
void
linalg_invert (double *A, int m)
{
int N = m;
int lwork = N * N;
int *ipiv = (int *) malloc (sizeof (int) * (N + 1));
double *work = (double *) malloc (sizeof (double) * lwork);
int info;
dgetrf_ (&N, &N, A, &N, ipiv, &info);
dgetri_ (&N, A, &N, ipiv, work, &lwork, &info);
free (ipiv);
free (work);
}
/* Invert square, real, nonsymmetric matrix. Uses LU decomposition
(LAPACK routines dgetrf and dgetri). Returns 0 on success, 1 on
failure. */
int mat_invert(Matrix *M_inv, Matrix *M) {
#ifdef SKIP_LAPACK
die("ERROR: LAPACK required for matrix inversion.\n");
#else
int i, j;
LAPACK_INT info, n = (LAPACK_INT)M->nrows, ipiv[n], lwork=(LAPACK_INT)n;
LAPACK_DOUBLE tmp[n][n], work[lwork];
if (!(M->nrows == M->ncols && M_inv->nrows == M_inv->ncols &&
M->nrows == M_inv->nrows))
die("ERROR mat_invert: bad dimensions\n");
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
tmp[i][j] = (LAPACK_DOUBLE)mat_get(M, j, i);
#ifdef R_LAPACK
F77_CALL(dgetrf)(&n, &n, (LAPACK_DOUBLE*)tmp, &n, ipiv, &info);
#else
dgetrf_(&n, &n, (LAPACK_DOUBLE*)tmp, &n, ipiv, &info);
#endif
if (info != 0) {
fprintf(stderr, "ERROR: unable to compute LU factorization of matrix (for matrix inversion); dgetrf returned value of %d.\n", (int)info);
return 1;
}
#ifdef R_LAPACK
F77_CALL(dgetri)(&n, (LAPACK_DOUBLE*)tmp, &n, ipiv, work, &lwork, &info);
#else
dgetri_(&n, (LAPACK_DOUBLE*)tmp, &n, ipiv, work, &lwork, &info);
#endif
if (info != 0) {
if (info > 0)
fprintf(stderr, "ERROR: matrix is singular -- cannot invert.\n");
else
fprintf(stderr, "ERROR: unable to invert matrix. Element %d had an illegal value (according to dgetri).\n", (int)info);
return 1;
}
for (i = 0; i < M->nrows; i++)
for (j = 0; j < M->nrows; j++)
mat_set(M_inv, i, j, (double)tmp[j][i]);
#endif
return 0;
}
bool inv(const mat &X, mat &Y)
{
// it_assert1(X.rows() == X.cols(), "inv: matrix is not square");
int m = X.rows(), info, lwork;
lwork = m; // may be choosen better
ivec p(m);
Y = X;
vec work(lwork);
dgetrf_(&m, &m, Y._data(), &m, p._data(), &info); // LU-factorization
if (info!=0)
return false;
dgetri_(&m, Y._data(), &m, p._data(), work._data(), &lwork, &info);
return (info==0);
}
int inverse(double* A, double* Ainv, int N)
{
int *IPIV = new int[N+1];
int LWORK = N*N;
double *WORK = new double[LWORK];
int INFO;
memcpy(Ainv,A,LWORK*sizeof(double));
dgetrf_(&N,&N,Ainv,&N,IPIV,&INFO);
dgetri_(&N,Ainv,&N,IPIV,WORK,&LWORK,&INFO);
delete IPIV;
delete WORK;
return INFO;
}
void invMatrix(double *Matrix, int nrow){
if (nrow == 1){
Matrix[0] = 1.0/Matrix[0];
} else {
int i, j, count;
long int m= (long int) nrow, n= (long int) nrow;
long int *pivot = calloc(((long int) nrow), sizeof(long int));
long int lda= (long int) nrow;
double *work = calloc((nrow)*(nrow), sizeof(double));
long int info;
long int length = nrow*nrow;
dgetrf_(&m, &n, Matrix, &lda, pivot, &info);
if (info > 0) printf("WARNING singular matrix inversion...%d\n", info);
dgetri_(&m, Matrix, &lda, pivot, work, &length, &info);
free(pivot);
free(work);
}
}
int32_t invert_matrix_checked(__CLPK_integer dim, double* matrix, MATRIX_INVERT_BUF1_TYPE* int_1d_buf, double* dbl_2d_buf) {
// This used to fall back on PLINK 1.07's SVD-based implementation when the
// rcond estimate was too small, but in practice that just slowed things down
// without meaningfully improving inversion of nonsingular matrices. So now
// this just exits a bit earlier, while leaving the old "binary search for
// the first row/column causing multicollinearity" logic to the caller.
__CLPK_integer lwork = dim * dim;
char cc = '1';
double norm = dlange_(&cc, &dim, &dim, matrix, &dim, dbl_2d_buf);
__CLPK_integer info;
double rcond;
dgetrf_(&dim, &dim, matrix, &dim, int_1d_buf, &info);
if (info > 0) {
return 1;
}
dgecon_(&cc, &dim, matrix, &dim, &norm, &rcond, dbl_2d_buf, &(int_1d_buf[dim]), &info);
if (rcond < MATRIX_SINGULAR_RCOND) {
return 1;
}
dgetri_(&dim, matrix, &dim, int_1d_buf, dbl_2d_buf, &lwork, &info);
return 0;
}
// Interface to lapack routine dgetri
// nn: nrow and ncol of A
void lapack_dgetri(int nn, dreal *AA, int *ipiv)
{
int lda, lwork, info;
dreal *work = NULL;
lda = (1 > nn) ? 1 : nn;
lwork = lda;
work = (dreal *) calloc(lwork, sizeof(dreal));
check_mem(work, "work");
dgetri_(&nn, AA, &lda, ipiv, work, &lwork, &info);
check(info == 0, "Failed dgetri, info = %d", info);
freeup(work);
return;
error:
if(work) freeup(work);
abort();
}
void InvSqMat(double * Data, int NCol)
{
/******************************************************************
input: 矩陣本身開頭指標，矩陣column數
output: 直接儲存在矩陣本身位置
Note: 輸入一定要是方陣!!
******************************************************************/
// 準備丟給CLAPACK的變數 還有記憶體分配
integer Dim = NCol;
doublereal *work = new doublereal[Dim*Dim];
integer INFO;
integer * ipiv = new integer[Dim*Dim];
// CLAPACK 的 LU decomposition
dgetrf_(&Dim,&Dim,Data,&Dim,ipiv,&INFO);
if (INFO != 0)
{
cout << "Fail to Calculate LU decomposition" << endl;
system("pause");
}
// CLAPACK 的 矩陣 inverse
dgetri_(&Dim,Data,&Dim,ipiv,work,&Dim,&INFO);
if (INFO != 0)
{
cout << "Fail to Calculate Matrix Inversion" << endl;
system("pause");
}
// 清除動態記憶體
delete[] work;
delete[] ipiv;
}
void matrix_invert(int n, double *A, double *Ainv) {
double *At = malloc(sizeof(double) * n * n);
int m = n;
int lda = n;
int info;
int *ipiv = malloc(sizeof(int) * n);
int lwork = n * 512;
int i, j;
double *work = malloc(sizeof(double) * lwork);
assert(At != NULL);
assert(ipiv != NULL);
assert(work != NULL);
/* Transpose A info At like FORTRAN likes */
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
At[i * n + j] = A[j * n + i];
/* Make calls to FORTRAN routines */
dgetrf_(&m, &n, At, &lda, ipiv, &info);
if (info != 0)
printf("[matrix_invert] Error[dgetrf]: %d\n", info);
dgetri_(&n, At, &lda, ipiv, work, &lwork, &info);
if (info != 0)
printf("[matrix_invert] Error[dgetri]: %d\n", info);
/* Transpose back into Ainv */
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
Ainv[i * n + j] = At[j * n + i];
free(At);
free(ipiv);
free(work);
}
/**
* <p id="dlm_invert_gel">Inverts a matrix and computes its determinant through Gaussian
* elimination.</p>
*
* @param A
* Pointer to input matrix, replaced in computation by resultant
* inverse
* @param nXA
* Order of matrix (number of rows and columns)
* @param lpnDet
* Pointer to be filled with resultant determinant (may be
* <code>NULL</code>)
* @return <code>O_K</code> if successfull, a (negative) error code otherwise
*/
INT16 dlm_invert_gel(FLOAT64* A, INT32 nXA, FLOAT64* lpnDet) {
integer n = (integer) nXA;
integer c__1 = 1;
integer c_n1 = -1;
integer info = 0;
integer* ipiv = dlp_calloc(n, sizeof(integer));
void* work = NULL;
char opts[1] = { ' ' };
extern integer ilaenv_(integer*,char*,char*,integer*,integer*,integer*,integer*,ftnlen,ftnlen);
#ifdef __MAX_TYPE_32BIT
extern int sgetrf_(integer*,integer*,real*,integer*,integer*,integer*);
extern int sgetri_(integer*,real*,integer*,integer*,real*,integer*,integer*);
char name[8] = { 'S', 'G', 'E', 'T', 'R', 'I' };
integer lwork = n * ilaenv_(&c__1, name, opts, &n, &c_n1, &c_n1, &c_n1, (ftnlen)6, (ftnlen)1);
work = dlp_calloc(lwork, sizeof(real));
if(!ipiv || !work) return ERR_MEM;
sgetrf_(&n,&n,A,&n,ipiv,&info);
if(lpnDet != NULL) *lpnDet = (info > 0) ? 0.0 : dlm_get_det_trf(A, nXA, ipiv);
sgetri_(&n,A,&n,ipiv,work,&lwork,&info);
#else
extern int dgetrf_(integer*,integer*,doublereal*,integer*,integer*,integer*);
extern int dgetri_(integer*,doublereal*,integer*,integer*,doublereal*,integer*,integer*);
char name[8] = { 'D', 'G', 'E', 'T', 'R', 'I' };
integer lwork = n * ilaenv_(&c__1, name, opts, &n, &c_n1, &c_n1, &c_n1, (ftnlen) 6, (ftnlen) 1);
work = dlp_calloc(lwork, sizeof(doublereal));
if (!ipiv || !work) return ERR_MEM;
dgetrf_(&n, &n, A, &n, ipiv, &info);
if (lpnDet != NULL) *lpnDet = (info > 0) ? 0.0 : dlm_get_det_trf(A, nXA, ipiv);
dgetri_(&n, A, &n, ipiv, work, &lwork, &info);
#endif
dlp_free(work);
dlp_free(ipiv);
return (info == 0) ? O_K : NOT_EXEC;
}
/* Subroutine */ int ddrvge_(logical *dotype, integer *nn, integer *nval,
integer *nrhs, doublereal *thresh, logical *tsterr, integer *nmax,
doublereal *a, doublereal *afac, doublereal *asav, doublereal *b,
doublereal *bsav, doublereal *x, doublereal *xact, doublereal *s,
doublereal *work, doublereal *rwork, integer *iwork, integer *nout)
{
/* Initialized data */
static integer iseedy[4] = { 1988,1989,1990,1991 };
static char transs[1*3] = "N" "T" "C";
static char facts[1*3] = "F" "N" "E";
static char equeds[1*4] = "N" "R" "C" "B";
/* Format strings */
static char fmt_9999[] = "(1x,a,\002, N =\002,i5,\002, type \002,i2,\002"
", test(\002,i2,\002) =\002,g12.5)";
static char fmt_9997[] = "(1x,a,\002, FACT='\002,a1,\002', TRANS='\002,a"
"1,\002', N=\002,i5,\002, EQUED='\002,a1,\002', type \002,i2,\002"
", test(\002,i1,\002)=\002,g12.5)";
static char fmt_9998[] = "(1x,a,\002, FACT='\002,a1,\002', TRANS='\002,a"
"1,\002', N=\002,i5,\002, type \002,i2,\002, test(\002,i1,\002)"
"=\002,g12.5)";
/* System generated locals */
address a__1[2];
integer i__1, i__2, i__3, i__4, i__5[2];
doublereal d__1;
char ch__1[2];
/* Builtin functions */
/* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
integer s_wsfe(cilist *), do_fio(integer *, char *, ftnlen), e_wsfe(void);
/* Subroutine */ int s_cat(char *, char **, integer *, integer *, ftnlen);
/* Local variables */
extern /* Subroutine */ int debchvxx_(doublereal *, char *);
integer i__, k, n;
doublereal *errbnds_c__, *errbnds_n__;
integer k1, nb, in, kl, ku, nt, n_err_bnds__;
extern doublereal dla_rpvgrw__(integer *, integer *, doublereal *,
integer *, doublereal *, integer *);
integer lda;
char fact[1];
integer ioff, mode;
doublereal amax;
char path[3];
integer imat, info;
doublereal *berr;
char dist[1];
doublereal rpvgrw_svxx__;
char type__[1];
integer nrun;
extern /* Subroutine */ int dget01_(integer *, integer *, doublereal *,
integer *, doublereal *, integer *, integer *, doublereal *,
doublereal *), dget02_(char *, integer *, integer *, integer *,
doublereal *, integer *, doublereal *, integer *, doublereal *,
integer *, doublereal *, doublereal *);
integer ifact;
extern /* Subroutine */ int dget04_(integer *, integer *, doublereal *,
integer *, doublereal *, integer *, doublereal *, doublereal *);
integer nfail, iseed[4], nfact;
extern doublereal dget06_(doublereal *, doublereal *);
extern /* Subroutine */ int dget07_(char *, integer *, integer *,
doublereal *, integer *, doublereal *, integer *, doublereal *,
integer *, doublereal *, integer *, doublereal *, logical *,
doublereal *, doublereal *);
extern logical lsame_(char *, char *);
char equed[1];
integer nbmin;
doublereal rcond, roldc;
integer nimat;
doublereal roldi;
extern /* Subroutine */ int dgesv_(integer *, integer *, doublereal *,
integer *, integer *, doublereal *, integer *, integer *);
doublereal anorm;
integer itran;
logical equil;
doublereal roldo;
char trans[1];
integer izero, nerrs, lwork;
logical zerot;
char xtype[1];
extern /* Subroutine */ int dlatb4_(char *, integer *, integer *, integer
*, char *, integer *, integer *, doublereal *, integer *,
doublereal *, char *), aladhd_(integer *,
char *);
extern doublereal dlamch_(char *), dlange_(char *, integer *,
integer *, doublereal *, integer *, doublereal *);
extern /* Subroutine */ int alaerh_(char *, char *, integer *, integer *,
char *, integer *, integer *, integer *, integer *, integer *,
integer *, integer *, integer *, integer *), dlaqge_(integer *, integer *, doublereal *, integer *,
doublereal *, doublereal *, doublereal *, doublereal *,
doublereal *, char *);
logical prefac;
doublereal colcnd, rcondc;
logical nofact;
integer iequed;
extern /* Subroutine */ int dgeequ_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, doublereal *, doublereal *,
doublereal *, integer *);
doublereal rcondi;
extern /* Subroutine */ int dgetrf_(integer *, integer *, doublereal *,
integer *, integer *, integer *), dgetri_(integer *, doublereal *,
integer *, integer *, doublereal *, integer *, integer *),
dlacpy_(char *, integer *, integer *, doublereal *, integer *,
doublereal *, integer *), alasvm_(char *, integer *,
integer *, integer *, integer *);
doublereal cndnum, anormi, rcondo, ainvnm;
extern doublereal dlantr_(char *, char *, char *, integer *, integer *,
doublereal *, integer *, doublereal *);
extern /* Subroutine */ int dlarhs_(char *, char *, char *, char *,
integer *, integer *, integer *, integer *, integer *, doublereal
*, integer *, doublereal *, integer *, doublereal *, integer *,
integer *, integer *);
logical trfcon;
doublereal anormo, rowcnd;
extern /* Subroutine */ int dlaset_(char *, integer *, integer *,
doublereal *, doublereal *, doublereal *, integer *),
dgesvx_(char *, char *, integer *, integer *, doublereal *,
integer *, doublereal *, integer *, integer *, char *, doublereal
*, doublereal *, doublereal *, integer *, doublereal *, integer *,
doublereal *, doublereal *, doublereal *, doublereal *, integer *
, integer *), dlatms_(integer *, integer *
, char *, integer *, char *, doublereal *, integer *, doublereal *
, doublereal *, integer *, integer *, char *, doublereal *,
integer *, doublereal *, integer *),
xlaenv_(integer *, integer *), derrvx_(char *, integer *);
doublereal result[7], rpvgrw;
extern /* Subroutine */ int dgesvxx_(char *, char *, integer *, integer *,
doublereal *, integer *, doublereal *, integer *, integer *,
char *, doublereal *, doublereal *, doublereal *, integer *,
doublereal *, integer *, doublereal *, doublereal *, doublereal *,
integer *, doublereal *, doublereal *, integer *, doublereal *,
doublereal *, integer *, integer *);
/* Fortran I/O blocks */
static cilist io___55 = { 0, 0, 0, fmt_9999, 0 };
static cilist io___61 = { 0, 0, 0, fmt_9997, 0 };
static cilist io___62 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___63 = { 0, 0, 0, fmt_9997, 0 };
static cilist io___64 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___65 = { 0, 0, 0, fmt_9997, 0 };
static cilist io___66 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___67 = { 0, 0, 0, fmt_9997, 0 };
static cilist io___68 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___74 = { 0, 0, 0, fmt_9997, 0 };
static cilist io___75 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___76 = { 0, 0, 0, fmt_9997, 0 };
static cilist io___77 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___78 = { 0, 0, 0, fmt_9997, 0 };
static cilist io___79 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___80 = { 0, 0, 0, fmt_9997, 0 };
static cilist io___81 = { 0, 0, 0, fmt_9998, 0 };
/* -- LAPACK test routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* DDRVGE tests the driver routines DGESV, -SVX, and -SVXX. */
/* Note that this file is used only when the XBLAS are available, */
/* otherwise ddrvge.f defines this subroutine. */
/* Arguments */
/* ========= */
/* DOTYPE (input) LOGICAL array, dimension (NTYPES) */
/* The matrix types to be used for testing. Matrices of type j */
/* (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = */
/* .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. */
/* NN (input) INTEGER */
/* The number of values of N contained in the vector NVAL. */
/* NVAL (input) INTEGER array, dimension (NN) */
/* The values of the matrix column dimension N. */
/* NRHS (input) INTEGER */
/* The number of right hand side vectors to be generated for */
/* each linear system. */
/* THRESH (input) DOUBLE PRECISION */
/* The threshold value for the test ratios. A result is */
/* included in the output file if RESULT >= THRESH. To have */
/* every test ratio printed, use THRESH = 0. */
/* TSTERR (input) LOGICAL */
/* Flag that indicates whether error exits are to be tested. */
/* NMAX (input) INTEGER */
/* The maximum value permitted for N, used in dimensioning the */
/* work arrays. */
/* A (workspace) DOUBLE PRECISION array, dimension (NMAX*NMAX) */
/* AFAC (workspace) DOUBLE PRECISION array, dimension (NMAX*NMAX) */
/* ASAV (workspace) DOUBLE PRECISION array, dimension (NMAX*NMAX) */
/* B (workspace) DOUBLE PRECISION array, dimension (NMAX*NRHS) */
/* BSAV (workspace) DOUBLE PRECISION array, dimension (NMAX*NRHS) */
/* X (workspace) DOUBLE PRECISION array, dimension (NMAX*NRHS) */
/* XACT (workspace) DOUBLE PRECISION array, dimension (NMAX*NRHS) */
/* S (workspace) DOUBLE PRECISION array, dimension (2*NMAX) */
/* WORK (workspace) DOUBLE PRECISION array, dimension */
/* (NMAX*max(3,NRHS)) */
/* RWORK (workspace) DOUBLE PRECISION array, dimension (2*NRHS+NMAX) */
/* IWORK (workspace) INTEGER array, dimension (2*NMAX) */
/* NOUT (input) INTEGER */
/* The unit number for output. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Scalars in Common .. */
/* .. */
/* .. Common blocks .. */
/* .. */
/* .. Data statements .. */
/* Parameter adjustments */
--iwork;
--rwork;
--work;
--s;
--xact;
--x;
--bsav;
--b;
--asav;
--afac;
--a;
--nval;
--dotype;
/* Function Body */
/* .. */
/* .. Executable Statements .. */
/* Initialize constants and the random number seed. */
s_copy(path, "Double precision", (ftnlen)1, (ftnlen)16);
s_copy(path + 1, "GE", (ftnlen)2, (ftnlen)2);
nrun = 0;
nfail = 0;
nerrs = 0;
for (i__ = 1; i__ <= 4; ++i__) {
iseed[i__ - 1] = iseedy[i__ - 1];
/* L10: */
}
/* Test the error exits */
if (*tsterr) {
derrvx_(path, nout);
}
infoc_1.infot = 0;
/* Set the block size and minimum block size for testing. */
nb = 1;
nbmin = 2;
xlaenv_(&c__1, &nb);
xlaenv_(&c__2, &nbmin);
/* Do for each value of N in NVAL */
i__1 = *nn;
for (in = 1; in <= i__1; ++in) {
n = nval[in];
lda = max(n,1);
*(unsigned char *)xtype = 'N';
nimat = 11;
if (n <= 0) {
nimat = 1;
}
i__2 = nimat;
for (imat = 1; imat <= i__2; ++imat) {
/* Do the tests only if DOTYPE( IMAT ) is true. */
if (! dotype[imat]) {
goto L80;
}
/* Skip types 5, 6, or 7 if the matrix size is too small. */
zerot = imat >= 5 && imat <= 7;
if (zerot && n < imat - 4) {
goto L80;
}
/* Set up parameters with DLATB4 and generate a test matrix */
/* with DLATMS. */
dlatb4_(path, &imat, &n, &n, type__, &kl, &ku, &anorm, &mode, &
cndnum, dist);
rcondc = 1. / cndnum;
s_copy(srnamc_1.srnamt, "DLATMS", (ftnlen)32, (ftnlen)6);
dlatms_(&n, &n, dist, iseed, type__, &rwork[1], &mode, &cndnum, &
anorm, &kl, &ku, "No packing", &a[1], &lda, &work[1], &
info);
/* Check error code from DLATMS. */
if (info != 0) {
alaerh_(path, "DLATMS", &info, &c__0, " ", &n, &n, &c_n1, &
c_n1, &c_n1, &imat, &nfail, &nerrs, nout);
goto L80;
}
/* For types 5-7, zero one or more columns of the matrix to */
/* test that INFO is returned correctly. */
if (zerot) {
if (imat == 5) {
izero = 1;
} else if (imat == 6) {
izero = n;
} else {
izero = n / 2 + 1;
}
ioff = (izero - 1) * lda;
if (imat < 7) {
i__3 = n;
for (i__ = 1; i__ <= i__3; ++i__) {
a[ioff + i__] = 0.;
/* L20: */
}
} else {
i__3 = n - izero + 1;
dlaset_("Full", &n, &i__3, &c_b20, &c_b20, &a[ioff + 1], &
lda);
}
} else {
izero = 0;
}
/* Save a copy of the matrix A in ASAV. */
dlacpy_("Full", &n, &n, &a[1], &lda, &asav[1], &lda);
for (iequed = 1; iequed <= 4; ++iequed) {
*(unsigned char *)equed = *(unsigned char *)&equeds[iequed -
1];
if (iequed == 1) {
nfact = 3;
} else {
nfact = 1;
}
i__3 = nfact;
for (ifact = 1; ifact <= i__3; ++ifact) {
*(unsigned char *)fact = *(unsigned char *)&facts[ifact -
1];
prefac = lsame_(fact, "F");
nofact = lsame_(fact, "N");
equil = lsame_(fact, "E");
if (zerot) {
if (prefac) {
goto L60;
}
rcondo = 0.;
rcondi = 0.;
} else if (! nofact) {
/* Compute the condition number for comparison with */
/* the value returned by DGESVX (FACT = 'N' reuses */
/* the condition number from the previous iteration */
/* with FACT = 'F'). */
dlacpy_("Full", &n, &n, &asav[1], &lda, &afac[1], &
lda);
if (equil || iequed > 1) {
/* Compute row and column scale factors to */
/* equilibrate the matrix A. */
dgeequ_(&n, &n, &afac[1], &lda, &s[1], &s[n + 1],
&rowcnd, &colcnd, &amax, &info);
if (info == 0 && n > 0) {
if (lsame_(equed, "R"))
{
rowcnd = 0.;
colcnd = 1.;
} else if (lsame_(equed, "C")) {
rowcnd = 1.;
colcnd = 0.;
} else if (lsame_(equed, "B")) {
rowcnd = 0.;
colcnd = 0.;
}
/* Equilibrate the matrix. */
dlaqge_(&n, &n, &afac[1], &lda, &s[1], &s[n +
1], &rowcnd, &colcnd, &amax, equed);
}
}
/* Save the condition number of the non-equilibrated */
/* system for use in DGET04. */
if (equil) {
roldo = rcondo;
roldi = rcondi;
}
/* Compute the 1-norm and infinity-norm of A. */
anormo = dlange_("1", &n, &n, &afac[1], &lda, &rwork[
1]);
anormi = dlange_("I", &n, &n, &afac[1], &lda, &rwork[
1]);
/* Factor the matrix A. */
dgetrf_(&n, &n, &afac[1], &lda, &iwork[1], &info);
/* Form the inverse of A. */
dlacpy_("Full", &n, &n, &afac[1], &lda, &a[1], &lda);
lwork = *nmax * max(3,*nrhs);
dgetri_(&n, &a[1], &lda, &iwork[1], &work[1], &lwork,
&info);
/* Compute the 1-norm condition number of A. */
ainvnm = dlange_("1", &n, &n, &a[1], &lda, &rwork[1]);
if (anormo <= 0. || ainvnm <= 0.) {
rcondo = 1.;
} else {
rcondo = 1. / anormo / ainvnm;
}
/* Compute the infinity-norm condition number of A. */
ainvnm = dlange_("I", &n, &n, &a[1], &lda, &rwork[1]);
if (anormi <= 0. || ainvnm <= 0.) {
rcondi = 1.;
} else {
rcondi = 1. / anormi / ainvnm;
}
}
for (itran = 1; itran <= 3; ++itran) {
for (i__ = 1; i__ <= 7; ++i__) {
result[i__ - 1] = 0.;
}
/* Do for each value of TRANS. */
*(unsigned char *)trans = *(unsigned char *)&transs[
itran - 1];
if (itran == 1) {
rcondc = rcondo;
} else {
rcondc = rcondi;
}
/* Restore the matrix A. */
dlacpy_("Full", &n, &n, &asav[1], &lda, &a[1], &lda);
/* Form an exact solution and set the right hand side. */
s_copy(srnamc_1.srnamt, "DLARHS", (ftnlen)32, (ftnlen)
6);
dlarhs_(path, xtype, "Full", trans, &n, &n, &kl, &ku,
nrhs, &a[1], &lda, &xact[1], &lda, &b[1], &
lda, iseed, &info);
*(unsigned char *)xtype = 'C';
dlacpy_("Full", &n, nrhs, &b[1], &lda, &bsav[1], &lda);
if (nofact && itran == 1) {
/* --- Test DGESV --- */
/* Compute the LU factorization of the matrix and */
/* solve the system. */
dlacpy_("Full", &n, &n, &a[1], &lda, &afac[1], &
lda);
dlacpy_("Full", &n, nrhs, &b[1], &lda, &x[1], &
lda);
s_copy(srnamc_1.srnamt, "DGESV ", (ftnlen)32, (
ftnlen)6);
dgesv_(&n, nrhs, &afac[1], &lda, &iwork[1], &x[1],
&lda, &info);
/* Check error code from DGESV . */
if (info != izero) {
alaerh_(path, "DGESV ", &info, &izero, " ", &
n, &n, &c_n1, &c_n1, nrhs, &imat, &
nfail, &nerrs, nout);
goto L50;
}
/* Reconstruct matrix from factors and compute */
/* residual. */
dget01_(&n, &n, &a[1], &lda, &afac[1], &lda, &
iwork[1], &rwork[1], result);
nt = 1;
if (izero == 0) {
/* Compute residual of the computed solution. */
dlacpy_("Full", &n, nrhs, &b[1], &lda, &work[
1], &lda);
dget02_("No transpose", &n, &n, nrhs, &a[1], &
lda, &x[1], &lda, &work[1], &lda, &
rwork[1], &result[1]);
/* Check solution from generated exact solution. */
dget04_(&n, nrhs, &x[1], &lda, &xact[1], &lda,
&rcondc, &result[2]);
nt = 3;
}
/* Print information about the tests that did not */
/* pass the threshold. */
i__4 = nt;
for (k = 1; k <= i__4; ++k) {
if (result[k - 1] >= *thresh) {
if (nfail == 0 && nerrs == 0) {
aladhd_(nout, path);
}
io___55.ciunit = *nout;
s_wsfe(&io___55);
do_fio(&c__1, "DGESV ", (ftnlen)6);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(
integer));
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&k, (ftnlen)sizeof(
integer));
do_fio(&c__1, (char *)&result[k - 1], (
ftnlen)sizeof(doublereal));
e_wsfe();
++nfail;
}
/* L30: */
}
nrun += nt;
}
/* --- Test DGESVX --- */
if (! prefac) {
dlaset_("Full", &n, &n, &c_b20, &c_b20, &afac[1],
&lda);
}
dlaset_("Full", &n, nrhs, &c_b20, &c_b20, &x[1], &lda);
if (iequed > 1 && n > 0) {
/* Equilibrate the matrix if FACT = 'F' and */
/* EQUED = 'R', 'C', or 'B'. */
dlaqge_(&n, &n, &a[1], &lda, &s[1], &s[n + 1], &
rowcnd, &colcnd, &amax, equed);
}
/* Solve the system and compute the condition number */
/* and error bounds using DGESVX. */
s_copy(srnamc_1.srnamt, "DGESVX", (ftnlen)32, (ftnlen)
6);
dgesvx_(fact, trans, &n, nrhs, &a[1], &lda, &afac[1],
&lda, &iwork[1], equed, &s[1], &s[n + 1], &b[
1], &lda, &x[1], &lda, &rcond, &rwork[1], &
rwork[*nrhs + 1], &work[1], &iwork[n + 1], &
info);
/* Check the error code from DGESVX. */
if (info == n + 1) {
goto L50;
}
if (info != izero) {
/* Writing concatenation */
i__5[0] = 1, a__1[0] = fact;
i__5[1] = 1, a__1[1] = trans;
s_cat(ch__1, a__1, i__5, &c__2, (ftnlen)2);
alaerh_(path, "DGESVX", &info, &izero, ch__1, &n,
&n, &c_n1, &c_n1, nrhs, &imat, &nfail, &
nerrs, nout);
goto L50;
}
/* Compare WORK(1) from DGESVX with the computed */
/* reciprocal pivot growth factor RPVGRW */
if (info != 0) {
rpvgrw = dlantr_("M", "U", "N", &info, &info, &
afac[1], &lda, &work[1]);
if (rpvgrw == 0.) {
rpvgrw = 1.;
} else {
rpvgrw = dlange_("M", &n, &info, &a[1], &lda,
&work[1]) / rpvgrw;
}
} else {
rpvgrw = dlantr_("M", "U", "N", &n, &n, &afac[1],
&lda, &work[1]);
if (rpvgrw == 0.) {
rpvgrw = 1.;
} else {
rpvgrw = dlange_("M", &n, &n, &a[1], &lda, &
work[1]) / rpvgrw;
}
}
result[6] = (d__1 = rpvgrw - work[1], abs(d__1)) /
max(work[1],rpvgrw) / dlamch_("E");
if (! prefac) {
/* Reconstruct matrix from factors and compute */
/* residual. */
dget01_(&n, &n, &a[1], &lda, &afac[1], &lda, &
iwork[1], &rwork[(*nrhs << 1) + 1],
result);
k1 = 1;
} else {
k1 = 2;
}
if (info == 0) {
trfcon = FALSE_;
/* Compute residual of the computed solution. */
dlacpy_("Full", &n, nrhs, &bsav[1], &lda, &work[1]
, &lda);
dget02_(trans, &n, &n, nrhs, &asav[1], &lda, &x[1]
, &lda, &work[1], &lda, &rwork[(*nrhs <<
1) + 1], &result[1]);
/* Check solution from generated exact solution. */
if (nofact || prefac && lsame_(equed, "N")) {
dget04_(&n, nrhs, &x[1], &lda, &xact[1], &lda,
&rcondc, &result[2]);
} else {
if (itran == 1) {
roldc = roldo;
} else {
roldc = roldi;
}
dget04_(&n, nrhs, &x[1], &lda, &xact[1], &lda,
&roldc, &result[2]);
}
/* Check the error bounds from iterative */
/* refinement. */
dget07_(trans, &n, nrhs, &asav[1], &lda, &b[1], &
lda, &x[1], &lda, &xact[1], &lda, &rwork[
1], &c_true, &rwork[*nrhs + 1], &result[3]
);
} else {
trfcon = TRUE_;
}
/* Compare RCOND from DGESVX with the computed value */
/* in RCONDC. */
result[5] = dget06_(&rcond, &rcondc);
/* Print information about the tests that did not pass */
/* the threshold. */
if (! trfcon) {
for (k = k1; k <= 7; ++k) {
if (result[k - 1] >= *thresh) {
if (nfail == 0 && nerrs == 0) {
aladhd_(nout, path);
}
if (prefac) {
io___61.ciunit = *nout;
s_wsfe(&io___61);
do_fio(&c__1, "DGESVX", (ftnlen)6);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)
sizeof(integer));
do_fio(&c__1, equed, (ftnlen)1);
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&k, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[k - 1],
(ftnlen)sizeof(doublereal));
e_wsfe();
} else {
io___62.ciunit = *nout;
s_wsfe(&io___62);
do_fio(&c__1, "DGESVX", (ftnlen)6);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&k, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[k - 1],
(ftnlen)sizeof(doublereal));
e_wsfe();
}
++nfail;
}
/* L40: */
}
nrun = nrun + 7 - k1;
} else {
if (result[0] >= *thresh && ! prefac) {
if (nfail == 0 && nerrs == 0) {
aladhd_(nout, path);
}
if (prefac) {
io___63.ciunit = *nout;
s_wsfe(&io___63);
do_fio(&c__1, "DGESVX", (ftnlen)6);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(
integer));
do_fio(&c__1, equed, (ftnlen)1);
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&c__1, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[0], (ftnlen)
sizeof(doublereal));
e_wsfe();
} else {
io___64.ciunit = *nout;
s_wsfe(&io___64);
do_fio(&c__1, "DGESVX", (ftnlen)6);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(
integer));
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&c__1, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[0], (ftnlen)
sizeof(doublereal));
e_wsfe();
}
++nfail;
++nrun;
}
if (result[5] >= *thresh) {
if (nfail == 0 && nerrs == 0) {
aladhd_(nout, path);
}
if (prefac) {
io___65.ciunit = *nout;
s_wsfe(&io___65);
do_fio(&c__1, "DGESVX", (ftnlen)6);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(
integer));
do_fio(&c__1, equed, (ftnlen)1);
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&c__6, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[5], (ftnlen)
sizeof(doublereal));
e_wsfe();
} else {
io___66.ciunit = *nout;
s_wsfe(&io___66);
do_fio(&c__1, "DGESVX", (ftnlen)6);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(
integer));
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&c__6, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[5], (ftnlen)
sizeof(doublereal));
e_wsfe();
}
++nfail;
++nrun;
}
if (result[6] >= *thresh) {
if (nfail == 0 && nerrs == 0) {
aladhd_(nout, path);
}
if (prefac) {
io___67.ciunit = *nout;
s_wsfe(&io___67);
do_fio(&c__1, "DGESVX", (ftnlen)6);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(
integer));
do_fio(&c__1, equed, (ftnlen)1);
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&c__7, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[6], (ftnlen)
sizeof(doublereal));
e_wsfe();
} else {
io___68.ciunit = *nout;
s_wsfe(&io___68);
do_fio(&c__1, "DGESVX", (ftnlen)6);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(
integer));
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&c__7, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[6], (ftnlen)
sizeof(doublereal));
e_wsfe();
}
++nfail;
++nrun;
}
}
/* --- Test DGESVXX --- */
/* Restore the matrices A and B. */
dlacpy_("Full", &n, &n, &asav[1], &lda, &a[1], &lda);
dlacpy_("Full", &n, nrhs, &bsav[1], &lda, &b[1], &lda);
if (! prefac) {
dlaset_("Full", &n, &n, &c_b20, &c_b20, &afac[1],
&lda);
}
dlaset_("Full", &n, nrhs, &c_b20, &c_b20, &x[1], &lda);
if (iequed > 1 && n > 0) {
/* Equilibrate the matrix if FACT = 'F' and */
/* EQUED = 'R', 'C', or 'B'. */
dlaqge_(&n, &n, &a[1], &lda, &s[1], &s[n + 1], &
rowcnd, &colcnd, &amax, equed);
}
/* Solve the system and compute the condition number */
/* and error bounds using DGESVXX. */
s_copy(srnamc_1.srnamt, "DGESVXX", (ftnlen)32, (
ftnlen)7);
n_err_bnds__ = 3;
dalloc3();
dgesvxx_(fact, trans, &n, nrhs, &a[1], &lda, &afac[1],
&lda, &iwork[1], equed, &s[1], &s[n + 1], &b[
1], &lda, &x[1], &lda, &rcond, &rpvgrw_svxx__,
berr, &n_err_bnds__, errbnds_n__,
errbnds_c__, &c__0, &c_b20, &work[1], &iwork[
n + 1], &info);
free3();
/* Check the error code from DGESVXX. */
if (info == n + 1) {
goto L50;
}
if (info != izero) {
/* Writing concatenation */
i__5[0] = 1, a__1[0] = fact;
i__5[1] = 1, a__1[1] = trans;
s_cat(ch__1, a__1, i__5, &c__2, (ftnlen)2);
alaerh_(path, "DGESVXX", &info, &izero, ch__1, &n,
&n, &c_n1, &c_n1, nrhs, &imat, &nfail, &
nerrs, nout);
goto L50;
}
/* Compare rpvgrw_svxx from DGESVXX with the computed */
/* reciprocal pivot growth factor RPVGRW */
if (info > 0 && info < n + 1) {
rpvgrw = dla_rpvgrw__(&n, &info, &a[1], &lda, &
afac[1], &lda);
} else {
rpvgrw = dla_rpvgrw__(&n, &n, &a[1], &lda, &afac[
1], &lda);
}
result[6] = (d__1 = rpvgrw - rpvgrw_svxx__, abs(d__1))
/ max(rpvgrw_svxx__,rpvgrw) / dlamch_("E");
if (! prefac) {
/* Reconstruct matrix from factors and compute */
/* residual. */
dget01_(&n, &n, &a[1], &lda, &afac[1], &lda, &
iwork[1], &rwork[(*nrhs << 1) + 1],
result);
k1 = 1;
} else {
k1 = 2;
}
if (info == 0) {
trfcon = FALSE_;
/* Compute residual of the computed solution. */
dlacpy_("Full", &n, nrhs, &bsav[1], &lda, &work[1]
, &lda);
dget02_(trans, &n, &n, nrhs, &asav[1], &lda, &x[1]
, &lda, &work[1], &lda, &rwork[(*nrhs <<
1) + 1], &result[1]);
/* Check solution from generated exact solution. */
if (nofact || prefac && lsame_(equed, "N")) {
dget04_(&n, nrhs, &x[1], &lda, &xact[1], &lda,
&rcondc, &result[2]);
} else {
if (itran == 1) {
roldc = roldo;
} else {
roldc = roldi;
}
dget04_(&n, nrhs, &x[1], &lda, &xact[1], &lda,
&roldc, &result[2]);
}
} else {
trfcon = TRUE_;
}
/* Compare RCOND from DGESVXX with the computed value */
/* in RCONDC. */
result[5] = dget06_(&rcond, &rcondc);
/* Print information about the tests that did not pass */
/* the threshold. */
if (! trfcon) {
for (k = k1; k <= 7; ++k) {
if (result[k - 1] >= *thresh) {
if (nfail == 0 && nerrs == 0) {
aladhd_(nout, path);
}
if (prefac) {
io___74.ciunit = *nout;
s_wsfe(&io___74);
do_fio(&c__1, "DGESVXX", (ftnlen)7);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)
sizeof(integer));
do_fio(&c__1, equed, (ftnlen)1);
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&k, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[k - 1],
(ftnlen)sizeof(doublereal));
e_wsfe();
} else {
io___75.ciunit = *nout;
s_wsfe(&io___75);
do_fio(&c__1, "DGESVXX", (ftnlen)7);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&k, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[k - 1],
(ftnlen)sizeof(doublereal));
e_wsfe();
}
++nfail;
}
/* L45: */
}
nrun = nrun + 7 - k1;
} else {
if (result[0] >= *thresh && ! prefac) {
if (nfail == 0 && nerrs == 0) {
aladhd_(nout, path);
}
if (prefac) {
io___76.ciunit = *nout;
s_wsfe(&io___76);
do_fio(&c__1, "DGESVXX", (ftnlen)7);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(
integer));
do_fio(&c__1, equed, (ftnlen)1);
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&c__1, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[0], (ftnlen)
sizeof(doublereal));
e_wsfe();
} else {
io___77.ciunit = *nout;
s_wsfe(&io___77);
do_fio(&c__1, "DGESVXX", (ftnlen)7);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(
integer));
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&c__1, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[0], (ftnlen)
sizeof(doublereal));
e_wsfe();
}
++nfail;
++nrun;
}
if (result[5] >= *thresh) {
if (nfail == 0 && nerrs == 0) {
aladhd_(nout, path);
}
if (prefac) {
io___78.ciunit = *nout;
s_wsfe(&io___78);
do_fio(&c__1, "DGESVXX", (ftnlen)7);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(
integer));
do_fio(&c__1, equed, (ftnlen)1);
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&c__6, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[5], (ftnlen)
sizeof(doublereal));
e_wsfe();
} else {
io___79.ciunit = *nout;
s_wsfe(&io___79);
do_fio(&c__1, "DGESVXX", (ftnlen)7);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(
integer));
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&c__6, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[5], (ftnlen)
sizeof(doublereal));
e_wsfe();
}
++nfail;
++nrun;
}
if (result[6] >= *thresh) {
if (nfail == 0 && nerrs == 0) {
aladhd_(nout, path);
}
if (prefac) {
io___80.ciunit = *nout;
s_wsfe(&io___80);
do_fio(&c__1, "DGESVXX", (ftnlen)7);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(
integer));
do_fio(&c__1, equed, (ftnlen)1);
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&c__7, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[6], (ftnlen)
sizeof(doublereal));
e_wsfe();
} else {
io___81.ciunit = *nout;
s_wsfe(&io___81);
do_fio(&c__1, "DGESVXX", (ftnlen)7);
do_fio(&c__1, fact, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(
integer));
do_fio(&c__1, (char *)&imat, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&c__7, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[6], (ftnlen)
sizeof(doublereal));
e_wsfe();
}
++nfail;
++nrun;
}
}
L50:
;
}
L60:
;
}
/* L70: */
}
L80:
;
}
/* L90: */
}
/* Print a summary of the results. */
alasvm_(path, nout, &nfail, &nrun, &nerrs);
/* Test Error Bounds from DGESVXX */
debchvxx_(thresh, path);
return 0;
/* End of DDRVGE */
} /* ddrvge_ */
bool CFitProblem::calculateStatistics(const C_FLOAT64 & factor,
const C_FLOAT64 & resolution)
{
// Set the current values to the solution values.
unsigned C_INT32 i, imax = mSolutionVariables.size();
unsigned C_INT32 j, jmax = mExperimentDependentValues.size();
unsigned C_INT32 l;
mRMS = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD.resize(imax);
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mFisher = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mGradient.resize(imax);
mGradient = std::numeric_limits<C_FLOAT64>::quiet_NaN();
// Recalcuate the best solution.
for (i = 0; i < imax; i++)
(*mUpdateMethods[i])(mSolutionVariables[i]);
mStoreResults = true;
calculate();
// Keep the results
CVector< C_FLOAT64 > DependentValues = mExperimentDependentValues;
if (mSolutionValue == mInfinity)
return false;
// The statistics need to be calculated for the result, i.e., now.
mpExperimentSet->calculateStatistics();
if (jmax)
mRMS = sqrt(mSolutionValue / jmax);
if (jmax > imax)
mSD = sqrt(mSolutionValue / (jmax - imax));
mHaveStatistics = true;
CMatrix< C_FLOAT64 > dyp;
bool CalculateFIM = true;
try
{
dyp.resize(imax, jmax);
}
catch (CCopasiException Exception)
{
CalculateFIM = false;
}
C_FLOAT64 Current;
C_FLOAT64 Delta;
// Calculate the gradient
for (i = 0; i < imax; i++)
{
Current = mSolutionVariables[i];
if (fabs(Current) > resolution)
{
(*mUpdateMethods[i])(Current *(1.0 + factor));
Delta = 1.0 / (Current * factor);
}
else
{
(*mUpdateMethods[i])(resolution);
Delta = 1.0 / resolution;
}
calculate();
mGradient[i] = (mCalculateValue - mSolutionValue) * Delta;
if (CalculateFIM)
for (j = 0; j < jmax; j++)
dyp(i, j) = (mExperimentDependentValues[j] - DependentValues[j]) * Delta;
// Restore the value
(*mUpdateMethods[i])(Current);
}
// This is necessary so that CExperiment::printResult shows the correct data.
calculate();
mStoreResults = false;
if (!CalculateFIM)
{
// Make sure the timer is acurate.
(*mCPUTime.getRefresh())();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 13);
return false;
}
// Construct the fisher information matrix
for (i = 0; i < imax; i++)
for (l = 0; l <= i; l++)
{
C_FLOAT64 & tmp = mFisher(i, l);
tmp = 0.0;
for (j = 0; j < jmax; j++)
tmp += dyp(i, j) * dyp(l, j);
tmp *= 2.0;
if (l != i)
mFisher(l, i) = tmp;
}
mCorrelation = mFisher;
#ifdef XXXX
/* int dgetrf_(integer *m,
* integer *n,
* doublereal *a,
* integer * lda,
* integer *ipiv,
* integer *info)
*
* Purpose
* =======
*
* DGETRF computes an LU factorization of a general M-by-N matrix A
* using partial pivoting with row interchanges.
*
* The factorization has the form
* A = P * L * U
* where P is a permutation matrix, L is lower triangular with unit
* diagonal elements (lower trapezoidal if m > n), and U is upper
* triangular (upper trapezoidal if m < n).
*
* This is the right-looking Level 3 BLAS version of the algorithm.
*
* Arguments
* =========
*
* m (input) INTEGER
* The number of rows of the matrix A. m >= 0.
*
* n (input) INTEGER
* The number of columns of the matrix A. n >= 0.
*
* a (input/output) DOUBLE PRECISION array, dimension (lda,n)
* On entry, the m by n matrix to be factored.
* On exit, the factors L and U from the factorization
* A = P*L*U; the unit diagonal elements of L are not stored.
*
* lda (input) INTEGER
* The leading dimension of the array A. lda >= max(1,m).
*
* ipiv (output) INTEGER array, dimension (min(m,n))
* The pivot indices; for 1 <= i <= min(m,n), row i of the
* matrix was interchanged with row ipiv(i).
*
* info (output) INTEGER
* = 0: successful exit
* < 0: if info = -k, the k-th argument had an illegal value
* > 0: if info = k, U(k,k) is exactly zero. The factorization
* has been completed, but the factor U is exactly
* singular, and division by zero will occur if it is used
* to solve a system of equations.
*/
C_INT info = 0;
C_INT N = imax;
CVector< C_INT > ipiv(imax);
dgetrf_(&N, &N, mCorrelation.array(), &N, ipiv.array(), &info);
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 1, info);
return false;
}
/* dgetri_(integer *n, doublereal *a, integer *lda, integer *ipiv,
* doublereal *work, integer *lwork, integer *info);
*
*
* Purpose
* =======
*
* DGETRI computes the inverse of a matrix using the LU factorization
* computed by DGETRF.
*
* This method inverts U and then computes inv(A) by solving the system
* inv(A)*L = inv(U) for inv(A).
*
* Arguments
* =========
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
* On entry, the factors L and U from the factorization
* A = P*L*U as computed by DGETRF.
* On exit, if INFO = 0, the inverse of the original matrix A.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
* IPIV (input) INTEGER array, dimension (N)
* The pivot indices from DGETRF; for 1<=i<=N, row i of the
* matrix was interchanged with row IPIV(i).
*
* WORK (workspace/output) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
* On exit, if INFO=0, then WORK(1) returns the optimal LWORK.
*
* LWORK (input) INTEGER
* The dimension of the array WORK. LWORK >= max(1,N).
* For optimal performance LWORK >= N*NB, where NB is
* the optimal blocksize returned by ILAENV.
*
* If LWORK = -1, then a workspace query is assumed; the routine
* only calculates the optimal size of the WORK array, returns
* this value as the first entry of the WORK array, and no error
* message related to LWORK is issued by XERBLA.
*
* INFO (output) INTEGER
* = 0: successful exit
* < 0: if INFO = -i, the i-th argument had an illegal value
* > 0: if INFO = i, U(i,i) is exactly zero; the matrix is
* singular and its inverse could not be computed.
*
*/
C_INT lwork = -1; // Instruct dgesvd_ to determine work array size.
CVector< C_FLOAT64 > work;
work.resize(1);
dgetri_(&N, mCorrelation.array(), &N, ipiv.array(), work.array(), &lwork, &info);
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 1, info);
return false;
}
lwork = (C_INT) work[0];
work.resize(lwork);
dgetri_(&N, mCorrelation.array(), &N, ipiv.array(), work.array(), &lwork, &info);
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 1, info);
return false;
}
#endif // XXXX
// The Fisher Information matrix is a symmetric positive semidefinit matrix.
/* int dpotrf_(char *uplo, integer *n, doublereal *a,
* integer *lda, integer *info);
*
*
* Purpose
* =======
*
* DPOTRF computes the Cholesky factorization of a real symmetric
* positive definite matrix A.
*
* The factorization has the form
* A = U**T * U, if UPLO = 'U', or
* A = L * L**T, if UPLO = 'L',
* where U is an upper triangular matrix and L is lower triangular.
*
* This is the block version of the algorithm, calling Level 3 BLAS.
*
* Arguments
* =========
*
* UPLO (input) CHARACTER*1
* = 'U': Upper triangle of A is stored;
* = 'L': Lower triangle of A is stored.
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
* On entry, the symmetric matrix A. If UPLO = 'U', the leading
* N-by-N upper triangular part of A contains the upper
* triangular part of the matrix A, and the strictly lower
* triangular part of A is not referenced. If UPLO = 'L', the
* leading N-by-N lower triangular part of A contains the lower
* triangular part of the matrix A, and the strictly upper
* triangular part of A is not referenced.
*
* On exit, if INFO = 0, the factor U or L from the Cholesky
* factorization A = U**T*U or A = L*L**T.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
* INFO (output) INTEGER
* = 0: successful exit
* < 0: if INFO = -i, the i-th argument had an illegal value
* > 0: if INFO = i, the leading minor of order i is not
* positive definite, and the factorization could not be
* completed.
*
*/
char U = 'U';
C_INT info = 0;
C_INT N = imax;
dpotrf_(&U, &N, mCorrelation.array(), &N, &info);
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 12);
return false;
}
/* int dpotri_(char *uplo, integer *n, doublereal *a,
* integer *lda, integer *info);
*
*
* Purpose
* =======
*
* DPOTRI computes the inverse of a real symmetric positive definite
* matrix A using the Cholesky factorization A = U**T*U or A = L*L**T
* computed by DPOTRF.
*
* Arguments
* =========
*
* UPLO (input) CHARACTER*1
* = 'U': Upper triangle of A is stored;
* = 'L': Lower triangle of A is stored.
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
* On entry, the triangular factor U or L from the Cholesky
* factorization A = U**T*U or A = L*L**T, as computed by
* DPOTRF.
* On exit, the upper or lower triangle of the (symmetric)
* inverse of A, overwriting the input factor U or L.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
* INFO (output) INTEGER
* = 0: successful exit
* < 0: if INFO = -i, the i-th argument had an illegal value
* > 0: if INFO = i, the (i,i) element of the factor U or L is
* zero, and the inverse could not be computed.
*
*/
dpotri_(&U, &N, mCorrelation.array(), &N, &info);
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 1, info);
return false;
}
// Assure that the inverse is completed.
for (i = 0; i < imax; i++)
for (l = 0; l < i; l++)
mCorrelation(l, i) = mCorrelation(i, l);
CVector< C_FLOAT64 > S(imax);
#ifdef XXXX
// We invert the Fisher information matrix with the help of singular
// value decomposition.
/* int dgesvd_(char *jobu, char *jobvt, integer *m, integer *n,
* doublereal *a, integer *lda, doublereal *s, doublereal *u,
* integer *ldu, doublereal *vt, integer *ldvt,
* doublereal *work, integer *lwork, integer *info);
*
*
* Purpose
* =======
*
* DGESVD computes the singular value decomposition (SVD) of a real
* M-by-N matrix A, optionally computing the left and/or right singular
* vectors. The SVD is written
*
* A = U * SIGMA * transpose(V)
*
* where SIGMA is an M-by-N matrix which is zero except for its
* min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and
* V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA
* are the singular values of A; they are real and non-negative, and
* are returned in descending order. The first min(m,n) columns of
* U and V are the left and right singular vectors of A.
*
* Note that the routine returns V**T, not V.
*
* Arguments
* =========
*
* JOBU (input) CHARACTER*1
* Specifies options for computing all or part of the matrix U:
* = 'A': all M columns of U are returned in array U:
* = 'S': the first min(m,n) columns of U (the left singular
* vectors) are returned in the array U;
* = 'O': the first min(m,n) columns of U (the left singular
* vectors) are overwritten on the array A;
* = 'N': no columns of U (no left singular vectors) are
* computed.
*
* JOBVT (input) CHARACTER*1
* Specifies options for computing all or part of the matrix
* V**T:
* = 'A': all N rows of V**T are returned in the array VT;
* = 'S': the first min(m,n) rows of V**T (the right singular
* vectors) are returned in the array VT;
* = 'O': the first min(m,n) rows of V**T (the right singular
* vectors) are overwritten on the array A;
* = 'N': no rows of V**T (no right singular vectors) are
* computed.
*
* JOBVT and JOBU cannot both be 'O'.
*
* M (input) INTEGER
* The number of rows of the input matrix A. M >= 0.
*
* N (input) INTEGER
* The number of columns of the input matrix A. N >= 0.
*
* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
* On entry, the M-by-N matrix A.
* On exit,
* if JOBU = 'O', A is overwritten with the first min(m,n)
* columns of U (the left singular vectors,
* stored columnwise);
* if JOBVT = 'O', A is overwritten with the first min(m,n)
* rows of V**T (the right singular vectors,
* stored rowwise);
* if JOBU .ne. 'O' and JOBVT .ne. 'O', the contents of A
* are destroyed.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,M).
*
* S (output) DOUBLE PRECISION array, dimension (min(M,N))
* The singular values of A, sorted so that S(i) >= S(i+1).
*
* U (output) DOUBLE PRECISION array, dimension (LDU,UCOL)
* (LDU,M) if JOBU = 'A' or (LDU,min(M,N)) if JOBU = 'S'.
* If JOBU = 'A', U contains the M-by-M orthogonal matrix U;
* if JOBU = 'S', U contains the first min(m,n) columns of U
* (the left singular vectors, stored columnwise);
* if JOBU = 'N' or 'O', U is not referenced.
*
* LDU (input) INTEGER
* The leading dimension of the array U. LDU >= 1; if
* JOBU = 'S' or 'A', LDU >= M.
*
* VT (output) DOUBLE PRECISION array, dimension (LDVT,N)
* If JOBVT = 'A', VT contains the N-by-N orthogonal matrix
* V**T;
* if JOBVT = 'S', VT contains the first min(m,n) rows of
* V**T (the right singular vectors, stored rowwise);
* if JOBVT = 'N' or 'O', VT is not referenced.
*
* LDVT (input) INTEGER
* The leading dimension of the array VT. LDVT >= 1; if
* JOBVT = 'A', LDVT >= N; if JOBVT = 'S', LDVT >= min(M,N).
*
* WORK (workspace/output) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
* On exit, if INFO = 0, WORK(1) returns the optimal LWORK;
* if INFO > 0, WORK(2:MIN(M,N)) contains the unconverged
* superdiagonal elements of an upper bidiagonal matrix B
* whose diagonal is in S (not necessarily sorted). B
* satisfies A = U * B * VT, so it has the same singular values
* as A, and singular vectors related by U and VT.
*
* LWORK (input) INTEGER
* The dimension of the array WORK.
* LWORK >= MAX(1,3*MIN(M,N)+MAX(M,N),5*MIN(M,N)).
* For good performance, LWORK should generally be larger.
*
* If LWORK = -1, then a workspace query is assumed; the routine
* only calculates the optimal size of the WORK array, returns
* this value as the first entry of the WORK array, and no error
* message related to LWORK is issued by XERBLA.
*
* INFO (output) INTEGER
* = 0: successful exit.
* < 0: if INFO = -i, the i-th argument had an illegal value.
* > 0: if DBDSQR did not converge, INFO specifies how many
* superdiagonals of an intermediate bidiagonal form B
* did not converge to zero. See the description of WORK
* above for details.
*
*/
char job = 'A';
C_INT info = 0;
C_INT N = imax;
CVector< C_FLOAT64 > S(imax);
CMatrix< C_FLOAT64 > U(imax, imax);
CMatrix< C_FLOAT64 > VT(imax, imax);
C_INT lwork = -1; // Instruct dgesvd_ to determine work array size.
CVector< C_FLOAT64 > work;
work.resize(1);
dgesvd_(&job, &job, &N, &N, mCorrelation.array(), &N, S.array(), U.array(),
&N, VT.array(), &N, work.array(), &lwork, &info);
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 1, info);
return false;
}
lwork = (C_INT) work[0];
work.resize(lwork);
// This actually calculates the SVD of mCorrelation^T, since dgesvd uses
// fortran notation, i.e., mCorrelation = V^T * B^T * U
dgesvd_(&job, &job, &N, &N, mCorrelation.array(), &N, S.array(), U.array(),
&N, VT.array(), &N, work.array(), &lwork, &info);
// Even if info is not zero we are still able to invert
if (info)
{
mCorrelation = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mParameterSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 1, info);
return false;
}
// Now we invert the Fisher Information Matrix. Please note,
// that we are calculating a pseudo inverse in the case that one or
// more singular values are zero.
mCorrelation = 0.0;
for (i = 0; i < imax; i++)
if (S[i] == 0.0)
mCorrelation(i, i) = 0.0;
else
mCorrelation(i, i) = 1.0 / S[i];
CMatrix< C_FLOAT64 > Tmp(imax, imax);
char opN = 'N';
C_FLOAT64 Alpha = 1.0;
C_FLOAT64 Beta = 0.0;
dgemm_(&opN, &opN, &N, &N, &N, &Alpha, U.array(), &N,
mCorrelation.array(), &N, &Beta, Tmp.array(), &N);
dgemm_(&opN, &opN, &N, &N, &N, &Alpha, Tmp.array(), &N,
VT.array(), &N, &Beta, mCorrelation.array(), &N);
#endif // XXXX
// rescale the lower bound of the covariant matrix to have unit diagonal
for (i = 0; i < imax; i++)
{
C_FLOAT64 & tmp = S[i];
if (mCorrelation(i, i) > 0.0)
{
tmp = 1.0 / sqrt(mCorrelation(i, i));
mParameterSD[i] = mSD / tmp;
}
else if (mCorrelation(i, i) < 0.0)
{
tmp = 1.0 / sqrt(- mCorrelation(i, i));
mParameterSD[i] = mSD / tmp;
}
else
{
mParameterSD[i] = mInfinity;
tmp = 1.0;
mCorrelation(i, i) = 1.0;
}
}
for (i = 0; i < imax; i++)
for (l = 0; l < imax; l++)
mCorrelation(i, l) *= S[i] * S[l];
// Make sure the timer is acurate.
(*mCPUTime.getRefresh())();
return true;
}
/* Subroutine */ int derrge_(char *path, integer *nunit)
{
/* Builtin functions */
integer s_wsle(cilist *), e_wsle(void);
/* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
/* Local variables */
doublereal a[16] /* was [4][4] */, b[4];
integer i__, j;
doublereal w[12], x[4];
char c2[2];
doublereal r1[4], r2[4], af[16] /* was [4][4] */;
integer ip[4], iw[4], info;
doublereal anrm, ccond, rcond;
extern /* Subroutine */ int dgbtf2_(integer *, integer *, integer *,
integer *, doublereal *, integer *, integer *, integer *),
dgetf2_(integer *, integer *, doublereal *, integer *, integer *,
integer *), dgbcon_(char *, integer *, integer *, integer *,
doublereal *, integer *, integer *, doublereal *, doublereal *,
doublereal *, integer *, integer *), dgecon_(char *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
doublereal *, integer *, integer *), alaesm_(char *,
logical *, integer *), dgbequ_(integer *, integer *,
integer *, integer *, doublereal *, integer *, doublereal *,
doublereal *, doublereal *, doublereal *, doublereal *, integer *)
, dgbrfs_(char *, integer *, integer *, integer *, integer *,
doublereal *, integer *, doublereal *, integer *, integer *,
doublereal *, integer *, doublereal *, integer *, doublereal *,
doublereal *, doublereal *, integer *, integer *),
dgbtrf_(integer *, integer *, integer *, integer *, doublereal *,
integer *, integer *, integer *), dgeequ_(integer *, integer *,
doublereal *, integer *, doublereal *, doublereal *, doublereal *,
doublereal *, doublereal *, integer *), dgerfs_(char *, integer *
, integer *, doublereal *, integer *, doublereal *, integer *,
integer *, doublereal *, integer *, doublereal *, integer *,
doublereal *, doublereal *, doublereal *, integer *, integer *), dgetrf_(integer *, integer *, doublereal *, integer *,
integer *, integer *), dgetri_(integer *, doublereal *, integer *,
integer *, doublereal *, integer *, integer *);
extern logical lsamen_(integer *, char *, char *);
extern /* Subroutine */ int chkxer_(char *, integer *, integer *, logical
*, logical *), dgbtrs_(char *, integer *, integer *,
integer *, integer *, doublereal *, integer *, integer *,
doublereal *, integer *, integer *), dgetrs_(char *,
integer *, integer *, doublereal *, integer *, integer *,
doublereal *, integer *, integer *);
/* Fortran I/O blocks */
static cilist io___1 = { 0, 0, 0, 0, 0 };
/* -- LAPACK test routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* DERRGE tests the error exits for the DOUBLE PRECISION routines */
/* for general matrices. */
/* Arguments */
/* ========= */
/* PATH (input) CHARACTER*3 */
/* The LAPACK path name for the routines to be tested. */
/* NUNIT (input) INTEGER */
/* The unit number for output. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Scalars in Common .. */
/* .. */
/* .. Common blocks .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
infoc_1.nout = *nunit;
io___1.ciunit = infoc_1.nout;
s_wsle(&io___1);
e_wsle();
s_copy(c2, path + 1, (ftnlen)2, (ftnlen)2);
/* Set the variables to innocuous values. */
for (j = 1; j <= 4; ++j) {
for (i__ = 1; i__ <= 4; ++i__) {
a[i__ + (j << 2) - 5] = 1. / (doublereal) (i__ + j);
af[i__ + (j << 2) - 5] = 1. / (doublereal) (i__ + j);
/* L10: */
}
b[j - 1] = 0.;
r1[j - 1] = 0.;
r2[j - 1] = 0.;
w[j - 1] = 0.;
x[j - 1] = 0.;
ip[j - 1] = j;
iw[j - 1] = j;
/* L20: */
}
infoc_1.ok = TRUE_;
if (lsamen_(&c__2, c2, "GE")) {
/* Test error exits of the routines that use the LU decomposition */
/* of a general matrix. */
/* DGETRF */
s_copy(srnamc_1.srnamt, "DGETRF", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgetrf_(&c_n1, &c__0, a, &c__1, ip, &info);
chkxer_("DGETRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgetrf_(&c__0, &c_n1, a, &c__1, ip, &info);
chkxer_("DGETRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dgetrf_(&c__2, &c__1, a, &c__1, ip, &info);
chkxer_("DGETRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DGETF2 */
s_copy(srnamc_1.srnamt, "DGETF2", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgetf2_(&c_n1, &c__0, a, &c__1, ip, &info);
chkxer_("DGETF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgetf2_(&c__0, &c_n1, a, &c__1, ip, &info);
chkxer_("DGETF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dgetf2_(&c__2, &c__1, a, &c__1, ip, &info);
chkxer_("DGETF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DGETRI */
s_copy(srnamc_1.srnamt, "DGETRI", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgetri_(&c_n1, a, &c__1, ip, w, &c__12, &info);
chkxer_("DGETRI", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dgetri_(&c__2, a, &c__1, ip, w, &c__12, &info);
chkxer_("DGETRI", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DGETRS */
s_copy(srnamc_1.srnamt, "DGETRS", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgetrs_("/", &c__0, &c__0, a, &c__1, ip, b, &c__1, &info);
chkxer_("DGETRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgetrs_("N", &c_n1, &c__0, a, &c__1, ip, b, &c__1, &info);
chkxer_("DGETRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dgetrs_("N", &c__0, &c_n1, a, &c__1, ip, b, &c__1, &info);
chkxer_("DGETRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
dgetrs_("N", &c__2, &c__1, a, &c__1, ip, b, &c__2, &info);
chkxer_("DGETRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 8;
dgetrs_("N", &c__2, &c__1, a, &c__2, ip, b, &c__1, &info);
chkxer_("DGETRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DGERFS */
s_copy(srnamc_1.srnamt, "DGERFS", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgerfs_("/", &c__0, &c__0, a, &c__1, af, &c__1, ip, b, &c__1, x, &
c__1, r1, r2, w, iw, &info);
chkxer_("DGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgerfs_("N", &c_n1, &c__0, a, &c__1, af, &c__1, ip, b, &c__1, x, &
c__1, r1, r2, w, iw, &info);
chkxer_("DGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dgerfs_("N", &c__0, &c_n1, a, &c__1, af, &c__1, ip, b, &c__1, x, &
c__1, r1, r2, w, iw, &info);
chkxer_("DGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
dgerfs_("N", &c__2, &c__1, a, &c__1, af, &c__2, ip, b, &c__2, x, &
c__2, r1, r2, w, iw, &info);
chkxer_("DGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 7;
dgerfs_("N", &c__2, &c__1, a, &c__2, af, &c__1, ip, b, &c__2, x, &
c__2, r1, r2, w, iw, &info);
chkxer_("DGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 10;
dgerfs_("N", &c__2, &c__1, a, &c__2, af, &c__2, ip, b, &c__1, x, &
c__2, r1, r2, w, iw, &info);
chkxer_("DGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 12;
dgerfs_("N", &c__2, &c__1, a, &c__2, af, &c__2, ip, b, &c__2, x, &
c__1, r1, r2, w, iw, &info);
chkxer_("DGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DGECON */
s_copy(srnamc_1.srnamt, "DGECON", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgecon_("/", &c__0, a, &c__1, &anrm, &rcond, w, iw, &info);
chkxer_("DGECON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgecon_("1", &c_n1, a, &c__1, &anrm, &rcond, w, iw, &info);
chkxer_("DGECON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dgecon_("1", &c__2, a, &c__1, &anrm, &rcond, w, iw, &info);
chkxer_("DGECON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DGEEQU */
s_copy(srnamc_1.srnamt, "DGEEQU", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgeequ_(&c_n1, &c__0, a, &c__1, r1, r2, &rcond, &ccond, &anrm, &info);
chkxer_("DGEEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgeequ_(&c__0, &c_n1, a, &c__1, r1, r2, &rcond, &ccond, &anrm, &info);
chkxer_("DGEEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dgeequ_(&c__2, &c__2, a, &c__1, r1, r2, &rcond, &ccond, &anrm, &info);
chkxer_("DGEEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
} else if (lsamen_(&c__2, c2, "GB")) {
/* Test error exits of the routines that use the LU decomposition */
/* of a general band matrix. */
/* DGBTRF */
s_copy(srnamc_1.srnamt, "DGBTRF", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgbtrf_(&c_n1, &c__0, &c__0, &c__0, a, &c__1, ip, &info);
chkxer_("DGBTRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgbtrf_(&c__0, &c_n1, &c__0, &c__0, a, &c__1, ip, &info);
chkxer_("DGBTRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dgbtrf_(&c__1, &c__1, &c_n1, &c__0, a, &c__1, ip, &info);
chkxer_("DGBTRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dgbtrf_(&c__1, &c__1, &c__0, &c_n1, a, &c__1, ip, &info);
chkxer_("DGBTRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 6;
dgbtrf_(&c__2, &c__2, &c__1, &c__1, a, &c__3, ip, &info);
chkxer_("DGBTRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DGBTF2 */
s_copy(srnamc_1.srnamt, "DGBTF2", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgbtf2_(&c_n1, &c__0, &c__0, &c__0, a, &c__1, ip, &info);
chkxer_("DGBTF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgbtf2_(&c__0, &c_n1, &c__0, &c__0, a, &c__1, ip, &info);
chkxer_("DGBTF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dgbtf2_(&c__1, &c__1, &c_n1, &c__0, a, &c__1, ip, &info);
chkxer_("DGBTF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dgbtf2_(&c__1, &c__1, &c__0, &c_n1, a, &c__1, ip, &info);
chkxer_("DGBTF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 6;
dgbtf2_(&c__2, &c__2, &c__1, &c__1, a, &c__3, ip, &info);
chkxer_("DGBTF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DGBTRS */
s_copy(srnamc_1.srnamt, "DGBTRS", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgbtrs_("/", &c__0, &c__0, &c__0, &c__1, a, &c__1, ip, b, &c__1, &
info);
chkxer_("DGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgbtrs_("N", &c_n1, &c__0, &c__0, &c__1, a, &c__1, ip, b, &c__1, &
info);
chkxer_("DGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dgbtrs_("N", &c__1, &c_n1, &c__0, &c__1, a, &c__1, ip, b, &c__1, &
info);
chkxer_("DGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dgbtrs_("N", &c__1, &c__0, &c_n1, &c__1, a, &c__1, ip, b, &c__1, &
info);
chkxer_("DGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
dgbtrs_("N", &c__1, &c__0, &c__0, &c_n1, a, &c__1, ip, b, &c__1, &
info);
chkxer_("DGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 7;
dgbtrs_("N", &c__2, &c__1, &c__1, &c__1, a, &c__3, ip, b, &c__2, &
info);
chkxer_("DGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 10;
dgbtrs_("N", &c__2, &c__0, &c__0, &c__1, a, &c__1, ip, b, &c__1, &
info);
chkxer_("DGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DGBRFS */
s_copy(srnamc_1.srnamt, "DGBRFS", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgbrfs_("/", &c__0, &c__0, &c__0, &c__0, a, &c__1, af, &c__1, ip, b, &
c__1, x, &c__1, r1, r2, w, iw, &info);
chkxer_("DGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgbrfs_("N", &c_n1, &c__0, &c__0, &c__0, a, &c__1, af, &c__1, ip, b, &
c__1, x, &c__1, r1, r2, w, iw, &info);
chkxer_("DGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dgbrfs_("N", &c__1, &c_n1, &c__0, &c__0, a, &c__1, af, &c__1, ip, b, &
c__1, x, &c__1, r1, r2, w, iw, &info);
chkxer_("DGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dgbrfs_("N", &c__1, &c__0, &c_n1, &c__0, a, &c__1, af, &c__1, ip, b, &
c__1, x, &c__1, r1, r2, w, iw, &info);
chkxer_("DGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
dgbrfs_("N", &c__1, &c__0, &c__0, &c_n1, a, &c__1, af, &c__1, ip, b, &
c__1, x, &c__1, r1, r2, w, iw, &info);
chkxer_("DGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 7;
dgbrfs_("N", &c__2, &c__1, &c__1, &c__1, a, &c__2, af, &c__4, ip, b, &
c__2, x, &c__2, r1, r2, w, iw, &info);
chkxer_("DGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 9;
dgbrfs_("N", &c__2, &c__1, &c__1, &c__1, a, &c__3, af, &c__3, ip, b, &
c__2, x, &c__2, r1, r2, w, iw, &info);
chkxer_("DGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 12;
dgbrfs_("N", &c__2, &c__0, &c__0, &c__1, a, &c__1, af, &c__1, ip, b, &
c__1, x, &c__2, r1, r2, w, iw, &info);
chkxer_("DGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 14;
dgbrfs_("N", &c__2, &c__0, &c__0, &c__1, a, &c__1, af, &c__1, ip, b, &
c__2, x, &c__1, r1, r2, w, iw, &info);
chkxer_("DGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DGBCON */
s_copy(srnamc_1.srnamt, "DGBCON", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgbcon_("/", &c__0, &c__0, &c__0, a, &c__1, ip, &anrm, &rcond, w, iw,
&info);
chkxer_("DGBCON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgbcon_("1", &c_n1, &c__0, &c__0, a, &c__1, ip, &anrm, &rcond, w, iw,
&info);
chkxer_("DGBCON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dgbcon_("1", &c__1, &c_n1, &c__0, a, &c__1, ip, &anrm, &rcond, w, iw,
&info);
chkxer_("DGBCON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dgbcon_("1", &c__1, &c__0, &c_n1, a, &c__1, ip, &anrm, &rcond, w, iw,
&info);
chkxer_("DGBCON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 6;
dgbcon_("1", &c__2, &c__1, &c__1, a, &c__3, ip, &anrm, &rcond, w, iw,
&info);
chkxer_("DGBCON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DGBEQU */
s_copy(srnamc_1.srnamt, "DGBEQU", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgbequ_(&c_n1, &c__0, &c__0, &c__0, a, &c__1, r1, r2, &rcond, &ccond,
&anrm, &info);
chkxer_("DGBEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgbequ_(&c__0, &c_n1, &c__0, &c__0, a, &c__1, r1, r2, &rcond, &ccond,
&anrm, &info);
chkxer_("DGBEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dgbequ_(&c__1, &c__1, &c_n1, &c__0, a, &c__1, r1, r2, &rcond, &ccond,
&anrm, &info);
chkxer_("DGBEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dgbequ_(&c__1, &c__1, &c__0, &c_n1, a, &c__1, r1, r2, &rcond, &ccond,
&anrm, &info);
chkxer_("DGBEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 6;
dgbequ_(&c__2, &c__2, &c__1, &c__1, a, &c__2, r1, r2, &rcond, &ccond,
&anrm, &info);
chkxer_("DGBEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
}
/* Print a summary line. */
alaesm_(path, &infoc_1.ok, &infoc_1.nout);
return 0;
/* End of DERRGE */
} /* derrge_ */
int matinv(int sizeA,double **A,double (*determinant))
{
int i, j , *pivot,N=sizeA*sizeA,size=sizeA;
double *AT,*work; /* AT=transpose vectorized matrix (to accomodate
Fortran)
work=workspace vector */
int INFO,ipiv=1;
MAKE_VECTOR(AT,size*size);
MAKE_VECTOR(work,size*size);
MAKE_VECTOR(pivot,size);
for (i=0; i<size; i++) /* to call a Fortran routine from C */
{ /* have to transform the matrix */
for(j=0; j<size; j++) AT[j+size*i]=A[j][i];
}
dgetrf_(&size,&size,AT,&size,pivot,&INFO);
/* LAPACK routine DGETRF computes an LU factorization of a general
m x n matrix A using partial pivoting with row interchanges. The
factorization has the form A = P * L * U where P is a permutation
matrix, L is lower triangular with unit diagonal elements (lower
trapezoidal if m > n), and U is upper triangular (upper trapezoidal
if m < n). Note that because of the permutation, the determinant
needs to be multiplied by -1 for every interchange that has occurred.
Parameters in the order as they appear in the function call:
number of rows of the matrix A, number of columns of the
matrix A, the matrix A, the leading dimension of A, the
array that records pivoting, and the flag for the
result. On exit, A contains the factors of L and U (with the
diagonals of L not stored).*/
if (INFO==0) {
for(i=0; i<size; i++) {
if (i!=(pivot[i]-1)) ipiv*=-1; /* PIVOT assumes indices are from 1
through N*/
}
(*determinant)=(double)ipiv;
for (i=0; i<size; i++) {
(*determinant)*=AT[i+i*size];
}
dgetri_(&size,AT,&size,pivot,work,&N,&INFO);
/* LAPACK routine DGETRI computes the inverse of a matrix A
using the output of DGETRF. This method inverts U and then
computes A^(-1) by solving A^(-1)L = U^(-1) for A^(-1).
parameters in the order as they appear in the function call:
order of the matrix A, the matrix A, the leading dimension of
A, the array that records pivoting, workspace, the
dimension of the workspace array, and the flag for the
result. On exit, A contains the inverted matrix. */
if (INFO!=0) {
/* Marked by Wei-Chen Chen on 2009/06/07.
* printf("Problem in matinv: dgetri error %d\n",INFO);
*/
}
}
else {
/* Marked by Wei-Chen Chen on 2009/06/07.
* printf("Problem in matinv: dgetrf error %d\n",INFO);
*/
}
for (i=0; i<size; i++) /* to call a Fortran routine from C */
{ /* have to transform the matrix */
for(j=0; j<size; j++) {
A[j][i]=AT[j+size*i];
}
}
FREE_VECTOR(AT);
FREE_VECTOR(pivot);
FREE_VECTOR(work);
return 0;
}
