int main(int argc, char *argv[]) {
int len;
char *mat_file1, *mat_file2;
double **mat1, **mat2, **result_mat;
FILE *fp1, *fp2;
mat_file1 = readLine();
mat_file2 = readLine();
fp1 = fopen(mat_file1, "r");
fp2 = fopen(mat_file2, "r");
len = mat_length(fp1);
mat1 = write_matrix(fp1, len);
norma(mat1, len);
mat2 = write_matrix(fp2, len);
norma(mat2, len);
result_mat = matrix_sum(mat1, mat2, len);
norma(result_mat, len);
fclose(fp1);
fclose(fp2);
free(mat_file1);
free(mat_file2);
freePointers(mat1, len);
freePointers(mat2, len);
freePointers(result_mat, len);
return 0;
}
void make_spl (points_t * pts, spline_t * spl){
int n = pts->n - 1;
matrix_t *eqs = make_matrix(n*3, n*3+1);
double *x = pts->x;
double *y = pts->y;
int i;
for(i= 0; i < n; i++){
double dx = x[i+1] - x[i];
int if1 = 3*i;
int if2 = if1+1;
int if3 = if2+1;
put_entry_matrix(eqs, if1, if1, dx);
put_entry_matrix(eqs, if1, if2, dx*dx/2);
put_entry_matrix(eqs, if1, if3, dx*dx*dx/6);
put_entry_matrix(eqs, if1, n*3, y[i+1]-y[i]);
put_entry_matrix(eqs, if2, if1, 1);
put_entry_matrix(eqs, if2, if2, dx);
put_entry_matrix(eqs, if2, if3, dx*dx/2);
if(if3+1 < n*3)
put_entry_matrix(eqs, if2, if3+1, -1);
else
put_entry_matrix(eqs, if2, if1, 0);
put_entry_matrix(eqs, if3, if2, 1);
put_entry_matrix(eqs, if3, if3, dx);
if(if3+2 < n*3)
put_entry_matrix(eqs, if3, if3+2, -1);
}
#ifdef DEBUG
write_matrix(eqs, stdout);
#endif
if(piv_ge_solver(eqs)) {
spl->n = 0;
return;
}
#ifdef DEBUG
write_matrix(eqs, stdout);
#endif
if(alloc_spl(spl, pts->n) == 0){
spl->n = pts->n;
for(i = 0; i < n; i++) {
spl->x[i] = pts->x[i];
spl->f[i] = pts->y[i];
spl->f1[i] = get_entry_matrix(eqs, 3*i, 3*n);
spl->f2[i] = get_entry_matrix(eqs, 3*i+1, 3*n);
spl->f3[i] = get_entry_matrix(eqs, 3*i+2, 3*n);
}
spl->x[n] = pts->x[n];
spl->f[n] = pts->y[n];
spl->f1[n] = spl->f1[n-1];
spl->f2[n] = 0;
spl->f3[n] = 0;
}
}
int main(int argc, char **argv){
FILE *in;
if(argc > 1 && (in = fopen (argv[1], "r")) != NULL){
matrix_t *m = read_matrix (in);
int sym = 0;
if(m != NULL){
matrix_t *c = NULL;
int *row_per = malloc(m->rn * sizeof *row_per);
printf("\nMacierz:\n");
write_matrix (m, stdout);
if(argc > 2 && strcmp (argv[2], "-s") == 0){
c = symm_pivot_ge_matrix(m, row_per);
sym = 1;
}
else
c = pivot_ge_matrix(m, row_per);
if(c != NULL){
int i;
printf("\nPo elim. Gaussa:\n");
write_matrix(c, stdout);
printf("Permutacja:");
for(i = 0; i < c->rn; i++)
printf(" %d", row_per[i]);
printf("\n");
if(bs_matrix (c) == 0) {
int j;
int *iper = pivot_get_inv_per (c, row_per);
printf("Permutacja odwrotna:");
for(i = 0; i < c->rn; i++)
printf(" %d", iper[i]);
printf("\n");
printf("\nPo podstawieniu wstecz:\n");
write_matrix(c, stdout);
printf("Rozwiązania: \n");
for(j = 0; j < c->cn - c->rn; j++){
printf("Nr %d:\n", j + 1);
for(i = 0; i < c->rn; i++) {
int oi = sym ? iper[i] : i;
printf("\t%g", *(c->e + oi * c->cn + j + c->rn));
}
printf("\n");
}
}
}
else
printf("nie lula!\n");
}
return 0;
}
else
return 1;
}
int main (int argc, char** argv)
{
int n = 200;
double p = .05;
const char* ifname = NULL;
const char* ofname = NULL;
//args
extern char* optarg;
const char* optstring = "hn:d:p:o:i:";
int c;
while ((c = getopt(argc, argv, optstring)) != -1) {
switch (c) {
case 'h':
fprintf(stderr, "%s", usage);
return -1;
case 'n': n = atoi(optarg); break;
case 'p': p = atof(optarg); break;
case 'o': ofname = optarg; break;
case 'i': ifname = optarg; break;
}
}
//make graph + output
int* l = gen_graph(n,p);
if(ifname)
write_matrix(ifname, n, l);
double start = omp_get_wtime();
infinitize(n,l);
floyd(l,n);
deinfinitize(n,l);
double end = omp_get_wtime();
printf("== OpenMP with %d threads\n", omp_get_max_threads());
printf("n: %d\n", n);
printf("p: %g\n", p);
printf("Time: %g sec\n", (end-start));
printf("Check: %X\n", fletcher16(l, n*n));
//output
if(ofname)
write_matrix(ofname,n,l);
free(l);
return 0;
}
/* <angle> <matrix> rotate <matrix> */
static int
zrotate(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
int code;
double ang;
if ((code = real_param(op, &ang)) >= 0) {
code = gs_rotate(igs, ang);
if (code < 0)
return code;
} else { /* matrix operand */
gs_matrix mat;
/* The num_params failure might be a stack underflow. */
check_op(1);
if ((code = num_params(op - 1, 1, &ang)) < 0 ||
(code = gs_make_rotation(ang, &mat)) < 0 ||
(code = write_matrix(op, &mat)) < 0
) { /* Might be a stack underflow. */
check_op(2);
return code;
}
op[-1] = *op;
}
pop(1);
return code;
}
/* <sx> <sy> <matrix> scale <matrix> */
static int
zscale(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
int code;
double scale[2];
if ((code = num_params(op, 2, scale)) >= 0) {
code = gs_scale(igs, scale[0], scale[1]);
if (code < 0)
return code;
} else { /* matrix operand */
gs_matrix mat;
/* The num_params failure might be a stack underflow. */
check_op(2);
if ((code = num_params(op - 1, 2, scale)) < 0 ||
(code = gs_make_scaling(scale[0], scale[1], &mat)) < 0 ||
(code = write_matrix(op, &mat)) < 0
) { /* Might be a stack underflow. */
check_op(3);
return code;
}
op[-2] = *op;
}
pop(2);
return code;
}
void *merge(void *hnd, c4snet_data_t *OutFile, c4snet_data_t *Result,
int X, c4snet_data_t *Out, int N, int B, int K, int J, int I)
{
const int P = N / B;
if (verbose) {
printf("%s: %p, %p, X=%d, %p, N=%d, B=%d, (%d, %d, %d)\n",
__func__, OutFile, Result, X, Out, N, B, K, J, I);
}
if (compute) {
c4snet_data_t **result = C4SNetGetData(Result);
assert(result[J + I * P] == NULL);
result[J + I * P] = Out;
}
if (X > 1) {
C4SNetOut(hnd, 1, OutFile, Result, X - 1);
}
else if (compute) {
struct timespec end;
if (clock_gettime(CLOCK_REALTIME, &end)) {
pexit("clock_gettime");
}
printf("Time for size %d x %d : %lf sec\n", N, N, delta_time(begin, end));
write_matrix(Result, N, B, OutFile);
C4SNetOut(hnd, 2, C4SNetCreate(CTYPE_char, 5, "Done."));
C4SNetFree(OutFile);
C4SNetFree(Result);
}
return hnd;
}
/* <matrix> defaultmatrix <matrix> */
static int
zdefaultmatrix(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gs_matrix mat;
gs_defaultmatrix(igs, &mat);
return write_matrix(op, &mat);
}
int main(int argc, char** argv)
{
if (argc < 3){
return 1;
}
std::string file_name_one(argv[1]);
std::string file_name_two(argv[2]);
std::vector<std::vector<int> > matrix_a = read_matrix(file_name_one);
std::vector<std::vector<int> > matrix_b = read_matrix(file_name_two);
write_matrix(matrix_a);
write_matrix(matrix_b);
std::vector<std::vector<int> > c = multiple_matrix(matrix_a, matrix_b);
write_matrix(c);
return 0;
}
void Bayes::mcmc(const int nit, const int nmc, const string& data_file, const bool record) {
Py_BEGIN_ALLOW_THREADS
// assign storage;
save_z.resize(nmc);
save_pi.resize(nmc);
save_mu.resize(nmc);
save_Omega.resize(nmc);
for (int i=0; i<nmc; ++i) {
save_z[i].resize(n);
save_pi[i].resize(k);
save_mu[i].resize(k);
save_Omega[i].resize(k);
for (int j=0; j<k; ++j) {
save_mu[i][j].resize(p);
save_Omega[i][j].resize(p, p);
}
}
//! MCMC routine
for (int i=0; i<(nit + nmc); ++i) {
sample_zpi();
// save MCMC samples
if (i >= nit) {
save_z.push_back(z);
save_pi.push_back(pi);
save_mu.push_back(mu);
save_Omega.push_back(Omega);
}
// print out occasionally
if (i%100 == 0) {
cout << "======== " << i << " =========\n";
cout << "MCMC: " << i << "\n";
cout << "pi " << pi << "\n";
cout << "mu " << mu << "\n";
// cout << "Omega " << Omega << "\n\n";
}
sample_muOmega();
}
Py_END_ALLOW_THREADS
if (record) {
// dump stored results to file
write_matrix("save_probx_" + int2str(k) + "_" + data_file, probx);
write_vec("save_z_" + int2str(k) + "_" + data_file, save_z);
write_vec("save_pi_" + int2str(k) + "_" + data_file, save_pi);
write_vec_vec("save_mu_" + int2str(k) + "_" + data_file, save_mu);
write_vec_mat("save_omega_" + int2str(k) + "_" + data_file, save_Omega);
}
}
static int
zsizeimagebox(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
const gx_device *dev = gs_currentdevice(igs);
gs_rect srect, drect;
gs_matrix mat;
gs_int_rect rect;
int w, h;
int code;
check_type(op[-4], t_integer);
check_type(op[-3], t_integer);
check_type(op[-2], t_integer);
check_type(op[-1], t_integer);
srect.p.x = op[-4].value.intval;
srect.p.y = op[-3].value.intval;
srect.q.x = srect.p.x + op[-2].value.intval;
srect.q.y = srect.p.y + op[-1].value.intval;
gs_currentmatrix(igs, &mat);
gs_bbox_transform(&srect, &mat, &drect);
/*
* We want the dimensions of the image as a source, not a
* destination, so we need to expand it rather than pixround.
*/
rect.p.x = (int)floor(drect.p.x);
rect.p.y = (int)floor(drect.p.y);
rect.q.x = (int)ceil(drect.q.x);
rect.q.y = (int)ceil(drect.q.y);
/*
* Clip the rectangle to the device boundaries, since that's what
* the NeXT implementation does.
*/
box_confine(&rect.p.x, &rect.q.x, dev->width);
box_confine(&rect.p.y, &rect.q.y, dev->height);
w = rect.q.x - rect.p.x;
h = rect.q.y - rect.p.y;
/*
* The NeXT documentation doesn't specify very clearly what is
* supposed to be in the matrix: the following produces results
* that match testing on an actual NeXT system.
*/
mat.tx -= rect.p.x;
mat.ty -= rect.p.y;
code = write_matrix(op, &mat);
if (code < 0)
return code;
make_int(op - 4, rect.p.x);
make_int(op - 3, rect.p.y);
make_int(op - 2, w);
make_int(op - 1, h);
return 0;
}
/*
* PURPOSE: The command line driven program does matrix creation, reading, writing, and other
* miscellaneous operations. The program automatically creates a matrix and writes
* that out called temp_mat (in binary do not use the cat command on it). You are
* able to display any matrix by using the display command. You can create a new
* blank matrix with the command create. To fill a matrix with random values use the
* random command between a range of values. To get some experience with bit shifting
* there is a command called shift. If you want to write and read in a matrix from
* the filesystem use the respective read and write commands. To see memory operations
* in action use the duplicate and equal commands. The others commands are sum and add.
* To exit the program use the exit command.
* INPUTS: No inputs needed
* RETURN: Returns 0 on successful exectution otherwise -1 if there was an error
**/
int main (int argc, char **argv) {
srand(time(NULL));
char *line = NULL;
Commands_t* cmd;
Matrix_t *mats[10];
memset(&mats,0, sizeof(Matrix_t*) * 10); // IMPORTANT C FUNCTION TO LEARN
Matrix_t *temp = NULL;
// TODO ERROR CHECK
if(!create_matrix (&temp,"temp_mat", 5, 5)) {
return -1;
}
//TODO ERROR CHECK NEEDED
if( (add_matrix_to_array(mats,temp, 10)) < 0) {
return -1;
}
int mat_idx = find_matrix_given_name(mats,10,"temp_mat");
if (mat_idx < 0) {
perror("PROGRAM FAILED TO INIT\n");
return -1;
}
random_matrix(mats[mat_idx], 10, 15);
// TODO ERROR CHECK
if(!write_matrix("temp_mat", mats[mat_idx])) {
return -1;
}
line = readline("> ");
while (strncmp(line,"exit", strlen("exit") + 1) != 0) {
if (!parse_user_input(line,&cmd)) {
printf("Failed at parsing command\n\n");
}
if (cmd->num_cmds > 1) {
run_commands(cmd,mats,10);
}
if (line) {
free(line);
}
destroy_commands(&cmd);
line = readline("> ");
}
free(line);
destroy_remaining_heap_allocations(mats,10);
return 0;
}
int main(
int argc,
char *argv[]) {
static atm_t atm;
static ctl_t ctl;
static obs_t obs;
gsl_matrix *k;
size_t m, n;
/* Check arguments... */
if (argc < 5)
ERRMSG("Give parameters: <ctl> <obs> <atm> <kernel>");
/* Read control parameters... */
read_ctl(argc, argv, &ctl);
/* Set flags... */
ctl.write_matrix = 1;
/* Read observation geometry... */
read_obs(NULL, argv[2], &ctl, &obs);
/* Read atmospheric data... */
read_atm(NULL, argv[3], &ctl, &atm);
/* Get sizes... */
n = atm2x(&ctl, &atm, NULL, NULL, NULL);
m = obs2y(&ctl, &obs, NULL, NULL, NULL);
/* Check sizes... */
if (n <= 0)
ERRMSG("No state vector elements!");
if (m <= 0)
ERRMSG("No measurement vector elements!");
/* Allocate... */
k = gsl_matrix_alloc(m, n);
/* Compute kernel matrix... */
kernel(&ctl, &atm, &obs, k);
/* Write matrix to file... */
write_matrix(NULL, argv[4], &ctl, k, &atm, &obs, "y", "x", "r");
/* Free... */
gsl_matrix_free(k);
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
Matrix *A, *B;
MultiplierMethod mult_method = NULL;
const Multiplier *m = &multipliers[0];
if (argc < 2) goto usage;
while (m->name) {
if (!strcmp(argv[1], m->name)) {
mult_method = m->meth;
break;
}
++m;
}
if (!mult_method) {
goto usage;
}
FILE *input = fopen(kInputFile, "rb");
if (!input) {
printf("unable to open %s\n", kInputFile);
return 1;
}
if (!(A = create_matrix(input))) {
printf("create matrix A failed\n");
fclose(input);
return 1;
}
if (!(B = create_matrix(input))) {
printf("create matrix B failed\n");
fclose(input);
return 1;
}
fclose(input);
Matrix *C = mult_method(A, B, argc - 2, argv + 2);
FILE *out = fopen(kOutputFile, "wb");
write_matrix(C, out);
fclose(out);
free_matrix(&C);
free_matrix(&A);
free_matrix(&B);
return 0;
usage:
printf("%s: method ...\n" "available methods:\n", argv[0]);
m = &multipliers[0];
while (m->name) {
printf(" %s: %s\n", m->name, m->desc);
++m;
}
return 1;
(void) read_row_old;
}
/* <matrix> <inv_matrix> invertmatrix <inv_matrix> */
static int
zinvertmatrix(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gs_matrix m;
int code;
if ((code = read_matrix(imemory, op - 1, &m)) < 0 ||
(code = gs_matrix_invert(&m, &m)) < 0 ||
(code = write_matrix(op, &m)) < 0
)
return code;
op[-1] = *op;
pop(1);
return code;
}
int main(int argc,char *argv[])
{
if (check_input(argc)==1) return 1; // Abuse test
FILE *file = create_file(argv[1]); // File handling
unsigned int nocords=atoi(argv[2]); // Number of coordinates
if (!file)
{
printf("Nothing to write..\nExiting...\n");
return 1;
}
printf("[-] Working...\n");
write_matrix(file,nocords); // Write matrix to file
fclose(file);
printf("[+] Done! \n" );
return 0;
}
/* <matrix1> <matrix2> <matrix> concatmatrix <matrix> */
static int
zconcatmatrix(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gs_matrix m1, m2, mp;
int code;
if ((code = read_matrix(imemory, op - 2, &m1)) < 0 ||
(code = read_matrix(imemory, op - 1, &m2)) < 0 ||
(code = gs_matrix_multiply(&m1, &m2, &mp)) < 0 ||
(code = write_matrix(op, &mp)) < 0
)
return code;
op[-2] = *op;
pop(2);
return code;
}
void *
finalize (void *hnd, c4snet_data_t * fltiles, int bs, int p)
{
struct timespec end;
tile * tiles = *((tile **) C4SNetGetData (fltiles));
if (clock_gettime(CLOCK_REALTIME, &end)) {
pexit("clock_gettime");
}
printf("Time for size %d x %d : %lf sec\n", bs * p, bs * p, delta_time(begin, end));
write_matrix(tiles, p, bs);
C4SNetOut (hnd, 1, C4SNetCreate (CTYPE_char, 5, "Done."));
C4SNetFree (fltiles);
return hnd;
}
int main( int argc, char** argv )
{
if ( argc < 2 ) {
fprintf( stderr, "Error: No file argument.\n");
exit( EXIT_FAILURE );
}
matrix *read_in = read_matrix( argv[1] );
print_matrix( read_in );
if ( argc == 3 ) {
write_matrix( argv[2], read_in );
}
return 0;
}
/* [<req_x> <req_y>] [<med_x0> <med_y0> (<med_x1> <med_y1> | )]
* <policy> <orient|null> <roll> <matrix|null> .matchpagesize
* <matrix|null> <med_x> <med_y> true -or- false
*/
static int
zmatchpagesize(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gs_matrix mat;
float ignore_mismatch = (float)max_long;
gs_point media_size;
int orient;
bool roll;
int code;
check_type(op[-3], t_integer);
if (r_has_type(op - 2, t_null))
orient = -1;
else {
check_int_leu(op[-2], 3);
orient = (int)op[-2].value.intval;
}
check_type(op[-1], t_boolean);
roll = op[-1].value.boolval;
code = zmatch_page_size(imemory,
op - 5, op - 4, (int)op[-3].value.intval,
orient, roll,
&ignore_mismatch, &mat, &media_size);
switch (code) {
default:
return code;
case 0:
make_false(op - 5);
pop(5);
break;
case 1:
code = write_matrix(op, &mat);
if (code < 0 && !r_has_type(op, t_null))
return code;
op[-5] = *op;
make_real(op - 4, media_size.x);
make_real(op - 3, media_size.y);
make_true(op - 2);
pop(2);
break;
}
return 0;
}
// calculates the inverse of the matrix M outputs to M_1 //
int
inverse( GLU_complex M_1[ NCNC ] ,
const GLU_complex M[ NCNC ] )
{
#if (defined HAVE_LAPACKE_H)
const int n = NC , lda = NC ;
int ipiv[ NC + 1 ] ;
memcpy( M_1 , M , NCNC * sizeof( GLU_complex ) ) ;
int info = LAPACKE_zgetrf( LAPACK_ROW_MAJOR , n , n , M_1 , lda , ipiv ) ;
info = LAPACKE_zgetri( LAPACK_ROW_MAJOR , n , M_1 , lda, ipiv ) ;
return info ;
#elif (defined CLASSICAL_ADJOINT_INV)
// define the adjunct //
GLU_complex adjunct[ NCNC ] GLUalign ;
register GLU_complex deter = cofactor_transpose( adjunct , M ) ;
// here we worry about numerical stability //
if( cabs( deter ) < NC * PREC_TOL ) {
fprintf( stderr , "[INVERSE] Matrix is singular !!! "
"deter=%1.14e %1.14e \n" , creal( deter ) , cimag( deter ) ) ;
write_matrix( M ) ;
return GLU_FAILURE ;
}
// obtain inverse of M from 1/( detM )*adj( M ) //
size_t i ;
deter = 1.0 / deter ;
for( i = 0 ; i < NCNC ; i++ ) { M_1[i] = adjunct[i] * deter ; }
return GLU_SUCCESS ;
#else
#if NC == 2
// use the identity, should warn for singular matrices
const double complex INV_detM = 1.0 / ( det( M ) ) ;
M_1[ 0 ] = M[ 3 ] * INV_detM ;
M_1[ 1 ] = -M[ 1 ] * INV_detM ;
M_1[ 2 ] = -M[ 2 ] * INV_detM ;
M_1[ 3 ] = M[ 0 ] * INV_detM ;
return GLU_SUCCESS ;
#else
return gauss_jordan( M_1 , M ) ;
#endif
#endif
}
hid_t set_up_rnw() {
// Set up driver to use ram instead of on-disk files.
hid_t fapl;
fapl = set_core();
create_file(fapl, FILE_NAME_RNW);
hid_t file_id;
file_id = open_file(fapl, FILE_NAME_RNW);
size_t dim0, dim1;
for (dim0 = DIM0_START; dim0 <= DIM0_LIM; dim0 *= 2) {
for (dim1 = DIM1_START; dim1 <= DIM1_LIM; dim1 *= 2) {
// get name of dataset
char name[25];
sprintf(name, "dataset_%dx%d", dim0, dim1); // puts string into buffer
create_dataset(file_id, dim0, dim1, name);
/* Initialise with values */
hid_t dataset_id;
dataset_id = open_dataset(file_id, name);
double matrix[dim0][dim1];
int i, j;
// fill matrix with some elements
for (i = 0; i < dim0; i++) {
for (j = 0; j < dim1; j++) {
matrix[i][j] = i * dim1 + j;
}
}
write_matrix(dataset_id, matrix);
close_dataset(dataset_id);
}
}
/* Done initializing values */
close_file(file_id);
return fapl;
}
int
driver(const Box& global_box, Box& my_box,
Parameters& params, YAML_Doc& ydoc)
{
int global_nx = global_box[0][1];
int global_ny = global_box[1][1];
int global_nz = global_box[2][1];
int numprocs = 1, myproc = 0;
#ifdef HAVE_MPI
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &myproc);
#endif
if (params.load_imbalance > 0) {
add_imbalance<GlobalOrdinal>(global_box, my_box, params.load_imbalance, ydoc);
}
float largest_imbalance = 0, std_dev = 0;
compute_imbalance<GlobalOrdinal>(global_box, my_box, largest_imbalance,
std_dev, ydoc, true);
//Create a representation of the mesh:
//Note that 'simple_mesh_description' is a virtual or conceptual
//mesh that doesn't actually store mesh data.
#ifdef TIME_IT
if (myproc==0) {
std::cout.width(30);
std::cout << "creating/filling mesh...";
std::cout.flush();
}
#endif
timer_type t_start = mytimer();
timer_type t0 = mytimer();
simple_mesh_description<GlobalOrdinal> mesh(global_box, my_box);
timer_type mesh_fill = mytimer() - t0;
timer_type t_total = mytimer() - t_start;
#ifdef TIME_IT
if (myproc==0) {
std::cout << mesh_fill << "s, total time: " << t_total << std::endl;
}
#endif
//next we will generate the matrix structure.
//Declare matrix object:
#if defined(MINIFE_ELL_MATRIX)
typedef ELLMatrix<Scalar,LocalOrdinal,GlobalOrdinal> MatrixType;
#else
typedef CSRMatrix<Scalar,LocalOrdinal,GlobalOrdinal> MatrixType;
#endif
MatrixType A;
timer_type gen_structure;
RUN_TIMED_FUNCTION("generating matrix structure...",
generate_matrix_structure(mesh, A),
gen_structure, t_total);
GlobalOrdinal local_nrows = A.rows.size();
GlobalOrdinal my_first_row = local_nrows > 0 ? A.rows[0] : -1;
Vector<Scalar,LocalOrdinal,GlobalOrdinal> b(my_first_row, local_nrows);
Vector<Scalar,LocalOrdinal,GlobalOrdinal> x(my_first_row, local_nrows);
//Assemble finite-element sub-matrices and sub-vectors into the global
//linear system:
timer_type fe_assembly;
RUN_TIMED_FUNCTION("assembling FE data...",
assemble_FE_data(mesh, A, b, params),
fe_assembly, t_total);
if (myproc == 0) {
ydoc.add("Matrix structure generation","");
ydoc.get("Matrix structure generation")->add("Mat-struc-gen Time",gen_structure);
ydoc.add("FE assembly","");
ydoc.get("FE assembly")->add("FE assembly Time",fe_assembly);
}
#ifdef MINIFE_DEBUG
write_matrix("A_prebc.mtx", A);
write_vector("b_prebc.vec", b);
#endif
//Now apply dirichlet boundary-conditions
//(Apply the 0-valued surfaces first, then the 1-valued surface last.)
timer_type dirbc_time;
RUN_TIMED_FUNCTION("imposing Dirichlet BC...",
impose_dirichlet(0.0, A, b, global_nx+1, global_ny+1, global_nz+1, mesh.bc_rows_0), dirbc_time, t_total);
RUN_TIMED_FUNCTION("imposing Dirichlet BC...",
impose_dirichlet(1.0, A, b, global_nx+1, global_ny+1, global_nz+1, mesh.bc_rows_1), dirbc_time, t_total);
#ifdef MINIFE_DEBUG
write_matrix("A.mtx", A);
write_vector("b.vec", b);
#endif
//Transform global indices to local, set up communication information:
timer_type make_local_time;
RUN_TIMED_FUNCTION("making matrix indices local...",
make_local_matrix(A),
make_local_time, t_total);
#ifdef MINIFE_DEBUG
write_matrix("A_local.mtx", A);
write_vector("b_local.vec", b);
#endif
size_t global_nnz = compute_matrix_stats(A, myproc, numprocs, ydoc);
//Prepare to perform conjugate gradient solve:
LocalOrdinal max_iters = 200;
LocalOrdinal num_iters = 0;
typedef typename TypeTraits<Scalar>::magnitude_type magnitude;
magnitude rnorm = 0;
magnitude tol = std::numeric_limits<magnitude>::epsilon();
timer_type cg_times[NUM_TIMERS];
typedef Vector<Scalar,LocalOrdinal,GlobalOrdinal> VectorType;
t_total = mytimer() - t_start;
bool matvec_with_comm_overlap = params.mv_overlap_comm_comp==1;
int verify_result = 0;
#if MINIFE_KERNELS != 0
if (myproc==0) {
std::cout.width(30);
std::cout << "Starting kernel timing loops ..." << std::endl;
}
max_iters = 500;
x.coefs[0] = 0.9;
if (matvec_with_comm_overlap) {
time_kernels(A, b, x, matvec_overlap<MatrixType,VectorType>(), max_iters, rnorm, cg_times);
}
else {
time_kernels(A, b, x, matvec_std<MatrixType,VectorType>(), max_iters, rnorm, cg_times);
}
num_iters = max_iters;
std::string title("Kernel timings");
#else
if (myproc==0) {
std::cout << "Starting CG solver ... " << std::endl;
}
if (matvec_with_comm_overlap) {
#ifdef MINIFE_CSR_MATRIX
rearrange_matrix_local_external(A);
cg_solve(A, b, x, matvec_overlap<MatrixType,VectorType>(), max_iters, tol,
num_iters, rnorm, cg_times);
#else
std::cout << "ERROR, matvec with overlapping comm/comp only works with CSR matrix."<<std::endl;
#endif
}
else {
cg_solve(A, b, x, matvec_std<MatrixType,VectorType>(), max_iters, tol,
num_iters, rnorm, cg_times);
if (myproc == 0) {
std::cout << "Final Resid Norm: " << rnorm << std::endl;
}
if (params.verify_solution > 0) {
double tolerance = 0.06;
bool verify_whole_domain = false;
#ifdef MINIFE_DEBUG
verify_whole_domain = true;
#endif
if (myproc == 0) {
if (verify_whole_domain) std::cout << "verifying solution..." << std::endl;
else std::cout << "verifying solution at ~ (0.5, 0.5, 0.5) ..." << std::endl;
}
verify_result = verify_solution(mesh, x, tolerance, verify_whole_domain);
}
}
#ifdef MINIFE_DEBUG
write_vector("x.vec", x);
#endif
std::string title("CG solve");
#endif
if (myproc == 0) {
ydoc.get("Global Run Parameters")->add("ScalarType",TypeTraits<Scalar>::name());
ydoc.get("Global Run Parameters")->add("GlobalOrdinalType",TypeTraits<GlobalOrdinal>::name());
ydoc.get("Global Run Parameters")->add("LocalOrdinalType",TypeTraits<LocalOrdinal>::name());
ydoc.add(title,"");
ydoc.get(title)->add("Iterations",num_iters);
ydoc.get(title)->add("Final Resid Norm",rnorm);
GlobalOrdinal global_nrows = global_nx;
global_nrows *= global_ny*global_nz;
//flops-per-mv, flops-per-dot, flops-per-waxpy:
double mv_flops = global_nnz*2.0;
double dot_flops = global_nrows*2.0;
double waxpy_flops = global_nrows*3.0;
#if MINIFE_KERNELS == 0
//if MINIFE_KERNELS == 0 then we did a CG solve, and in that case
//there were num_iters+1 matvecs, num_iters*2 dots, and num_iters*3+2 waxpys.
mv_flops *= (num_iters+1);
dot_flops *= (2*num_iters);
waxpy_flops *= (3*num_iters+2);
#else
//if MINIFE_KERNELS then we did one of each operation per iteration.
mv_flops *= num_iters;
dot_flops *= num_iters;
waxpy_flops *= num_iters;
#endif
double total_flops = mv_flops + dot_flops + waxpy_flops;
double mv_mflops = -1;
if (cg_times[MATVEC] > 1.e-4)
mv_mflops = 1.e-6 * (mv_flops/cg_times[MATVEC]);
double dot_mflops = -1;
if (cg_times[DOT] > 1.e-4)
dot_mflops = 1.e-6 * (dot_flops/cg_times[DOT]);
double waxpy_mflops = -1;
if (cg_times[WAXPY] > 1.e-4)
waxpy_mflops = 1.e-6 * (waxpy_flops/cg_times[WAXPY]);
double total_mflops = -1;
if (cg_times[TOTAL] > 1.e-4)
total_mflops = 1.e-6 * (total_flops/cg_times[TOTAL]);
ydoc.get(title)->add("WAXPY Time",cg_times[WAXPY]);
ydoc.get(title)->add("WAXPY Flops",waxpy_flops);
if (waxpy_mflops >= 0)
ydoc.get(title)->add("WAXPY Mflops",waxpy_mflops);
else
ydoc.get(title)->add("WAXPY Mflops","inf");
ydoc.get(title)->add("DOT Time",cg_times[DOT]);
ydoc.get(title)->add("DOT Flops",dot_flops);
if (dot_mflops >= 0)
ydoc.get(title)->add("DOT Mflops",dot_mflops);
else
ydoc.get(title)->add("DOT Mflops","inf");
ydoc.get(title)->add("MATVEC Time",cg_times[MATVEC]);
ydoc.get(title)->add("MATVEC Flops",mv_flops);
if (mv_mflops >= 0)
ydoc.get(title)->add("MATVEC Mflops",mv_mflops);
else
ydoc.get(title)->add("MATVEC Mflops","inf");
#ifdef MINIFE_FUSED
ydoc.get(title)->add("MATVECDOT Time",cg_times[MATVECDOT]);
ydoc.get(title)->add("MATVECDOT Flops",mv_flops);
if (mv_mflops >= 0)
ydoc.get(title)->add("MATVECDOT Mflops",mv_mflops);
else
ydoc.get(title)->add("MATVECDOT Mflops","inf");
#endif
#if MINIFE_KERNELS == 0
ydoc.get(title)->add("Total","");
ydoc.get(title)->get("Total")->add("Total CG Time",cg_times[TOTAL]);
ydoc.get(title)->get("Total")->add("Total CG Flops",total_flops);
if (total_mflops >= 0)
ydoc.get(title)->get("Total")->add("Total CG Mflops",total_mflops);
else
ydoc.get(title)->get("Total")->add("Total CG Mflops","inf");
ydoc.get(title)->add("Time per iteration",cg_times[TOTAL]/num_iters);
#endif
}
return verify_result;
}
/*
* PURPOSE: run the commands which user entered
* INPUTS:
* cmd double pointer that holds all commands
* mats the matrix list
* num_mats the number of matrix in the list
* RETURN: void
* If no errors occurred during process then return nothing
* else print error message
**/
void run_commands (Commands_t* cmd, Matrix_t** mats, unsigned int num_mats) {
//TODO ERROR CHECK INCOMING PARAMETERS
if(!cmd){
printf("commands array is null\n");
return;
}
if(!(*mats)){
printf("matrix list is null\n");
return;
}
/*Parsing and calling of commands*/
if (strncmp(cmd->cmds[0],"display",strlen("display") + 1) == 0
&& cmd->num_cmds == 2) {
/*find the requested matrix*/
int idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
if (idx >= 0) {
display_matrix (mats[idx]);
}
else {
printf("Matrix (%s) doesn't exist\n", cmd->cmds[1]);
return;
}
}
else if (strncmp(cmd->cmds[0],"add",strlen("add") + 1) == 0
&& cmd->num_cmds == 4) {
int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
int mat2_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[2]);
if (mat1_idx >= 0 && mat2_idx >= 0) {
Matrix_t* c = NULL;
if( !create_matrix (&c,cmd->cmds[3], mats[mat1_idx]->rows,
mats[mat1_idx]->cols)) {
printf("Failure to create the result Matrix (%s)\n", cmd->cmds[3]);
return;
}
if(add_matrix_to_array(mats,c, num_mats) == 999){
perror("PROGRAM FAILED TO ADD MATRIX TO ARRAY\n");
return;
} //TODO ERROR CHECK NEEDED
if (! add_matrices(mats[mat1_idx], mats[mat2_idx],c) ) {
printf("Failure to add %s with %s into %s\n", mats[mat1_idx]->name, mats[mat2_idx]->name,c->name);
return;
}
}
}
else if (strncmp(cmd->cmds[0],"duplicate",strlen("duplicate") + 1) == 0
&& cmd->num_cmds == 3 && strlen(cmd->cmds[1]) + 1 <= MATRIX_NAME_LEN) {
int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
if (mat1_idx >= 0 ) {
Matrix_t* dup_mat = NULL;
if( !create_matrix (&dup_mat,cmd->cmds[2], mats[mat1_idx]->rows,
mats[mat1_idx]->cols)) {
return;
}
if(!duplicate_matrix (mats[mat1_idx], dup_mat)){
perror("PROGRAM FAILED TO DUPLICATE MATRIX\n");
return;
} //TODO ERROR CHECK NEEDED
if(add_matrix_to_array(mats,dup_mat,num_mats) == 999){
perror("PROGRAM FAILED TO ADD MATRIX TO ARRAY\n");
return;
} //TODO ERROR CHECK NEEDED
printf ("Duplication of %s into %s finished\n", mats[mat1_idx]->name, cmd->cmds[2]);
}
else {
printf("Duplication Failed\n");
return;
}
}
else if (strncmp(cmd->cmds[0],"equal",strlen("equal") + 1) == 0
&& cmd->num_cmds == 2) {
int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
int mat2_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[2]);
if (mat1_idx >= 0 && mat2_idx >= 0) {
if ( equal_matrices(mats[mat1_idx],mats[mat2_idx]) ) {
printf("SAME DATA IN BOTH\n");
}
else {
printf("DIFFERENT DATA IN BOTH\n");
}
}
else {
printf("Equal Failed\n");
return;
}
}
else if (strncmp(cmd->cmds[0],"shift",strlen("shift") + 1) == 0
&& cmd->num_cmds == 4) {
int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
const int shift_value = atoi(cmd->cmds[3]);
if (mat1_idx >= 0 ) {
if(!bitwise_shift_matrix(mats[mat1_idx],cmd->cmds[2][0], shift_value)){
perror("PROGRAM FAILED TO SHIFT MATRIX\n");
return;
} //TODO ERROR CHECK NEEDED
printf("Matrix (%s) has been shifted by %d\n", mats[mat1_idx]->name, shift_value);
}
else {
printf("Matrix shift failed\n");
return;
}
}
else if (strncmp(cmd->cmds[0],"read",strlen("read") + 1) == 0
&& cmd->num_cmds == 2) {
Matrix_t* new_matrix = NULL;
if(! read_matrix(cmd->cmds[1],&new_matrix)) {
printf("Read Failed\n");
return;
}
if(add_matrix_to_array(mats,new_matrix, num_mats) == 999){
perror("PROGRAM FAILED TO ADD MATRIX TO ARRAY\n");
return;
} //TODO ERROR CHECK NEEDED
printf("Matrix (%s) is read from the filesystem\n", cmd->cmds[1]);
}
else if (strncmp(cmd->cmds[0],"write",strlen("write") + 1) == 0
&& cmd->num_cmds == 2) {
int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
if(! write_matrix(mats[mat1_idx]->name,mats[mat1_idx])) {
printf("Write Failed\n");
return;
}
else {
printf("Matrix (%s) is wrote out to the filesystem\n", mats[mat1_idx]->name);
}
}
else if (strncmp(cmd->cmds[0], "create", strlen("create") + 1) == 0
&& strlen(cmd->cmds[1]) + 1 <= MATRIX_NAME_LEN && cmd->num_cmds == 4) {
Matrix_t* new_mat = NULL;
const unsigned int rows = atoi(cmd->cmds[2]);
const unsigned int cols = atoi(cmd->cmds[3]);
if(!create_matrix(&new_mat,cmd->cmds[1],rows, cols)){
perror("PROGRAM FAILED TO ADD CREATE TO ARRAY\n");
return;
} //TODO ERROR CHECK NEEDED
if(add_matrix_to_array(mats,new_mat,num_mats) == 999){
perror("PROGRAM FAILED TO ADD MATRIX TO ARRAY\n");
return;
} // TODO ERROR CHECK NEEDED
printf("Created Matrix (%s,%u,%u)\n", new_mat->name, new_mat->rows, new_mat->cols);
}
else if (strncmp(cmd->cmds[0], "random", strlen("random") + 1) == 0
&& cmd->num_cmds == 4) {
int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
const unsigned int start_range = atoi(cmd->cmds[2]);
const unsigned int end_range = atoi(cmd->cmds[3]);
if(!random_matrix(mats[mat1_idx],start_range, end_range)) {
perror("PROGRAM FAILED TO RANDOMIZE MATRIX\n");
return;
} //TODO ERROR CHECK NEEDED
printf("Matrix (%s) is randomized between %u %u\n", mats[mat1_idx]->name, start_range, end_range);
}
else {
printf("Not a command in this application\n");
}
}
int main(int argc, char **argv){
int test;
test = 0;
int n_processes;
if (argc < 2){
return 0;
}
n_processes = atoi(argv[1]);
int m, x, n;
int i, j;
int **mmx, **mxn, **mmn;
// Read in1.txt
f_mmx = fopen("in1.txt", "r");
read_matrix_size(f_mmx, &m, &x);
mmx = (int**)malloc(m*sizeof(int*));
for (i = 0; i < m ; i++){
mmx[i] = (int*)malloc(x*sizeof(int));
for (j = 0; j < x ; j++){
fscanf(f_mmx, "%d",&mmx[i][j]);
}
}
fclose(f_mmx);
// Read in2.txt
f_mxn = fopen("in2.txt", "r");
read_matrix_size(f_mxn, &x, &n);
mxn = (int**)malloc(x*sizeof(int*));
for (i = 0; i < x ; i++){
mxn[i] = (int*)malloc(x*sizeof(int));
for (j = 0; j < n ; j++){
fscanf(f_mxn, "%d",&mxn[i][j]);
}
}
fclose(f_mxn);
// Init MMN
mmn = (int**)malloc(m*sizeof(int*));
for(i=0; i<m; i++){
mmn[i] = (int*)malloc(n*sizeof(int));
}
pid_t pid;
matrix_mult(0,n_processes,mmx, mxn, mmn, m, x, n);
switch(n_processes)
{
case 1:
write_matrix("out.txt", mmn, m, n);
break;
case 2:
pid = fork();
if(pid != 0){
;
}
else{
matrix_mult(1,n_processes,mmx, mxn, mmn, m, x, n);
write_matrix("out.txt", mmn, m, n);
}
break;
case 4:
pid = fork();
if(pid != 0){
;
}
else
{
matrix_mult(1,n_processes,mmx, mxn, mmn, m, x, n);
pid=fork();
if(pid!=0){
;
}
else{
matrix_mult(2,n_processes,mmx, mxn, mmn, m, x, n);
pid=fork();
if(pid !=0){
waitpid(pid,0,0);
}
else{
matrix_mult(3,n_processes,mmx, mxn, mmn, m, x, n);
write_matrix("out.txt", mmn, m, n);
}
}
}
break;
case 8:
pid = fork();
if(pid != 0){
waitpid(pid,0,0);
}
else{
matrix_mult(1,n_processes,mmx, mxn, mmn, m, x, n);
pid = fork();
if(pid != 0){
;
}
else{
matrix_mult(2,n_processes,mmx, mxn, mmn, m, x, n);
pid = fork();
if( pid!= 0){
;
}
else{
matrix_mult(3,n_processes,mmx, mxn, mmn, m, x, n);
pid = fork();
if( pid!=0){
;
}
else{
matrix_mult(4,n_processes,mmx, mxn, mmn, m, x, n);
pid = fork();
if(pid!=0){
;
}
else {
matrix_mult(5,n_processes,mmx, mxn, mmn, m, x, n);
pid=fork();
if( pid!=0){
;
}
else{
matrix_mult(6,n_processes,mmx, mxn, mmn, m, x, n);
pid = fork();
if( pid!=0){
waitpid(pid,0,0);
}
else{
matrix_mult(7,n_processes,mmx, mxn, mmn, m, x, n);
write_matrix("out.txt", mmn, m, n);
}
}
}
}
}
}
}
break;
default: printf("WRONG \n" );
}
free(mmn);
free(mmx);
free(mxn);
return 0;
}
void pins_model_init(model_t m) {
// create the LTS type LTSmin will generate
lts_type_t ltstype=lts_type_create();
// set the length of the state
lts_type_set_state_length(ltstype, state_length());
// add an "int" type for a state slot
int int_type = lts_type_add_type(ltstype, "int", NULL);
lts_type_set_format (ltstype, int_type, LTStypeDirect);
// add an "action" type for edge labels
int action_type = lts_type_add_type(ltstype, "action", NULL);
lts_type_set_format (ltstype, action_type, LTStypeEnum);
// add a "bool" type for state labels
int bool_type = lts_type_add_type (ltstype, LTSMIN_TYPE_BOOL, NULL);
lts_type_set_format(ltstype, bool_type, LTStypeEnum);
// set state name & type
for (int i=0; i < state_length(); ++i) {
char name[3]; sprintf(name, "%d", i);
lts_type_set_state_name(ltstype,i,name);
lts_type_set_state_typeno(ltstype,i,int_type);
}
// edge label types
lts_type_set_edge_label_count (ltstype, 1);
lts_type_set_edge_label_name(ltstype, 0, "action");
lts_type_set_edge_label_type(ltstype, 0, "action");
lts_type_set_edge_label_typeno(ltstype, 0, action_type);
// state label types
lts_type_set_state_label_count (ltstype, 1);
lts_type_set_state_label_name (ltstype, 0, "goal");
lts_type_set_state_label_typeno (ltstype, 0, bool_type);
// done with ltstype
lts_type_validate(ltstype);
// make sure to set the lts-type before anything else in the GB
GBsetLTStype(m, ltstype);
// setting all values for all non direct types
GBchunkPut(m, action_type, chunk_str("switch_a"));
GBchunkPut(m, action_type, chunk_str("switch_b"));
GBchunkPut(m, action_type, chunk_str("switch_c"));
GBchunkPut(m, action_type, chunk_str("switch_d"));
GBchunkPut(m, action_type, chunk_str("switch_ab"));
GBchunkPut(m, action_type, chunk_str("switch_ac"));
GBchunkPut(m, action_type, chunk_str("switch_ad"));
GBchunkPut(m, action_type, chunk_str("switch_bc"));
GBchunkPut(m, action_type, chunk_str("switch_bd"));
GBchunkPut(m, action_type, chunk_str("switch_cd"));
GBchunkPut(m, bool_type, chunk_str(LTSMIN_VALUE_BOOL_FALSE));
GBchunkPut(m, bool_type, chunk_str(LTSMIN_VALUE_BOOL_TRUE));
// set state variable values for initial state
GBsetInitialState(m, initial_state());
// set function pointer for the next-state function
GBsetNextStateLong(m, (next_method_grey_t) next_state);
// set function pointer for the label evaluation function
GBsetStateLabelLong(m, (get_label_method_t) state_label);
// create combined matrix
matrix_t *cm = malloc(sizeof(matrix_t));
dm_create(cm, group_count(), state_length());
// set the read dependency matrix
matrix_t *rm = malloc(sizeof(matrix_t));
dm_create(rm, group_count(), state_length());
for (int i = 0; i < group_count(); i++) {
for (int j = 0; j < state_length(); j++) {
if (read_matrix(i)[j]) {
dm_set(cm, i, j);
dm_set(rm, i, j);
}
}
}
GBsetDMInfoRead(m, rm);
// set the write dependency matrix
matrix_t *wm = malloc(sizeof(matrix_t));
dm_create(wm, group_count(), state_length());
for (int i = 0; i < group_count(); i++) {
for (int j = 0; j < state_length(); j++) {
if (write_matrix(i)[j]) {
dm_set(cm, i, j);
dm_set(wm, i, j);
}
}
}
GBsetDMInfoMustWrite(m, wm);
// set the combined matrix
GBsetDMInfo(m, cm);
// set the label dependency matrix
matrix_t *lm = malloc(sizeof(matrix_t));
dm_create(lm, label_count(), state_length());
for (int i = 0; i < label_count(); i++) {
for (int j = 0; j < state_length(); j++) {
if (label_matrix(i)[j]) dm_set(lm, i, j);
}
}
GBsetStateLabelInfo(m, lm);
}
void SkeletonExporter::export_light(INode *node)
{
Control *c;
int size_key, sf;
ObjectState os;
GenLight* light;
struct LightState ls;
float near_radius, far_radius;
Point3 row;
Matrix3 mat;
os=node->EvalWorldState(0);
if (!os.obj) return; // per sicurezza
light=(GenLight*)os.obj;
// controlliamo se esiste un padre
INode *padre=node->GetParentNode();
if ((padre) && (strcmp(padre->GetName(), "Scene Root")!=0))
sf=strlen(padre->GetName())+1;
else sf=0;
light->EvalLightState(0, FOREVER, &ls);
fprintf(fTXT, "Name : %s\n", node->GetName());
switch (ls.type)
{
case OMNI_LGT: fprintf(fTXT, "Omni light found\n");
// flag padre + nome padre + pivot + NodeTM(0) +
// + colore
write_chunk_header(fA3D, OMNI_LIGHT_ID,
node->GetName(), 4+sf+12+48+12);
if (makeRAY) write_chunk_header(fRAY, OMNI_LIGHT_ID,
node->GetName(), 4+sf+12+48+12);
break;
case SPOT_LGT: fprintf(fTXT, "Spot light found\n");
// flag padre + nome padre + pivot + NodeTM(0) +
// + colore + falloff + hotspot
write_chunk_header(fA3D, SPOT_LIGHT_ID,
node->GetName(), 4+sf+12+48+12+8);
if (makeRAY) write_chunk_header(fRAY, SPOT_LIGHT_ID,
node->GetName(), 4+sf+12+48+12+8);
break;
}
// ----------- scrivo il padre (flag, nome) ------------------
fwrite(&sf, sizeof(int), 1, fA3D);
if (sf>0) write_string0(fA3D, padre->GetName());
if (makeRAY) fwrite(&sf, sizeof(int), 1, fRAY);
if (makeRAY)
if (sf>0) write_string0(fRAY, padre->GetName());
// --------------- scrittura del punto di pivot ----------------
GetPivotOffset(node, &row);
fprintf(fTXT, "Pivot point : %f, %f, %f\n", row.x, row.y, row.z);
write_point3(&row, fA3D);
if (makeRAY) write_point3(&row, fRAY);
// ------------------- salviamo la NodeTM(0) ---------------------
mat=node->GetNodeTM(0);
row=mat.GetRow(3);
fprintf(fTXT, "World position : x=%f, y=%f, z=%f\n", row.x, row.y, row.z);
write_matrix(&mat, fA3D);
if (makeRAY) write_matrix(&mat, fRAY);
// -------------------- salviamo il colore -----------------------
fprintf(fTXT, "Color : R=%f, G=%f, B=%f\n", ls.color.r, ls.color.g, ls.color.b);
fwrite(&ls.color.r, sizeof(float), 1, fA3D);
fwrite(&ls.color.g, sizeof(float), 1, fA3D);
fwrite(&ls.color.b, sizeof(float), 1, fA3D);
if (makeRAY) fwrite(&ls.color.r, sizeof(float), 1, fRAY);
if (makeRAY) fwrite(&ls.color.g, sizeof(float), 1, fRAY);
if (makeRAY) fwrite(&ls.color.b, sizeof(float), 1, fRAY);
// ---------------------- falloff e hotpsot ----------------------
if (ls.type == SPOT_LGT)
{
float hotspot = (float)(ls.hotsize*3.14159265358979323846/180.0);
float falloff = (float)(ls.fallsize*3.14159265358979323846/180.0);
fwrite(&hotspot, sizeof(float), 1, fA3D);
if (makeRAY) fwrite(&hotspot, sizeof(float), 1, fRAY);
fwrite(&falloff, sizeof(float), 1, fA3D);
if (makeRAY) fwrite(&falloff, sizeof(float), 1, fRAY);
}
fprintf(fTXT, "Intensity : %f\n", ls.intens);
// -------------- esportazione tracce di posizione ---------------
c=node->GetTMController()->GetPositionController();
if ((c) && (c->NumKeys()>0))
{
if (IsTCBControl(c)) size_key=36;
else
if (IsBezierControl(c)) size_key=40;
else size_key=16;
fprintf(fTXT, "Light position track present.");
write_chunk_header(fA3D, POSITION_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_point3_track(c, 1, fA3D);
if (makeRAY) write_chunk_header(fRAY, POSITION_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
if (makeRAY) export_point3_track(c, 1, fRAY);
}
// --------------- esportazione tracce di colore -----------------
c=light->GetColorControl();
if ((c) && (c->NumKeys()>0))
{
if (IsTCBControl(c)) size_key=36;
else
if (IsBezierControl(c)) size_key=40;
else size_key=16;
fprintf(fTXT, "Light color track present.");
write_chunk_header(fA3D, COLOR_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_point3_track(c, 1.0f, fA3D);
if (makeRAY) write_chunk_header(fRAY, COLOR_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
if (makeRAY) export_point3_track(c, 1.0f, fRAY);
}
// -------------- esportazione tracce di hotspot -----------------
c=light->GetHotSpotControl();
if ((c) && (c->NumKeys()>0) && (ls.type == SPOT_LGT))
{
if (IsTCBControl(c)) size_key=28;
else
if (IsBezierControl(c)) size_key=16;
else size_key=8;
fprintf(fTXT, "Light hotspot track present.");
write_chunk_header(fA3D, HOTSPOT_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_float_track(c, (float)(3.14159265358979323846/180.0), fA3D); // in radianti
if (makeRAY) write_chunk_header(fRAY, HOTSPOT_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
if (makeRAY) export_float_track(c, (float)(3.14159265358979323846/180.0), fRAY); // in radianti
}
// -------------- esportazione tracce di falloff -----------------
c=light->GetFalloffControl();
if ((c) && (c->NumKeys()>0) && (ls.type == SPOT_LGT))
{
if (IsTCBControl(c)) size_key=28;
else
if (IsBezierControl(c)) size_key=16;
else size_key=8;
fprintf(fTXT, "Light falloff track present.");
write_chunk_header(fA3D, FALLOFF_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
export_float_track(c, (float)(3.14159265358979323846/180.0), fA3D); // in radianti
if (makeRAY) write_chunk_header(fRAY, FALLOFF_TRACK_ID,
node->GetName(), 1+2+4+c->NumKeys()*size_key);
if (makeRAY) export_float_track(c, (float)(3.14159265358979323846/180.0), fRAY); // in radianti
}
// ------------------------- script ADL --------------------------
Mtl *materiale=node->GetMtl();
// NO far + NO near
if ((!light->GetUseAttenNear()) && (!light->GetUseAtten()))
{
far_radius=near_radius=999999;
}
else
// NO far + SI near
if ((light->GetUseAttenNear()) && (!light->GetUseAtten()))
{
near_radius=light->GetAtten(0, ATTEN1_START, FOREVER);
far_radius=999999;
}
else
// SI far + NO near
if ((!light->GetUseAttenNear()) && (light->GetUseAtten()))
{
far_radius=light->GetAtten(0, ATTEN_START, FOREVER);
near_radius=far_radius;
}
// SI far + SI near
if ((light->GetUseAttenNear()) && (light->GetUseAtten()))
{
near_radius=light->GetAtten(0, ATTEN1_START, FOREVER);
far_radius=light->GetAtten(0, ATTEN_START, FOREVER);
}
if (makeADL)
{
fprintf(fADL, " light %c%s%c\n {\n", '"', node->GetName(), '"');
if (materiale)
fprintf(fADL, " material=%c%s%c;\n", '"', materiale->GetName(), '"');
else
fprintf(fADL, " material=%cNONE%c;\n", '"', '"');
//fprintf(fADL, " scale_x=%c160%c;\n", '"', '"');
//fprintf(fADL, " scale_y=%c160%c;\n", '"', '"');
//fprintf(fADL, " near_radius=%c%f%c;\n", '"', near_radius, '"');
//fprintf(fADL, " far_radius=%c%f%c;\n", '"', far_radius, '"');
switch (light->GetDecayType())
{
case 0: fprintf(fADL, " attenuation0=%c1.0%c;\n", '"', '"');
fprintf(fADL, " attenuation1=%c0%c;\n", '"', '"');
fprintf(fADL, " attenuation2=%c0%c;\n", '"', '"');
break;
case 1: fprintf(fADL, " attenuation0=%c0%c;\n", '"', '"');
fprintf(fADL, " attenuation1=%c1.0%c;\n", '"', '"');
fprintf(fADL, " attenuation2=%c0%c;\n", '"', '"');
break;
case 2: fprintf(fADL, " attenuation0=%c0%c;\n", '"', '"');
fprintf(fADL, " attenuation1=%c0%c;\n", '"', '"');
fprintf(fADL, " attenuation2=%c1.0%c;\n", '"', '"');
break;
}
char range[20];
my_ftoa(far_radius, range);
fprintf(fADL, " max_range=%c%s%c;\n", '"', range, '"');
fprintf(fADL, " }\n\n");
}
fprintf(fTXT, "\n\n\n----------------------------------------------------\n");
}
/*
* PURPOSE: Runs various commands for the operations to be performed on the matrices
* INPUTS: command array, matrix array, size of matrix array
* RETURN: Nothing
**/
void run_commands (Commands_t* cmd, Matrix_t** mats, unsigned int num_mats) {
if(cmd == NULL || mats == NULL || num_mats <= 0)
return;
/*Parsing and calling of commands*/
if (strncmp(cmd->cmds[0],"display",strlen("display") + 1) == 0
&& cmd->num_cmds == 2) {
/*find the requested matrix*/
int idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
if (idx >= 0) {
display_matrix (mats[idx]);
}
else {
printf("Matrix (%s) doesn't exist\n", cmd->cmds[1]);
return;
}
}
else if (strncmp(cmd->cmds[0],"add",strlen("add") + 1) == 0
&& cmd->num_cmds == 4) {
int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
int mat2_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[2]);
if (mat1_idx >= 0 && mat2_idx >= 0) {
Matrix_t* c = NULL;
if( !create_matrix (&c,cmd->cmds[3], mats[mat1_idx]->rows,
mats[mat1_idx]->cols)) {
printf("Failure to create the result Matrix (%s)\n", cmd->cmds[3]);
return;
}
if(add_matrix_to_array(mats,c, num_mats) == -1){
printf("Failed to add matrix to the array");
return;
}
if (! add_matrices(mats[mat1_idx], mats[mat2_idx],c) ) {
printf("Failure to add %s with %s into %s\n", mats[mat1_idx]->name, mats[mat2_idx]->name,c->name);
return;
}
}
}
else if (strncmp(cmd->cmds[0],"duplicate",strlen("duplicate") + 1) == 0
&& cmd->num_cmds == 3 && strlen(cmd->cmds[1]) + 1 <= MATRIX_NAME_LEN) {
int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
if (mat1_idx >= 0 ) {
Matrix_t* dup_mat = NULL;
if( !create_matrix (&dup_mat,cmd->cmds[2], mats[mat1_idx]->rows,
mats[mat1_idx]->cols)) {
return;
}
if(duplicate_matrix (mats[mat1_idx], dup_mat) == false){
printf("Duplication Failed\n");
return;
}
if(add_matrix_to_array(mats,dup_mat,num_mats) == -1){
printf("Failed to add matrix to array\n");
return;
}
printf ("Duplication of %s into %s finished\n", mats[mat1_idx]->name, cmd->cmds[2]);
}
else {
printf("Duplication Failed\n");
return;
}
}
else if (strncmp(cmd->cmds[0],"equal",strlen("equal") + 1) == 0
&& cmd->num_cmds == 3) {
int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
int mat2_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[2]);
if (mat1_idx >= 0 && mat2_idx >= 0) {
if ( equal_matrices(mats[mat1_idx],mats[mat2_idx]) ) {
printf("SAME DATA IN BOTH\n");
}
else {
printf("DIFFERENT DATA IN BOTH\n");
}
}
else {
printf("Equal Failed\n");
return;
}
}
else if (strncmp(cmd->cmds[0],"shift",strlen("shift") + 1) == 0
&& cmd->num_cmds == 4) {
int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
const int shift_value = atoi(cmd->cmds[3]);
if (mat1_idx <= 0 ) {
printf("Matrix shift failed\n");
return;
}
if(bitwise_shift_matrix(mats[mat1_idx],cmd->cmds[2][0], shift_value) == false){
printf("Matrix shift failed\n");
return;
}
else
printf("Matrix (%s) has been shifted by %d\n", mats[mat1_idx]->name, shift_value);
}
else if (strncmp(cmd->cmds[0],"read",strlen("read") + 1) == 0
&& cmd->num_cmds == 2) {
Matrix_t* new_matrix = NULL;
if(! read_matrix(cmd->cmds[1],&new_matrix)) {
printf("Read Failed\n");
return;
}
if(add_matrix_to_array(mats,new_matrix, num_mats) == -1){
printf("Failed to add matrix to the array");
;
}
printf("Matrix (%s) is read from the filesystem\n", cmd->cmds[1]);
}
else if (strncmp(cmd->cmds[0],"write",strlen("write") + 1) == 0
&& cmd->num_cmds == 2) {
int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
if(! write_matrix(mats[mat1_idx]->name,mats[mat1_idx])) {
printf("Write Failed\n");
return;
}
else {
printf("Matrix (%s) is wrote out to the filesystem\n", mats[mat1_idx]->name);
}
}
else if (strncmp(cmd->cmds[0], "create", strlen("create") + 1) == 0
&& strlen(cmd->cmds[1]) + 1 <= MATRIX_NAME_LEN && cmd->num_cmds == 4) {
Matrix_t* new_mat = NULL;
const unsigned int rows = atoi(cmd->cmds[2]);
const unsigned int cols = atoi(cmd->cmds[3]);
if(create_matrix(&new_mat,cmd->cmds[1],rows, cols) == false){
printf("Failed to create the matrix");
return;
}
if(add_matrix_to_array(mats,new_mat,num_mats) == -1){
printf("Failed to add matrix to the array");
return;
}
printf("Created Matrix (%s,%u,%u)\n", new_mat->name, new_mat->rows, new_mat->cols);
}
else if (strncmp(cmd->cmds[0], "random", strlen("random") + 1) == 0
&& cmd->num_cmds == 4) {
int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]);
const unsigned int start_range = atoi(cmd->cmds[2]);
const unsigned int end_range = atoi(cmd->cmds[3]);
if(random_matrix(mats[mat1_idx],start_range, end_range) == false){
printf("Failed to randomize\n");
return;//TODO ERROR CHECK NEEDED
}
printf("Matrix (%s) is randomized between %u %u\n", mats[mat1_idx]->name, start_range, end_range);
}
else {
printf("Not a command in this application\n");
}
}
void
make_spl(points_t * pts, spline_t * spl)
{
matrix_t *eqs= NULL;
double *x = pts->x;
double *y = pts->y;
double a = x[0];
double b = x[pts->n - 1];
int i, j, k;
int nb = pts->n - 3 > 10 ? 10 : pts->n - 3;
char *nbEnv= getenv( "APPROX_BASE_SIZE" );
if( nbEnv != NULL && atoi( nbEnv ) > 0 )
nb = atoi( nbEnv );
eqs = make_matrix(nb, nb + 1);
#ifdef DEBUG
#define TESTBASE 500
{
FILE *tst = fopen("debug_base_plot.txt", "w");
double dx = (b - a) / (TESTBASE - 1);
for( j= 0; j < nb; j++ )
xfi( a, b, nb, j, tst );
for (i = 0; i < TESTBASE; i++) {
fprintf(tst, "%g", a + i * dx);
for (j = 0; j < nb; j++) {
fprintf(tst, " %g", fi (a, b, nb, j, a + i * dx));
fprintf(tst, " %g", dfi (a, b, nb, j, a + i * dx));
fprintf(tst, " %g", d2fi(a, b, nb, j, a + i * dx));
fprintf(tst, " %g", d3fi(a, b, nb, j, a + i * dx));
}
fprintf(tst, "\n");
}
fclose(tst);
}
#endif
for (j = 0; j < nb; j++) {
for (i = 0; i < nb; i++)
for (k = 0; k < pts->n; k++)
add_to_entry_matrix(eqs, j, i, fi(a, b, nb, i, x[k]) * fi(a, b, nb, j, x[k]));
for (k = 0; k < pts->n; k++)
add_to_entry_matrix(eqs, j, nb, y[k] * fi(a, b, nb, j, x[k]));
}
#ifdef DEBUG
write_matrix(eqs, stdout);
#endif
if (piv_ge_solver(eqs)) {
spl->n = 0;
return;
}
#ifdef DEBUG
write_matrix(eqs, stdout);
#endif
if (alloc_spl(spl, nb) == 0) {
for (i = 0; i < spl->n; i++) {
double xx = spl->x[i] = a + i*(b-a)/(spl->n-1);
xx+= 10.0*DBL_EPSILON; // zabezpieczenie przed ulokowaniem punktu w poprzednim przedziale
spl->f[i] = 0;
spl->f1[i] = 0;
spl->f2[i] = 0;
spl->f3[i] = 0;
for (k = 0; k < nb; k++) {
double ck = get_entry_matrix(eqs, k, nb);
spl->f[i] += ck * fi (a, b, nb, k, xx);
spl->f1[i] += ck * dfi (a, b, nb, k, xx);
spl->f2[i] += ck * d2fi(a, b, nb, k, xx);
spl->f3[i] += ck * d3fi(a, b, nb, k, xx);
}
}
}
#ifdef DEBUG
{
FILE *tst = fopen("debug_spline_plot.txt", "w");
double dx = (b - a) / (TESTBASE - 1);
for (i = 0; i < TESTBASE; i++) {
double yi= 0;
double dyi= 0;
double d2yi= 0;
double d3yi= 0;
double xi= a + i * dx;
for( k= 0; k < nb; k++ ) {
yi += get_entry_matrix(eqs, k, nb) * fi(a, b, nb, k, xi);
dyi += get_entry_matrix(eqs, k, nb) * dfi(a, b, nb, k, xi);
d2yi += get_entry_matrix(eqs, k, nb) * d2fi(a, b, nb, k, xi);
d3yi += get_entry_matrix(eqs, k, nb) * d3fi(a, b, nb, k, xi);
}
fprintf(tst, "%g %g %g %g %g\n", xi, yi, dyi, d2yi, d3yi );
}
fclose(tst);
}
#endif
}
int main(int argc, char **argv)
{
char *rawfilename = NULL;
int numiter = 250;
int use_apc = 1;
int use_normalization = 0;
conjugrad_float_t lambda_single = F001; // 0.01
conjugrad_float_t lambda_pair = FInf;
conjugrad_float_t lambda_pair_factor = F02; // 0.2
int conjugrad_k = 5;
conjugrad_float_t conjugrad_eps = 0.01;
parse_option *optList, *thisOpt;
char *optstr;
char *old_optstr = malloc(1);
old_optstr[0] = 0;
optstr = concat("r:i:n:w:k:e:l:ARh?", old_optstr);
free(old_optstr);
#ifdef OPENMP
int numthreads = 1;
old_optstr = optstr;
optstr = concat("t:", optstr);
free(old_optstr);
#endif
#ifdef CUDA
int use_def_gpu = 0;
old_optstr = optstr;
optstr = concat("d:", optstr);
free(old_optstr);
#endif
#ifdef MSGPACK
char* msgpackfilename = NULL;
old_optstr = optstr;
optstr = concat("b:", optstr);
free(old_optstr);
#endif
optList = parseopt(argc, argv, optstr);
free(optstr);
char* msafilename = NULL;
char* matfilename = NULL;
char* initfilename = NULL;
conjugrad_float_t reweighting_threshold = F08; // 0.8
while(optList != NULL) {
thisOpt = optList;
optList = optList->next;
switch(thisOpt->option) {
#ifdef OPENMP
case 't':
numthreads = atoi(thisOpt->argument);
#ifdef CUDA
use_def_gpu = -1; // automatically disable GPU if number of threads specified
#endif
break;
#endif
#ifdef CUDA
case 'd':
use_def_gpu = atoi(thisOpt->argument);
break;
#endif
#ifdef MSGPACK
case 'b':
msgpackfilename = thisOpt->argument;
break;
#endif
case 'r':
rawfilename = thisOpt->argument;
break;
case 'i':
initfilename = thisOpt->argument;
break;
case 'n':
numiter = atoi(thisOpt->argument);
break;
case 'w':
reweighting_threshold = (conjugrad_float_t)atof(thisOpt->argument);
break;
case 'l':
lambda_pair_factor = (conjugrad_float_t)atof(thisOpt->argument);
break;
case 'k':
conjugrad_k = (int)atoi(thisOpt->argument);
break;
case 'e':
conjugrad_eps = (conjugrad_float_t)atof(thisOpt->argument);
break;
case 'A':
use_apc = 0;
break;
case 'R':
use_normalization = 1;
break;
case 'h':
case '?':
usage(argv[0], 1);
break;
case 0:
if(msafilename == NULL) {
msafilename = thisOpt->argument;
} else if(matfilename == NULL) {
matfilename = thisOpt->argument;
} else {
usage(argv[0], 0);
}
break;
default:
die("Unknown argument");
}
free(thisOpt);
}
if(msafilename == NULL || matfilename == NULL) {
usage(argv[0], 0);
}
FILE *msafile = fopen(msafilename, "r");
if( msafile == NULL) {
printf("Cannot open %s!\n\n", msafilename);
return 2;
}
#ifdef JANSSON
char* metafilename = malloc(2048);
snprintf(metafilename, 2048, "%s.meta.json", msafilename);
FILE *metafile = fopen(metafilename, "r");
json_t *meta;
if(metafile == NULL) {
// Cannot find .meta.json file - create new empty metadata
meta = meta_create();
} else {
// Load metadata from matfile.meta.json
meta = meta_read_json(metafile);
fclose(metafile);
}
json_object_set(meta, "method", json_string("ccmpred"));
json_t *meta_step = meta_add_step(meta, "ccmpred");
json_object_set(meta_step, "version", json_string(__VERSION));
json_t *meta_parameters = json_object();
json_object_set(meta_step, "parameters", meta_parameters);
json_t *meta_steps = json_array();
json_object_set(meta_step, "iterations", meta_steps);
json_t *meta_results = json_object();
json_object_set(meta_step, "results", meta_results);
#endif
int ncol, nrow;
unsigned char* msa = read_msa(msafile, &ncol, &nrow);
fclose(msafile);
int nsingle = ncol * (N_ALPHA - 1);
int nvar = nsingle + ncol * ncol * N_ALPHA * N_ALPHA;
int nsingle_padded = nsingle + N_ALPHA_PAD - (nsingle % N_ALPHA_PAD);
int nvar_padded = nsingle_padded + ncol * ncol * N_ALPHA * N_ALPHA_PAD;
#ifdef CURSES
bool color = detect_colors();
#else
bool color = false;
#endif
logo(color);
#ifdef CUDA
int num_devices, dev_ret;
struct cudaDeviceProp prop;
dev_ret = cudaGetDeviceCount(&num_devices);
if(dev_ret != CUDA_SUCCESS) {
num_devices = 0;
}
if(num_devices == 0) {
printf("No CUDA devices available, ");
use_def_gpu = -1;
} else if (use_def_gpu < -1 || use_def_gpu >= num_devices) {
printf("Error: %d is not a valid device number. Please choose a number between 0 and %d\n", use_def_gpu, num_devices - 1);
exit(1);
} else {
printf("Found %d CUDA devices, ", num_devices);
}
if (use_def_gpu != -1) {
cudaError_t err = cudaSetDevice(use_def_gpu);
if(cudaSuccess != err) {
printf("Error setting device: %d\n", err);
exit(1);
}
cudaGetDeviceProperties(&prop, use_def_gpu);
printf("using device #%d: %s\n", use_def_gpu, prop.name);
size_t mem_free, mem_total;
err = cudaMemGetInfo(&mem_free, &mem_total);
if(cudaSuccess != err) {
printf("Error getting memory info: %d\n", err);
exit(1);
}
size_t mem_needed = nrow * ncol * 2 + // MSAs
sizeof(conjugrad_float_t) * nrow * ncol * 2 + // PC, PCS
sizeof(conjugrad_float_t) * nrow * ncol * N_ALPHA_PAD + // PCN
sizeof(conjugrad_float_t) * nrow + // Weights
(sizeof(conjugrad_float_t) * ((N_ALPHA - 1) * ncol + ncol * ncol * N_ALPHA * N_ALPHA_PAD)) * 4;
setlocale(LC_NUMERIC, "");
printf("Total GPU RAM: %'17lu\n", mem_total);
printf("Free GPU RAM: %'17lu\n", mem_free);
printf("Needed GPU RAM: %'17lu ", mem_needed);
if(mem_needed <= mem_free) {
printf("✓\n");
} else {
printf("⚠\n");
}
#ifdef JANSSON
json_object_set(meta_parameters, "device", json_string("gpu"));
json_t* meta_gpu = json_object();
json_object_set(meta_parameters, "gpu_info", meta_gpu);
json_object_set(meta_gpu, "name", json_string(prop.name));
json_object_set(meta_gpu, "mem_total", json_integer(mem_total));
json_object_set(meta_gpu, "mem_free", json_integer(mem_free));
json_object_set(meta_gpu, "mem_needed", json_integer(mem_needed));
#endif
} else {
printf("using CPU");
#ifdef JANSSON
json_object_set(meta_parameters, "device", json_string("cpu"));
#endif
#ifdef OPENMP
printf(" (%d thread(s))", numthreads);
#ifdef JANSSON
json_object_set(meta_parameters, "cpu_threads", json_integer(numthreads));
#endif
#endif
printf("\n");
}
#else // CUDA
printf("using CPU");
#ifdef JANSSON
json_object_set(meta_parameters, "device", json_string("cpu"));
#endif
#ifdef OPENMP
printf(" (%d thread(s))\n", numthreads);
#ifdef JANSSON
json_object_set(meta_parameters, "cpu_threads", json_integer(numthreads));
#endif
#endif // OPENMP
printf("\n");
#endif // CUDA
conjugrad_float_t *x = conjugrad_malloc(nvar_padded);
if( x == NULL) {
die("ERROR: Not enough memory to allocate variables!");
}
memset(x, 0, sizeof(conjugrad_float_t) * nvar_padded);
// Auto-set lambda_pair
if(isnan(lambda_pair)) {
lambda_pair = lambda_pair_factor * (ncol - 1);
}
// fill up user data struct for passing to evaluate
userdata *ud = (userdata *)malloc( sizeof(userdata) );
if(ud == 0) { die("Cannot allocate memory for user data!"); }
ud->msa = msa;
ud->ncol = ncol;
ud->nrow = nrow;
ud->nsingle = nsingle;
ud->nvar = nvar;
ud->lambda_single = lambda_single;
ud->lambda_pair = lambda_pair;
ud->weights = conjugrad_malloc(nrow);
ud->reweighting_threshold = reweighting_threshold;
if(initfilename == NULL) {
// Initialize emissions to pwm
init_bias(x, ud);
} else {
// Load potentials from file
read_raw(initfilename, ud, x);
}
// optimize with default parameters
conjugrad_parameter_t *param = conjugrad_init();
param->max_iterations = numiter;
param->epsilon = conjugrad_eps;
param->k = conjugrad_k;
param->max_linesearch = 5;
param->alpha_mul = F05;
param->ftol = 1e-4;
param->wolfe = F02;
int (*init)(void *) = init_cpu;
int (*destroy)(void *) = destroy_cpu;
conjugrad_evaluate_t evaluate = evaluate_cpu;
#ifdef OPENMP
omp_set_num_threads(numthreads);
if(numthreads > 1) {
init = init_cpu_omp;
destroy = destroy_cpu_omp;
evaluate = evaluate_cpu_omp;
}
#endif
#ifdef CUDA
if(use_def_gpu != -1) {
init = init_cuda;
destroy = destroy_cuda;
evaluate = evaluate_cuda;
}
#endif
init(ud);
#ifdef JANSSON
json_object_set(meta_parameters, "reweighting_threshold", json_real(ud->reweighting_threshold));
json_object_set(meta_parameters, "apc", json_boolean(use_apc));
json_object_set(meta_parameters, "normalization", json_boolean(use_normalization));
json_t *meta_regularization = json_object();
json_object_set(meta_parameters, "regularization", meta_regularization);
json_object_set(meta_regularization, "type", json_string("l2"));
json_object_set(meta_regularization, "lambda_single", json_real(lambda_single));
json_object_set(meta_regularization, "lambda_pair", json_real(lambda_pair));
json_object_set(meta_regularization, "lambda_pair_factor", json_real(lambda_pair_factor));
json_t *meta_opt = json_object();
json_object_set(meta_parameters, "optimization", meta_opt);
json_object_set(meta_opt, "method", json_string("libconjugrad"));
json_object_set(meta_opt, "float_bits", json_integer((int)sizeof(conjugrad_float_t) * 8));
json_object_set(meta_opt, "max_iterations", json_integer(param->max_iterations));
json_object_set(meta_opt, "max_linesearch", json_integer(param->max_linesearch));
json_object_set(meta_opt, "alpha_mul", json_real(param->alpha_mul));
json_object_set(meta_opt, "ftol", json_real(param->ftol));
json_object_set(meta_opt, "wolfe", json_real(param->wolfe));
json_t *meta_msafile = meta_file_from_path(msafilename);
json_object_set(meta_parameters, "msafile", meta_msafile);
json_object_set(meta_msafile, "ncol", json_integer(ncol));
json_object_set(meta_msafile, "nrow", json_integer(nrow));
if(initfilename != NULL) {
json_t *meta_initfile = meta_file_from_path(initfilename);
json_object_set(meta_parameters, "initfile", meta_initfile);
json_object_set(meta_initfile, "ncol", json_integer(ncol));
json_object_set(meta_initfile, "nrow", json_integer(nrow));
}
double neff = 0;
for(int i = 0; i < nrow; i++) {
neff += ud->weights[i];
}
json_object_set(meta_msafile, "neff", json_real(neff));
ud->meta_steps = meta_steps;
#endif
printf("\nWill optimize %d %ld-bit variables\n\n", nvar, sizeof(conjugrad_float_t) * 8);
if(color) { printf("\x1b[1m"); }
printf("iter\teval\tf(x) \t║x║ \t║g║ \tstep\n");
if(color) { printf("\x1b[0m"); }
conjugrad_float_t fx;
int ret;
#ifdef CUDA
if(use_def_gpu != -1) {
conjugrad_float_t *d_x;
cudaError_t err = cudaMalloc((void **) &d_x, sizeof(conjugrad_float_t) * nvar_padded);
if (cudaSuccess != err) {
printf("CUDA error No. %d while allocation memory for d_x\n", err);
exit(1);
}
err = cudaMemcpy(d_x, x, sizeof(conjugrad_float_t) * nvar_padded, cudaMemcpyHostToDevice);
if (cudaSuccess != err) {
printf("CUDA error No. %d while copying parameters to GPU\n", err);
exit(1);
}
ret = conjugrad_gpu(nvar_padded, d_x, &fx, evaluate, progress, ud, param);
err = cudaMemcpy(x, d_x, sizeof(conjugrad_float_t) * nvar_padded, cudaMemcpyDeviceToHost);
if (cudaSuccess != err) {
printf("CUDA error No. %d while copying parameters back to CPU\n", err);
exit(1);
}
err = cudaFree(d_x);
if (cudaSuccess != err) {
printf("CUDA error No. %d while freeing memory for d_x\n", err);
exit(1);
}
} else {
ret = conjugrad(nvar_padded, x, &fx, evaluate, progress, ud, param);
}
#else
ret = conjugrad(nvar_padded, x, &fx, evaluate, progress, ud, param);
#endif
printf("\n");
printf("%s with status code %d - ", (ret < 0 ? "Exit" : "Done"), ret);
if(ret == CONJUGRAD_SUCCESS) {
printf("Success!\n");
} else if(ret == CONJUGRAD_ALREADY_MINIMIZED) {
printf("Already minimized!\n");
} else if(ret == CONJUGRADERR_MAXIMUMITERATION) {
printf("Maximum number of iterations reached.\n");
} else {
printf("Unknown status code!\n");
}
printf("\nFinal fx = %f\n\n", fx);
FILE* out = fopen(matfilename, "w");
if(out == NULL) {
printf("Cannot open %s for writing!\n\n", matfilename);
return 3;
}
conjugrad_float_t *outmat = conjugrad_malloc(ncol * ncol);
FILE *rawfile = NULL;
if(rawfilename != NULL) {
printf("Writing raw output to %s\n", rawfilename);
rawfile = fopen(rawfilename, "w");
if(rawfile == NULL) {
printf("Cannot open %s for writing!\n\n", rawfilename);
return 4;
}
write_raw(rawfile, x, ncol);
}
#ifdef MSGPACK
FILE *msgpackfile = NULL;
if(msgpackfilename != NULL) {
printf("Writing msgpack raw output to %s\n", msgpackfilename);
msgpackfile = fopen(msgpackfilename, "w");
if(msgpackfile == NULL) {
printf("Cannot open %s for writing!\n\n", msgpackfilename);
return 4;
}
#ifndef JANSSON
void *meta = NULL;
#endif
}
#endif
sum_submatrices(x, outmat, ncol);
if(use_apc) {
apc(outmat, ncol);
}
if(use_normalization) {
normalize(outmat, ncol);
}
write_matrix(out, outmat, ncol, ncol);
#ifdef JANSSON
json_object_set(meta_results, "fx_final", json_real(fx));
json_object_set(meta_results, "num_iterations", json_integer(json_array_size(meta_steps)));
json_object_set(meta_results, "opt_code", json_integer(ret));
json_t *meta_matfile = meta_file_from_path(matfilename);
json_object_set(meta_results, "matfile", meta_matfile);
if(rawfilename != NULL) {
json_object_set(meta_results, "rawfile", meta_file_from_path(rawfilename));
}
if(msgpackfilename != NULL) {
json_object_set(meta_results, "msgpackfile", meta_file_from_path(msgpackfilename));
}
fprintf(out, "#>META> %s", json_dumps(meta, JSON_COMPACT));
if(rawfile != NULL) {
fprintf(rawfile, "#>META> %s", json_dumps(meta, JSON_COMPACT));
}
#endif
if(rawfile != NULL) {
fclose(rawfile);
}
#ifdef MSGPACK
if(msgpackfile != NULL) {
write_raw_msgpack(msgpackfile, x, ncol, meta);
fclose(msgpackfile);
}
#endif
fflush(out);
fclose(out);
destroy(ud);
conjugrad_free(outmat);
conjugrad_free(x);
conjugrad_free(ud->weights);
free(ud);
free(msa);
free(param);
printf("Output can be found in %s\n", matfilename);
return 0;
}