double torsion(double **d)
/* get torsion angle a-b-c-d in degrees */
{
double ang_deg, dij;
double **vec3;
long i, j;
vec3 = dmatrix(1, 3, 1, 3);
for (i = 1; i <= 3; i++) {
for (j = 1; j <= 3; j++)
if (i == 1)
vec3[i][j] = d[i][j] - d[i + 1][j]; /* b-->a */
else
vec3[i][j] = d[i + 1][j] - d[i][j];
dij = veclen(vec3[i]);
if (dij > BOND_UPPER_LIMIT) {
free_dmatrix(vec3, 1, 3, 1, 3);
return EMPTY_NUMBER;
}
}
ang_deg = vec_ang(vec3[1], vec3[3], vec3[2]);
free_dmatrix(vec3, 1, 3, 1, 3);
return ang_deg;
}
int sa_lu_psinvert(double **out, double **in, int m, int n) {
int rv = 0;
double **tr;
double **sq;
tr = dmatrix(0, n-1, 0, m-1);
matrix_trans(tr, in, m, n);
if (m > n) {
sq = dmatrix(0, n-1, 0, n-1);
if ((rv = matrix_mult(sq, n, n, tr, n, m, in, m, n)) == 0) {
if ((rv = sa_lu_invert(sq, n)) == 0) {
rv = matrix_mult(out, n, m, sq, n, n, tr, n, m);
}
}
free_dmatrix(sq, 0, n-1, 0, n-1);
} else {
sq = dmatrix(0, m-1, 0, m-1);
if ((rv = matrix_mult(sq, m, m, in, m, n, tr, n, m)) == 0) {
if ((rv = sa_lu_invert(sq, m)) == 0) {
rv = matrix_mult(out, n, m, tr, n, m, sq, m, m);
}
}
free_dmatrix(sq, 0, m-1, 0, m-1);
}
free_dmatrix(tr, 0, n-1, 0, m-1);
return rv;
}
int main(void)
{
int i,j,midl=JMAX/2+1;
double **f,**u;
f=dmatrix(1,JMAX,1,JMAX);
u=dmatrix(1,JMAX,1,JMAX);
for (i=1;i<=JMAX;i++)
for (j=1;j<=JMAX;j++)
u[i][j]=0.0;
u[midl][midl]=2.0;
mgfas(u,JMAX,2);
printf("MGFAS solution:\n");
for (i=1;i<=JMAX;i+=NSTEP) {
for (j=1;j<=JMAX;j+=NSTEP) printf("%8.4f",u[i][j]);
printf("\n");
}
printf("\n Test that solution satisfies difference equations:\n");
for (i=NSTEP+1;i<JMAX;i+=NSTEP) {
for (j=NSTEP+1;j<JMAX;j+=NSTEP)
f[i][j]=u[i+1][j]+u[i-1][j]+u[i][j+1]+u[i][j-1]-
4.0*u[i][j]+u[i][j]*u[i][j]/((JMAX-1)*(JMAX-1));
printf("%7s"," ");
for (j=NSTEP+1;j<JMAX;j+=NSTEP) printf("%8.4f",f[i][j]*(JMAX-1)*(JMAX-1));
printf("\n");
}
free_dmatrix(u,1,JMAX,1,JMAX);
free_dmatrix(f,1,JMAX,1,JMAX);
return 0;
}
int rd_coords( FILE *istream, double ***ptr_pcoords, int *ncoords )
{
int n,i,status=0;
double **p_coords;
char line[MAXLENGTH],**p_parse;
p_coords = dmatrix(2,MAX_N_COORDS);
n=0;
while (fgets( line, MAXLENGTH, istream ) != NULL) {
if (n>=MAX_N_COORDS) {
fprintf(stderr,"ERROR: Too many sources. Max=%d\n",MAX_N_COORDS);
free_dmatrix(p_coords);
return(ERRNO_INPUT_ERROR);
}
p_parse = svector(2,MAXLENGTH);
splitstr(line,p_parse,SPACES);
*(*(p_coords+0)+n) = atof(p_parse[0]);
*(*(p_coords+1)+n) = atof(p_parse[1]);
n++;
free_svector(p_parse);
}
*ncoords = n;
*ptr_pcoords = dmatrix(2,*ncoords);
for (i=0;i<*ncoords;i++) {
*(*(*ptr_pcoords + 0) + i) = *(*(p_coords+0)+i);
*(*(*ptr_pcoords + 1) + i) = *(*(p_coords+1)+i);
}
free_dmatrix(p_coords);
return(status);
}
int free_map (Map *map) {
if ( !map) return 0;
free (map->x2y);
free (map->y2x);
map->x2y_size = 0;
map->y2x_size = 0;
if (map->x2y_residue_level)
free (map->x2y_residue_level);
if (map->y2x_residue_level)
free (map->y2x_residue_level);
map->x2y_residue_l_size = 0;
map->y2x_residue_l_size = 0;
free_dmatrix (map->cosine);
free_dmatrix (map->sse_pair_score);
if (map->submatch_best) {
free (map->submatch_best );
}
return 0;
}
int HJM_SimPath_Yield(FTYPE **ppdHJMPath, //Matrix that stores generated HJM path (Output)
int iN, //Number of time-steps
int iFactors, //Number of factors in the HJM framework
FTYPE dYears, //Number of years
FTYPE *pdYield, //Input yield curve (at t=0) for dYears (iN time steps)
FTYPE **ppdFactors, //Matrix of Factor Volatilies
long *lRndSeed)
{
//This function returns a single generated HJM Path for the given inputs
int iSuccess = 0; //return variable
FTYPE *pdForward; //Vector that will store forward curve computed from given yield curve
FTYPE **ppdDrifts; //Matrix that will store drifts for different maturities for each factor
FTYPE *pdTotalDrift; //Vector that stores total drift for each maturity
pdForward = dvector(0, iN-1);
ppdDrifts = dmatrix(0, iFactors-1, 0, iN-2);
pdTotalDrift = dvector(0, iN-2);
//generating forward curve at t=0 from supplied yield curve
iSuccess = HJM_Yield_to_Forward(pdForward, iN, pdYield);
if (iSuccess!=1)
{
free_dvector(pdForward, 0, iN-1);
free_dmatrix(ppdDrifts, 0, iFactors-1, 0, iN-2);
free_dvector(pdTotalDrift, 0, iN-1);
return iSuccess;
}
//computation of drifts from factor volatilities
iSuccess = HJM_Drifts(pdTotalDrift, ppdDrifts, iN, iFactors, dYears, ppdFactors);
if (iSuccess!=1)
{
free_dvector(pdForward, 0, iN-1);
free_dmatrix(ppdDrifts, 0, iFactors-1, 0, iN-2);
free_dvector(pdTotalDrift, 0, iN-1);
return iSuccess;
}
//generating HJM Path
iSuccess = HJM_SimPath_Forward(ppdHJMPath, iN, iFactors, dYears, pdForward, pdTotalDrift,ppdFactors, lRndSeed);
if (iSuccess!=1)
{
free_dvector(pdForward, 0, iN-1);
free_dmatrix(ppdDrifts, 0, iFactors-1, 0, iN-2);
free_dvector(pdTotalDrift, 0, iN-1);
return iSuccess;
}
free_dvector(pdForward, 0, iN-1);
free_dmatrix(ppdDrifts, 0, iFactors-1, 0, iN-2);
free_dvector(pdTotalDrift, 0, iN-1);
iSuccess = 1;
return iSuccess;
}
// ****************************************************************************
// Compute the (thin) singular value decomposition of a matrix A (size: rows x cols).
// I.e. it finds U, D and V such that:
// U.D.transpose(V) = A
// V.transpose(V) = I
// U.transpose(U) = I (if rows = cols)
// The matricies U, D, V must already be allocated prior to calling this function.
// Their required sizes are: U (rows x cols), D (cols x cols), V(cols x cols)
// The contents of A are not changed.
// ****************************************************************************
void svd(double *A, long int rows, long int cols, double *U, double *D, double *V)
{
double **a, **v, *d;
long int r, c;
// Allocate the data structures which the core function expects
a=dmatrix(1, rows, 1, cols);
v=dmatrix(1, cols, 1, cols);
d=dvector(1, cols);
// Copy the input data into the core data structures
for (r=1; r<=rows; r++)
{
for (c=1; c<=cols; c++)
{
a[r][c]=A[(r-1)*cols+(c-1)];
}
}
// Call the core function
dsvdcmp(a, rows, cols, d, v);
// Copy the output data into the output data structures
for (r=1; r<=rows; r++)
{
for (c=1; c<=cols; c++)
{
U[(r-1)*cols+(c-1)]=a[r][c];
}
}
for (r=1; r<=cols; r++)
{
for (c=1; c<=cols; c++)
{
V[(r-1)*cols+(c-1)]=v[r][c];
}
}
for (r=1; r<=cols; r++)
{
for (c=1; c<=cols; c++)
{
if (r==c) D[(r-1)*cols+(c-1)]=d[c];
else D[(r-1)*cols+(c-1)]=0.0;
}
}
// Free the core data structures
free_dvector(d, 1, cols);
free_dmatrix(v, 1, cols, 1, cols);
free_dmatrix(a, 1, rows, 1, cols);
return;
}
int
abg_to_xyz(int argc, char *argv[])
{
PBASIS p;
XVBASIS xv;
double **covar_abg, **covar_xyz, **derivs;
int i,j;
/* if (argc!=1) print_help(abg_to_xyz_help); */
covar_abg = dmatrix(1,6,1,6);
covar_xyz = dmatrix(1,6,1,6);
derivs = dmatrix(1,6,1,6);
/* echo the command line to output */
printf("#");
for (i=0; i<argc; i++) printf(" %s",argv[i]);
{
#include <time.h>
time_t timettt;
time(&timettt);
/* note that ctime returns string with newline at end */
printf("\n#---%s",ctime(&timettt));
}
if (read_abg(NULL,&p,covar_abg)) {
fprintf(stderr, "Error in input alpha/beta/gamma file\n");
exit(1);
}
/* Transform the orbit basis and get the deriv. matrix */
pbasis_to_bary(&p, &xv, derivs);
/* Map the covariance matrix to new basis */
covar_map(covar_abg, derivs, covar_xyz,6,6);
/* Print out the results, with comments */
printf("# x y z "
"vx vy vz\n");
printf("%12.8f %12.8f %12.8f %12.8f %12.8f %12.8f\n",
xv.x, xv.y, xv.z, xv.xdot, xv.ydot, xv.zdot);
printf("# covariance matrix:\n");
print_matrix(stdout,covar_xyz,6,6);
printf("# Position is for JD:\n%.5f\n",jd0);
free_dmatrix(covar_abg,1,6,1,6);
free_dmatrix(covar_xyz,1,6,1,6);
free_dmatrix(derivs,1,6,1,6);
exit(0);
}
main()
{
/* test program for above utility routines */
double **a, **b, **c, **bT;
double *x, *y, *z;
FILE *infile, *outfile;
int a_rows, a_cols, b_rows, b_cols, errors, xn, yn;
infile = fopen("mat.in", "r");
outfile = fopen("mat.dat", "w");
a = dReadMatrix( infile, &a_rows, &a_cols, &errors);
b = dReadMatrix( infile, &b_rows, &b_cols, &errors);
x = dReadVector( infile, &xn, &errors);
y = dReadVector( infile, &yn, &errors);
getchar();
dmdump( stdout, "Matrix A", a, a_rows, a_cols, "%8.2lf");
dmdump( stdout, "Matrix B", b, b_rows, b_cols, "%8.2lf");
dvdump( stdout, "Vector x", x, xn, "%8.2lf");
dvdump( stdout, "Vector y", y, yn, "%8.2lf");
z = dvector( 1, xn );
dvadd( x, xn, y, z );
dvdump( stdout, "x + y", z, xn, "%8.2lf");
dvsub( x, xn, y, z );
dvdump( stdout, "x - y", z, xn, "%8.2lf");
dvsmy( x, xn, 2.0, z );
dvdump( stdout, "2x", z, xn, "%8.2lf");
printf("Magnitude of 2x: %7.2lf\n", dvmag( z, xn ));
printf("dot product x.y: %7.2lf\n", dvdot( x, xn, y));
dmvmult( a, a_rows, a_cols, x, xn, z );
dvdump( stdout, "Ax", z, xn, "%8.2lf");
c = dmatrix( 1, a_rows, 1, b_cols );
bT = dmatrix( 1, b_cols, 1, b_rows );
dmtranspose( b, b_rows, b_cols, bT);
dmdump( stdout, "Matrix B (transposed)", bT, b_cols, b_rows, "%8.2lf");
dmmult( a, a_rows, a_cols, bT, b_cols, b_rows, c);
dmdump( stdout, "Matrix AB", c, a_rows, b_rows, "%8.2lf");
/* dmfillUT( a, a_rows, a_cols );
dmdump( stdout, "Symmetrified matrix A", a, a_rows, a_cols, "%8.2lf"); */
free_dmatrix( a, 1, a_rows, 1, a_cols);
free_dmatrix( b, 1, b_rows, 1, b_cols);
free_dmatrix( c, 1, a_rows, 1, b_cols);
free_dvector( x, 1, xn );
free_dvector( y, 1, yn );
}
int
test(
int n, /* Dimensionality */
double **a, /* A[][] input matrix, returns LU decimposition of A */
double *b /* B[] input array, returns solution X[] */
) {
int i, j;
double rip; /* Row interchange parity */
int *pivx;
int rv = 0;
double **sa; /* save input matrix values */
double *sb; /* save input vector values */
pivx = ivector(0, n-1);
sa = dmatrix(0, n-1, 0, n-1);
sb = dvector(0, n-1);
/* Copy input matrix and vector values */
for (i = 0; i < n; i++) {
sb[i] = b[i];
for (j = 0; j < n; j++)
sa[i][j] = a[i][j];
}
if (lu_decomp(a, n, pivx, &rip)) {
free_dvector(sb, 0, n-1);
free_dmatrix(sa, 0, n-1, 0, n-1);
free_ivector(pivx, 0, n-1);
return 1;
}
lu_backsub(a, n, pivx, b);
/* Check that the solution is correct */
for (i = 0; i < n; i++) {
double sum, temp;
sum = 0.0;
for (j = 0; j < n; j++)
sum += sa[i][j] * b[j];
//printf("~~ check %d = %f, against %f\n",i,sum,sb[i]);
temp = fabs(sum - sb[i]);
if (temp > 1e-6)
rv = 2;
}
free_dvector(sb, 0, n-1);
free_dmatrix(sa, 0, n-1, 0, n-1);
free_ivector(pivx, 0, n-1);
return rv;
}
void
free_dmatrix_3d(doublereal ***m)
{
if (m==NULL) return;
free_dmatrix(m[0]);
free( (char *) (m) );
}
double determinant(double *A[],int n)
/*
compute determinant of a n x n matrix A.
Return value: the determinant
*/
{
double d, **tmpA;
int i,j,*indx;
tmpA=dmatrix(n,n);
for (j=0;j<n;j++)
for (i=0;i<n;i++)
tmpA[j][i]=A[j][i];
indx=ivector(n);
ludcmp(tmpA,n,indx,&d);
for (j=0;j<n;j++)
d *= tmpA[j][j];
free_ivector(indx);
free_dmatrix(tmpA,n,n);
return(d);
}
NUMERICS_EXPORT BOOL inverse(double **a, int n)
{
double d;
int i, j;
BOOL ret = FALSE;
double** ai = dmatrix(0, n - 1, 0, n - 1);
double* col = dvector(0, n - 1);
int* indx = ivector(0, n - 1);
if(ludcmp(a, n, indx, &d)){
for(j = 0; j < n; j++){
for(i = 0; i < n; i++) col[i] = 0.0;
col[j] = 1.0;
lubksb(a, n, indx, col);
for(i = 0; i < n; i++) ai[i][j] = col[i];
}
for(i = 0; i < n; i++){
for(j = 0; j < n; j++){
a[i][j] = ai[i][j];
}
}
ret = TRUE;
}
free_dmatrix(ai, 0, n - 1, 0);
free_dvector(col, 0);
free_ivector(indx, 0);
return ret;
}
// function to reflect triangular data in SurfXpts about y axis
static void Reflect(int fid)
{
register int i,j,cnt;
double **tmp;
tmp = dmatrix(0,Snp-1,0,Snp-1);
for(cnt=i = 0; i < Snp; ++i)
for(j = 0; j < Snp-i; ++j,cnt++)
tmp[i][Snp-i-1-j] = SurXpts[fid][cnt];
for(cnt=i = 0; i < Snp; ++i)
for(j = 0; j < Snp-i; ++j,cnt++)
SurXpts[fid][cnt] = tmp[i][j];
for(cnt=i = 0; i < Snp; ++i)
for(j = 0; j < Snp-i; ++j,cnt++)
tmp[i][Snp-i-1-j] = SurYpts[fid][cnt];
for(cnt=i = 0; i < Snp; ++i)
for(j = 0; j < Snp-i; ++j,cnt++)
SurYpts[fid][cnt] = tmp[i][j];
for(cnt=i = 0; i < Snp; ++i)
for(j = 0; j < Snp-i; ++j,cnt++)
tmp[i][Snp-i-1-j] = SurZpts[fid][cnt];
for(cnt=i = 0; i < Snp; ++i)
for(j = 0; j < Snp-i; ++j,cnt++)
SurZpts[fid][cnt] = tmp[i][j];
free_dmatrix(tmp,0,0);
}
void free_d3matrix(double ***matrix, int dx, int dy)
{
int i;
for (i = 0; i < dx; i++)
free_dmatrix(matrix[i], dy);
free(matrix);
}
void makeMatrix(double **Af, unsigned long n, int nx, double C, int dim){
/* make the coefficient matrix in steady state 3d heat equation */
unsigned long i, j, r, h;
int k;
double **A = dmatrix(1, n, 1, dim*2+1); /* coefficient matrix in sparce */
for(i=1; i<=n; i++){ /* initialize matrix Af */
for(j=1; j<=n; j++)
Af[i][j] = 0;
for(k=1; k<=7; k++)
A[i][k] = C;
A[i][4] = -6*C;
}
for(k=1; k<=7; k++){ /* get the row and column index of each diagonal */
if(k==1) { r = -pow(nx, 2); i = -r+1; j = 1; }
else if(k==2) { r = -pow(nx, 1); i = -r+1; j = 1; }
else if(k==3) { r = -1; i = -r+1; j = 1; }
else if(k==4) { r = 0; i = -r+1; j = 1; }
else if(k==5) { r = -1; i = 1; j = -r+1; }
else if(k==6) { r = -pow(nx, 1); i = 1; j = -r+1; }
else { r = -pow(nx, 2); i = 1; j = -r+1; }
for(h=1; h<=n+r; h++, i++, j++) /* build multi-diagonal matrix */
Af[i][j] = A[h][k];
}
free_dmatrix(A, 1, n, 1, dim*2+1);
}
void Matrix_Inverse( double **invMat, double **Mat, int nn)
{
int i, j;
double ger;
int *p= ivector( 1, nn);
double **LU = dmatrix( 1, nn, 1, nn);
for( i=0; i<=nn-1; i++)
for( j=0; j<=nn-1; j++)
LU[i+1][j+1] = Mat[i][j];
double *col = dvector( 1, nn);
ludcmp( LU, nn, p, &ger);
for( j=1; j<=nn; j++) {
for( i=1; i<=nn; i++) col[i] = 0.0;
col[j] = 1.0;
lubksb( LU, nn, p, col );
for( i=1; i<=nn; i++) invMat[i-1][j-1] = (double) col[i];
};
free_dvector( col, 1, nn);
free_ivector( p, 1, nn);
free_dmatrix( LU, 1, nn, 1, nn);
}
int main(int argc, char** argv) {
int n, dim;
double **a;
double *b;
if (argc < 2) {
fprintf(stderr, "Usage: %s n\n", argv[0]);
exit(1);
}
n = atoi(argv[1]);
dim = matrix_dimension(n);
a = alloc_dmatrix(dim, dim);
generate_dense(n, 1.0/n, a);
b = alloc_dvector(dim);
generate_rhs(n, 1.0/n, b);
printf("Matrix A:\n");
fprint_dmatrix(stdout, dim, dim, a);
printf("Vector B (transposed):\n");
fprint_dvector(stdout, dim, b);
free_dmatrix(a);
free_dvector(b);
}
/*
* ASSEMBLE_K - assemble global stiffness matrix from individual elements 23feb94
*/
void assemble_K(
double **K,
int DoF, int nE,
vec3 *xyz, float *r, double *L, double *Le,
int *N1, int *N2,
float *Ax, float *Asy, float *Asz,
float *Jx, float *Iy, float *Iz,
float *E, float *G, float *p,
int shear, int geom, double **Q, int debug
){
double **k; /* element stiffness matrix in global coord */
int **ind, /* member-structure DoF index table */
res=0,
i, j, ii, jj, l, ll;
char stiffness_fn[FILENMAX];
for (i=1; i<=DoF; i++) for (j=1; j<=DoF; j++) K[i][j] = 0.0;
k = dmatrix(1,12,1,12);
ind = imatrix(1,12,1,nE);
for ( i=1; i<= nE; i++ ) {
ind[1][i] = 6*N1[i] - 5; ind[7][i] = 6*N2[i] - 5;
ind[2][i] = ind[1][i] + 1; ind[8][i] = ind[7][i] + 1;
ind[3][i] = ind[1][i] + 2; ind[9][i] = ind[7][i] + 2;
ind[4][i] = ind[1][i] + 3; ind[10][i] = ind[7][i] + 3;
ind[5][i] = ind[1][i] + 4; ind[11][i] = ind[7][i] + 4;
ind[6][i] = ind[1][i] + 5; ind[12][i] = ind[7][i] + 5;
}
for ( i = 1; i <= nE; i++ ) {
elastic_K ( k, xyz, r, L[i], Le[i], N1[i], N2[i],
Ax[i],Asy[i],Asz[i], Jx[i],Iy[i],Iz[i], E[i],G[i], p[i], shear);
if (geom)
geometric_K( k, xyz, r, L[i], Le[i], N1[i], N2[i],
Ax[i], Asy[i],Asz[i],
Jx[i], Iy[i], Iz[i],
E[i],G[i], p[i], -Q[i][1], shear);
if (debug) {
res = sprintf(stiffness_fn,"k_%03d",i);
save_dmatrix(stiffness_fn,k,1,12,1,12,0, "w");
}
for ( l=1; l <= 12; l++ ) {
ii = ind[l][i];
for ( ll=1; ll <= 12; ll++ ) {
jj = ind[ll][i];
K[ii][jj] += k[l][ll];
}
}
}
free_dmatrix ( k,1,12,1,12);
free_imatrix(ind,1,12,1,nE);
return;
}
void destroy_plume_data( Plume_data *grid )
{
if ( grid )
{
eh_free( grid->xval );
eh_free( grid->yval );
free_d3tensor( grid->ccnc );
free_d3tensor( grid->ncnc );
free_d3tensor( grid->deps );
free_d3tensor( grid->dist );
free_dmatrix ( grid->ualb );
free_dmatrix ( grid->pcent );
eh_free( grid );
}
}
int principal_stresses_orig(StressTensor* stress, double sp[3], double cn[3][3])
{
double **a,**v,*d;
int i,j;
a = dmatrix(1,3,1,3);
v = dmatrix(1,3,1,3);
d = dvector(1,3);
a[1][1] = (*stress)[0][0];
a[2][2] = (*stress)[1][1];
a[3][3] = (*stress)[2][2];
a[1][2] = (*stress)[0][1];
a[1][3] = (*stress)[0][2];
a[2][3] = (*stress)[1][2];
a[2][1] = a[1][2];
a[3][1] = a[1][3];
a[3][2] = a[2][3];
jacobi(a,d,v);
d[1] *= -1.0f;
d[2] *= -1.0f;
d[3] *= -1.0f;
eigsrt(d,v);
d[1] *= -1.0f;
d[2] *= -1.0f;
d[3] *= -1.0f;
for(i=0;i<3;i++) {
sp[i] = d[i+1];
for(j=0;j<3;j++) {
cn[i][j] = v[j+1][i+1];
}
}
free_dmatrix(a,1,3,1,3);
free_dmatrix(v,1,3,1,3);
free_dvector(d,1,3);
return(1);
}
int main (int argc, char **argv)
{
int t, T;
HMM hmm;
int *O; /* observation sequence O[1..T] */
double **alpha;
double *scale;
double proba, logproba;
FILE *fp;
if (argc != 3) {
printf("Usage error \n");
printf("Usage: testfor <model.hmm> <obs.seq> \n");
exit (1);
}
fp = fopen(argv[1], "r");
if (fp == NULL) {
fprintf(stderr, "Error: File %s not found\n", argv[1]);
exit (1);
}
ReadHMM(fp, &hmm);
fclose(fp);
fp = fopen(argv[2], "r");
if (fp == NULL) {
fprintf(stderr, "Error: File %s not found\n", argv[2]);
exit (1);
}
ReadSequence(fp, &T, &O);
fclose(fp);
alpha = dmatrix(1, T, 1, hmm.N);
scale = dvector(1, T);
printf("------------------------------------\n");
printf("Forward without scaling \n");
Forward(&hmm, T, O, alpha, &proba);
fprintf(stdout, "log prob(O| model) = %E\n", log(proba));
printf("------------------------------------\n");
printf("Forward with scaling \n");
ForwardWithScale(&hmm, T, O, alpha, scale, &logproba);
fprintf(stdout, "log prob(O| model) = %E\n", logproba);
printf("------------------------------------\n");
printf("The two log probabilites should identical \n");
printf("(within numerical precision). When observation\n");
printf("sequence is very large, use scaling. \n");
free_ivector(O, 1, T);
free_dmatrix(alpha, 1, T, 1, hmm.N);
free_dvector(scale, 1, T);
FreeHMM(&hmm);
}
NUMERICS_EXPORT void vecmat(double *x, double **a, int nra, int nca, double *b)
{
double** t = dmatrix(0, nca - 1, 0, nra - 1);
transpose(a, nra, nca, t);
matvec(t, nca, nra, x, b);
free_dmatrix(t, 0, nca - 1, 0);
}
/************************************************************************
**非用户接口函数
**/
void FreeXi(double *** xi, int T, int N)
{
int t;
for (t = 1; t <= T; t++)
free_dmatrix(xi[t], 1, N, 1, N);
xi ++;
free(xi);
}
int christmas_tree_similarity(Representation * hoodX, Representation * hoodY, double *max_score) {
double **x = hoodX->full;
double **y = hoodY->full;
double NX = hoodX->N_full;
double NY = hoodY->N_full;
int *typeX = hoodX->full_type;
int *typeY = hoodY->full_type;
double score, theta, cosine, sine;
double quat[4], **R, **Ry, **y_prev;
int step;
if ( ! (R=dmatrix(3,3) )) return 1; /* compiler is bugging me otherwise */
if ( ! (y_prev = dmatrix(NY,3) )) return 1; /* compiler is bugging me otherwise */
if ( ! (Ry = dmatrix(NY,3) )) return 1; /* compiler is bugging me otherwise */
theta = M_PI/1000;
cosine = cos(theta/2);
sine = sin(theta/2);
// rotation about the z-axis
quat[0] = cosine;
quat[1] = 0; quat[2] = 0;
quat[3] = sine;
quat_to_R (quat, R);
*max_score = exp_score(x, y, NX, NY);
memcpy (Ry[0], y[0], NY*3*sizeof(double));
for (step=1; step<1000; step++) {
double ** tmp;
tmp = y_prev; y_prev = Ry; Ry = tmp;
rotate (Ry, NY, R, y_prev);
score = hood_score(x, Ry, NX, NY, typeX, typeY);
if (score > *max_score) *max_score = score;
}
free_dmatrix (R);
free_dmatrix (Ry);
free_dmatrix (y_prev);
return 0;
}
void
free_dmatrix_3d_debug(doublereal ***m)
{
integer i;
if (m==NULL) return;
for (i = 0; m[i] != NULL; i++)
free_dmatrix(m[i]);
free( (char *) (m) );
}
int process_sse (Protein * protein, int type, double ** point, int number_of_points,
int first_res_index, int last_res_index, SSElement * element){
int point_ctr;
int number_of_avgd_points;
double ** point_avg = NULL;
Residue * residue;
if ( type != HELIX && type !=STRAND) {
fprintf (stderr, "Error in %s:%d: attempting a fit "
"on something that is neither strand nor helix.\n",
__FILE__, __LINE__);
exit (1);
}
/* the fields that are straightforward to fill: */
element->type = type;
residue = protein->sequence+first_res_index;
strncpy (element->begin_id, residue->pdb_id, (PDB_ATOM_RES_NO_LEN+2)*sizeof(char));
residue = protein->sequence+last_res_index;
strncpy (element->end_id, residue->pdb_id, (PDB_ATOM_RES_NO_LEN+2)*sizeof(char));
element->chain = residue->chain;
element->begin = first_res_index;
element->end = last_res_index;
element->length = last_res_index-first_res_index+1;
/* fit a line through the points --
fill in the center and direction fields of the element structure*/
if (type== STRAND) {
fit_line (point, number_of_points, element->cm, element->p);
} else {
number_of_avgd_points = number_of_points-2;
if ( ! (point_avg=dmatrix(number_of_avgd_points,3))) return 1;
for (point_ctr = 0; point_ctr < number_of_avgd_points; point_ctr++) {
int i;
for (i=0; i<3; i++) {
point_avg[point_ctr][i] = point[point_ctr][i]
+ point[point_ctr+1][i]
+ point[point_ctr+2][i];
point_avg[point_ctr][i] /= 3;
}
}
fit_line (point_avg, number_of_avgd_points, element->cm, element->p);
free_dmatrix (point_avg);
}
return 0;
}
void Matrix_Inverse2( double **invMat, double **Mat, int nn)
{
int i, j;
double **LU = dmatrix( 1, nn, 1, nn);
for( i=0; i<=nn-1; i++)
for( j=0; j<=nn-1; j++)
LU[i+1][j+1] = Mat[i][j];
double **col = dmatrix( 1, nn, 1, 1);
for( i=1; i<=nn; i++) col[i][1] = 0.0;
gaussj( LU, nn, col, 1);
for( j=1; j<=nn; j++)
for( i=1; i<=nn; i++) invMat[i-1][j-1] = (double) LU[i][j];
free_dmatrix( col, 1, nn, 1, 1);
free_dmatrix( LU, 1, nn, 1, nn);
}
double chi2wtheta_covar(float *d, float *x)
{
static int flag = 1, n=12;
static float **cij;
double **tmp, **tmp2, chi2=0, x1;
int i,j;
FILE *fp;
if(flag)
{
flag = 0;
fp = openfile("covar.dat");
cij = matrix(1,n,1,n);
for(i=1;i<=n;++i)
for(j=1;j<=n;++j)
fscanf(fp,"%e",&cij[i][j]);
fclose(fp);
tmp=dmatrix(1,n,1,1);
tmp2=dmatrix(1,n,1,n);
for(i=1;i<=n;++i)
for(j=1;j<=n;++j)
tmp2[i][j]=cij[i][j];
gaussj(tmp2,n,tmp,1);
for(i=1;i<=n;++i)
for(j=1;j<=n;++j)
cij[i][j]=tmp2[i][j];
free_dmatrix(tmp,1,n,1,1);
free_dmatrix(tmp2,1,n,1,n);
}
for(i=1;i<=n;++i)
for(j=1;j<=n;++j)
{
x1=(x[i]-d[i])*(x[j]-d[j])*cij[i][j];
chi2+=x1;
}
return chi2;
}
void Calc_PRSC_spectrum(Element *U, Bsystem *B){
register int i,j,k,n;
double **A,*aloc;
int l,nbl,cnt;
int nrecur = B->rslv->nrecur;
Recur *rdata = B->rslv->rdata + nrecur-1;
int npatch = rdata->npatch;
int **bmap = rdata->map;
int nsolve = rdata->cstart;
if(B->smeth != iterative) {
fputc('\n',stderr);
error_msg(must run with -i option to call Calc_PSC_spectrum);
}
if(!nsolve){
fprintf(stderr,"Calc_PRSC_spectrum: no boundary system, returning\n");
return;
}
/* Generate SC matrix from local contributions */
A = dmatrix(0,nsolve-1,0,nsolve-1);
dzero(nsolve*nsolve, A[0], 1);
for(k = 0; k < npatch; ++k){
nbl = rdata->patchlen_a[k];
aloc = B->rslv->A.a[k];
/* fill matrix from symmetrically packed local matrices */
cnt = 0;
for(i = 0; i < nbl; ++i){
/* do diagonal */
A[bmap[k][i]][bmap[k][i]] += aloc[cnt++];
for(j = i+1; j < nbl; ++j){
A[bmap[k][i]][bmap[k][j]] += aloc[cnt];
A[bmap[k][j]][bmap[k][i]] += aloc[cnt++];
}
}
}
/* operate preconditioner on A[i] */
for(i = 0; i < nsolve; ++i)
Precon(B,nsolve,A[i],A[i]);
/* get eigenvalues of invM*A */
fprintf(stderr,"\n Calculating eigenvalues\n"); fflush(stderr);
FullEigenMatrix(*A,nsolve,nsolve,0);
free_dmatrix(A,0,0);
}
