/***********************************************************************
* Copy a motif from one place to another.
***********************************************************************/
void copy_motif
(MOTIF_T* source,
MOTIF_T* dest)
{
strcpy(dest->id, source->id);
strcpy(dest->id2, source->id2);
dest->length = source->length;
dest->alph_size = source->alph_size;
dest->ambigs = source->ambigs;
dest->evalue = source->evalue;
dest->num_sites = source->num_sites;
dest->complexity = source->complexity;
dest->trim_left = source->trim_left;
dest->trim_right = source->trim_right;
if (source->freqs) {
// Allocate memory for the matrix.
dest->freqs = allocate_matrix(dest->length, dest->alph_size + dest->ambigs);
// Copy the matrix.
copy_matrix(source->freqs, dest->freqs);
} else {
dest->freqs = NULL;
}
if (source->scores) {
// Allocate memory for the matrix. Note that scores don't contain ambigs.
dest->scores = allocate_matrix(get_num_rows(source->scores), get_num_cols(source->scores));
// Copy the matrix.
copy_matrix(source->scores, dest->scores);
} else {
dest->scores = NULL;
}
copy_string(&(dest->url), source->url);
}
/*****************************************************************************
* MEME > motifs > motif
* Construct the skeleton of a motif.
****************************************************************************/
void mxml_start_motif(void *ctx, char *id, char *name, char *alt, int width, double sites,
double llr, double ic, double re, double bayes_threshold,
double log10_evalue, double elapsed_time, char *url) {
CTX_T *data;
MOTIF_T *motif;
data = (CTX_T*)ctx;
data->mscope.motif = mm_malloc(sizeof(MOTIF_T));
motif = data->mscope.motif;
memset(motif, 0, sizeof(MOTIF_T));
set_motif_id(name, strlen(name), motif);
set_motif_id2(alt, sizeof(alt), motif);
set_motif_strand('+', motif);
motif->length = width;
motif->num_sites = sites;
motif->url = strdup(url);
motif->log_evalue = log10_evalue;
motif->evalue = pow(10.0, log10_evalue);
// calculate alphabet size
motif->alph = alph_hold(data->alph);
motif->flags = (data->fscope.strands == 2 ? MOTIF_BOTH_STRANDS : 0);
// allocate matricies
motif->freqs = allocate_matrix(motif->length, alph_size_core(motif->alph));
init_matrix(-1, motif->freqs);
motif->scores = allocate_matrix(motif->length, alph_size_core(motif->alph));
init_matrix(NO_SCORE, motif->scores);
// should be set by a post processing method
motif->complexity = -1;
motif->trim_left = 0;
motif->trim_right = 0;
// cache motif position
if (data->options & SCANNED_SITES) {
rbtree_put(data->motif_lookup, id, &(data->current_motif));
}
}
main()
{
clock_t start, stop;
a = allocate_matrix( NUM );
b = allocate_matrix( NUM );
c = allocate_matrix( NUM );
d = allocate_matrix( NUM );
printf("Address a = %x\n", a );
printf("Address b = %x\n", b );
printf("Address c = %x\n", c );
// initialize the arrays with data
init_arr(3,-2,1,a);
init_arr(-2,1,3,b);
//start timing the matrix multiply code
start = clock();
multiply_mt();
stop = clock();
// print elapsed time
printf("Elapsed time = %lf seconds\n",
((double)(stop - start)) / CLOCKS_PER_SEC);
free_matrix( a );
free_matrix( b );
free_matrix( c );
free_matrix( d );
}
// ----------------------------------------------------------------
// Randomly populates lattice bonds, marks all clusters, and determines whether
// the center site is in the largest cluster. Plots the result to the screen.
// One may then visually verify the membership computation.
static void test_A_in_C(int argc, char** argv)
{
int M = 18;
int N = 18;
double p = 0.6;
int print_lattice = 0;
int argi;
int** vbonds;
int** hbonds;
int** site_marks;
int num_clusters;
int* cluster_sizes;
int C_clno; // Number of largest cluster
int A[d], A_clno;
for (argi = 2; argi < argc; argi++) {
if (sscanf(argv[argi], "M=%d", &M) == 1)
;
else if (sscanf(argv[argi], "N=%d", &N) == 1)
;
else if (sscanf(argv[argi], "MN=%d", &M) == 1)
N = M;
else if (sscanf(argv[argi], "p=%lf", &p) == 1)
;
else if (sscanf(argv[argi], "pl=%d", &print_lattice) == 1)
;
else
usage(argv[0], argv[1], 0);
}
if ((M < 3) || (N < 3))
usage(argv[0], argv[1], 1);
vbonds = allocate_matrix(M, N, 0);
hbonds = allocate_matrix(M, N, 0);
site_marks = allocate_matrix(M, N, SITECHAR);
set_A1(A, M, N);
populate_bonds(vbonds, hbonds, M, N, p);
mark_cluster_numbers(site_marks, vbonds, hbonds, M, N, &num_clusters);
if (print_lattice)
print_lattice_and_cluster_numbers(site_marks, vbonds, hbonds, M, N);
sanity_check_cluster_numbers(site_marks, vbonds, hbonds, M, N);
cluster_sizes = (int*)malloc_or_die(sizeof(int) * num_clusters);
get_cluster_sizes(site_marks, M, N, num_clusters, cluster_sizes,
&C_clno);
A_clno = site_marks[A[0]][A[1]];
if (print_lattice) {
printf("A at %d, %d\n", A[0], A[1]);
printf("A cluster number = %d\n", A_clno);
printf("Largest cluster = %d\n", C_clno);
}
printf("%s\n", (A_clno == C_clno) ? "Yes" : "No");
free_matrix(vbonds, M, N);
free_matrix(hbonds, M, N);
free_matrix(site_marks, M, N);
free(cluster_sizes);
}
// ----------------------------------------------------------------
// Randomly populates lattice bonds, marks all clusters, and computes cluster
// sizes. One may then visually verify the cluster-size computation.
static void test_cluster_sizes(int argc, char** argv)
{
int M = 18;
int N = 18;
double p = 0.6;
int print_lattice = 0;
int argi;
int** vbonds;
int** hbonds;
int** site_marks;
int num_clusters;
int* cluster_sizes;
int C_clno; // Number of largest cluster
int k;
for (argi = 2; argi < argc; argi++) {
if (sscanf(argv[argi], "M=%d", &M) == 1)
;
else if (sscanf(argv[argi], "N=%d", &N) == 1)
;
else if (sscanf(argv[argi], "MN=%d", &M) == 1)
N = M;
else if (sscanf(argv[argi], "p=%lf", &p) == 1)
;
else if (sscanf(argv[argi], "pl=%d", &print_lattice) == 1)
;
else
usage(argv[0], argv[1], 0);
}
if ((M < 3) || (N < 3))
usage(argv[0], argv[1], 1);
vbonds = allocate_matrix(M, N, 0);
hbonds = allocate_matrix(M, N, 0);
site_marks = allocate_matrix(M, N, SITECHAR);
populate_bonds(vbonds, hbonds, M, N, p);
mark_cluster_numbers(site_marks, vbonds, hbonds, M, N, &num_clusters);
if (print_lattice)
print_lattice_and_cluster_numbers(site_marks, vbonds, hbonds, M, N);
sanity_check_cluster_numbers(site_marks, vbonds, hbonds, M, N);
cluster_sizes = (int*)malloc_or_die(sizeof(int) * num_clusters);
get_cluster_sizes(site_marks, M, N, num_clusters, cluster_sizes,
&C_clno);
for (k = 0; k < num_clusters; k++) {
printf("Cluster %3d", k);
printf(" size %6d %7.4lf", cluster_sizes[k],
(double)cluster_sizes[k]/(double)M/(double)N);
if (k == C_clno)
printf(" *");
printf("\n");
}
free_matrix(vbonds, M, N);
free_matrix(hbonds, M, N);
free_matrix(site_marks, M, N);
free(cluster_sizes);
}
extern MATRIX_T* gen_pam_matrix(
ALPH_T alph, /* alphabet */
int dist, /* PAM distance */
BOOLEAN_T logodds /* true: generate log-odds matrix
false: generate target frequency matrix
*/
)
{
assert(alph == DNA_ALPH || alph == PROTEIN_ALPH);
int i, j;
MATRIX_T *matrix, *mul;
BOOLEAN_T dna = (alph == DNA_ALPH);
double *pfreq = dna ? pam_dna_freq : pam_prot_freq; // standard frequencies
int alen = alph_size(alph, ALPH_SIZE); // length of standard alphabet
double factor = dist < 170 ? 2/log(2) : 3/log(2); // same as in "pam" Version 1.0.6
/* create the array for the joint probability matrix */
matrix = allocate_matrix(alen, alen);
mul = allocate_matrix(alen, alen);
/* initialize the matrix: PAM 1:
due to roundoff, take the average of the two estimates of the joint frequency
of i and j as the joint, then compute the conditionals for the matrix
*/
for (i=0; i<alen; i++) {
for (j=0; j<=i; j++) {
double vij = dna ? trans[i][j] : dayhoff[i][j];
double vji = dna ? trans[j][i] : dayhoff[j][i];
double joint = ((vij * pfreq[j]) + (vji * pfreq[i]))/20000;/* use average to fix rndoff */
set_matrix_cell(i, j, joint/pfreq[j], matrix);
if (i!=j) set_matrix_cell(j, i, joint/pfreq[i], matrix);
}
}
/* take PAM matrix to desired power to scale it */
copy_matrix(matrix, mul);
for (i=dist; i>1; i--) {
MATRIX_T *product = matrix_multiply(matrix, mul);
SWAP(MATRIX_T*, product, matrix)
free_matrix(product);
}
free_matrix(mul);
/* convert to joint or logodds matrix:
target: J_ij = Pr(i,j) = Mij pr(j)
logodds: L_ij = log (Pr(i,j)/(Pr(i)Pr(j)) = log (Mij Pr(j)/Pr(i)Pr(j)) = log(Mij/pr(i))
*/
for (i=0; i<alen; i++) {
for (j=0; j<alen; j++) {
double vij = get_matrix_cell(i, j, matrix);
vij = logodds ? nint(factor * log((vij+EPSILON)/pfreq[i])) : vij * pfreq[j];
set_matrix_cell(i, j, vij, matrix);
}
}
return matrix;
} /* gen_pam_matrix */
// ----------------------------------------------------------------
// Randomly populates lattice bonds, prints the lattice, and lists the bonded
// neighbors of the center site. One may then visually verify the
// identification of neighbors.
static void test_get_bonded_neighbors(int argc, char** argv)
{
int M = 18;
int N = 18;
double p = 0.6;
int argi;
int** vbonds;
int** hbonds;
int** site_marks;
int A1[d];
int A2[d];
int neighbors[MAXNEI][d];
int numnei;
int k;
for (argi = 2; argi < argc; argi++) {
if (sscanf(argv[argi], "M=%d", &M) == 1)
;
else if (sscanf(argv[argi], "N=%d", &N) == 1)
;
else if (sscanf(argv[argi], "MN=%d", &M) == 1)
N = M;
else if (sscanf(argv[argi], "p=%lf", &p) == 1)
;
else
usage(argv[0], argv[1], 0);
}
if ((M < 3) || (N < 3))
usage(argv[0], argv[1], 1);
vbonds = allocate_matrix(M, N, 0);
hbonds = allocate_matrix(M, N, 0);
site_marks = allocate_matrix(M, N, SITECHAR);
set_A1_A2(A1, A2, M, N);
populate_bonds(vbonds, hbonds, M, N, p);
print_lattice(site_marks, vbonds, hbonds, M, N, A1, A2);
printf("\n");
get_bonded_neighbors(vbonds, hbonds, M, N, A1, neighbors, &numnei);
printf("Bonded neighbors of A1 at (%d, %d):\n", A1[0], A1[1]);
if (numnei == 0)
printf("(none)\n");
for (k = 0; k < numnei; k++) {
printf(" ( %3d, %3d )\n", neighbors[k][0], neighbors[k][1]);
}
free_matrix(vbonds, M, N);
free_matrix(hbonds, M, N);
free_matrix(site_marks, M, N);
}
// ----------------------------------------------------------------
// Randomly populates lattice bonds, marks the cluster containing the center
// site, and plots the results as a PPM file. One may then visually verify
// the cluster-marking computation.
static void test_plot_cluster(int argc, char** argv)
{
int M = 200;
int N = 200;
double p = 0.6;
int argi;
int** vbonds;
int** hbonds;
int** site_marks;
int A1[d];
int A2[d];
char* image_file_name = "p2.ppm";
int compact = 0;
for (argi = 2; argi < argc; argi++) {
if (sscanf(argv[argi], "M=%d", &M) == 1)
;
else if (sscanf(argv[argi], "N=%d", &N) == 1)
;
else if (sscanf(argv[argi], "MN=%d", &M) == 1)
N = M;
else if (sscanf(argv[argi], "p=%lf", &p) == 1)
;
else if (strncmp(argv[argi], "f=", 2) == 0)
image_file_name = &argv[argi][2];
else if (sscanf(argv[argi], "c=%d", &compact) == 1)
;
else
usage(argv[0], argv[1], 0);
}
if ((M < 3) || (N < 3))
usage(argv[0], argv[1], 1);
vbonds = allocate_matrix(M, N, 0);
hbonds = allocate_matrix(M, N, 0);
site_marks = allocate_matrix(M, N, SITECHAR);
set_A1_A2(A1, A2, M, N);
populate_bonds(vbonds, hbonds, M, N, p);
mark_one_cluster(site_marks, vbonds, hbonds, M, N, A1, VISITEDCHAR);
if (compact)
plot_one_cluster_compactly(site_marks, vbonds, hbonds, M, N,
A1, A2, image_file_name);
else
plot_lattice_and_one_cluster(site_marks, vbonds, hbonds, M, N,
A1, A2, image_file_name);
printf("Wrote %s.\n", image_file_name);
free_matrix(vbonds, M, N);
free_matrix(hbonds, M, N);
free_matrix(site_marks, M, N);
}
// ----------------------------------------------------------------
// Randomly populates lattice bonds and plots it to the screen using ASCII art.
static void test_print_lattice(int argc, char** argv)
{
int M = 18;
int N = 18;
double p = 0.6;
int argi;
int** vbonds;
int** hbonds;
int** site_marks;
int A1[d];
int A2[d];
// Parse the command line.
for (argi = 2; argi < argc; argi++) {
if (sscanf(argv[argi], "M=%d", &M) == 1)
;
else if (sscanf(argv[argi], "N=%d", &N) == 1)
;
else if (sscanf(argv[argi], "MN=%d", &M) == 1)
N = M;
else if (sscanf(argv[argi], "p=%lf", &p) == 1)
;
else
usage(argv[0], argv[1], 0);
}
// Validate parameters.
if ((M < 3) || (N < 3))
usage(argv[0], argv[1], 1);
// Allocate storage for the lattice.
vbonds = allocate_matrix(M, N, 0);
hbonds = allocate_matrix(M, N, 0);
site_marks = allocate_matrix(M, N, SITECHAR);
// Pick center points of the lattice.
set_A1_A2(A1, A2, M, N);
// Populate the bonds with probability p.
populate_bonds(vbonds, hbonds, M, N, p);
// Print the lattice.
print_lattice(site_marks, vbonds, hbonds, M, N, A1, A2);
// Free the lattice storage.
free_matrix(vbonds, M, N);
free_matrix(hbonds, M, N);
free_matrix(site_marks, M, N);
}
MATRIX_T *reorder_matrix(
const char *alpha1, /* current alphabet */
const char *alpha2, /* new alphabet; must be subset */
MATRIX_T *in_matrix /* matrix to reorder */
)
{
int i, j;
int alen1 = strlen(alpha1);
int alen2 = strlen(alpha2);
MATRIX_T *out_matrix;
if (alen2 > alen1)
die("The new alphabet %s must be a subset of the old alphabet %s.\n", alpha2, alpha1);
out_matrix = allocate_matrix(alen2, alen2);
for (i=0; i<alen2; i++) {
int ii = strchr(alpha1, alpha2[i]) - alpha1;
for (j=0; j<alen2; j++) {
int jj;
char *ptr = strchr(alpha1, alpha2[j]);
if (!ptr)
die("The new alphabet %s must be a subset of the old alphabet %s\n", alpha2, alpha1);
jj = ptr - alpha1;
set_matrix_cell(i, j, get_matrix_cell(ii, jj, in_matrix), out_matrix);
}
}
return(out_matrix);
} /* reorder_matrix */
TransitionParameters::TransitionParameters()
{
// initialize training data
TransitionTrainingData& td = training_data;
td.n_matches = 0;
td.n_merges = 0;
td.n_skips = 0;
//
allocate_matrix(td.state_transitions, 3, 3);
for(unsigned i = 0; i < td.state_transitions.n_rows; ++i) {
for(unsigned j = 0; j < td.state_transitions.n_cols; ++j) {
set(td.state_transitions, i, j, 0);
}
}
//
// Initialize transition parameters
//
// these are fixed across all models
skip_bin_width = 0.5;
skip_probabilities.resize(30);
trans_start_to_clip = 0.5f;
trans_clip_self = 0.90f;
}
void dxml_start_motif(void *ctx, char *id, char *seq, int length,
long num_sites, long p_hits, long n_hits,
double pvalue, double evalue, double uevalue) {
CTX_T *data;
MOTIF_T *motif;
data = (CTX_T*)ctx;
data->motif = (MOTIF_T*)mm_malloc(sizeof(MOTIF_T));
motif = data->motif;
memset(motif, 0, sizeof(MOTIF_T));
set_motif_id(seq, strlen(seq), motif);
set_motif_id2("", 0, motif);
set_motif_strand('+', motif);
motif->length = length;
motif->num_sites = num_sites;
motif->evalue = evalue;
// both DNA and RNA have 4 letters
motif->alph = data->fscope.alphabet;
motif->flags = MOTIF_BOTH_STRANDS; // DREME does not support the concept of single strand scanning (yet)
// allocate the matrix
motif->freqs = allocate_matrix(motif->length, alph_size(motif->alph, ALPH_SIZE));
motif->scores = NULL; // no scores in DREME xml
// no url in DREME
motif->url = strdup("");
// set by postprocessing
motif->complexity = -1;
motif->trim_left = 0;
motif->trim_right = 0;
}
/**************************************************************************
*
hash_pssm
Hash a PSSM (in place) where each n columns are combined into
a single column on the alphabet hashed to the nth power.
*
**************************************************************************/
void hash_pssm(
PSSM_T* pssm, // PSSM to hash
int n // hash n columns to 1
)
{
int w = get_pssm_w(pssm); // width of pssm
int alen = get_pssm_alphsize(pssm); // length of alphabet
int hashed_w = (w+n-1)/n; // width of hashed pssm
int hashed_alen = pow(alen+1, n) + 1; // length of hashed alphabet
// Allocate the hashed PSSM.
MATRIX_T* pssm_matrix = pssm->matrix;
MATRIX_T* hashed_pssm_matrix = allocate_matrix(hashed_w, hashed_alen);
int pos, hashed_pos;
for (pos=hashed_pos=0; pos<w; pos+=n, hashed_pos++) { // position in pssm
hash_pssm_matrix_pos(pssm_matrix, hashed_pssm_matrix, pos, hashed_pos, n, 0, 0);
} // position in pssm
free_matrix(pssm_matrix);
pssm->matrix = hashed_pssm_matrix;
pssm->w = hashed_w;
pssm->alphsize = hashed_alen;
} // hash_pssm
/******************************************************************************
* This function returns a copy of the matrix for time t of a transition
* matrix array. Returns NUL is no matrix is found matching time t.
* Caller is responsible for free the returned copy.
******************************************************************************/
MATRIX_T* get_substmatrix_for_time(
SUBSTMATRIX_ARRAY_T *a,
double t
) {
assert(a != NULL);
// Create a copy of our matrix
int i;
MATRIX_T* src = NULL;
for (i = 0; i < a->length; i++) {
if (a->t[i] == t) {
src = a->substmatrix[i];
break;
}
}
MATRIX_T* dst = NULL;
if (src != NULL) {
int num_rows = get_num_rows(src);
int num_cols = get_num_cols(src);
dst = allocate_matrix(num_rows, num_cols);
copy_matrix(src, dst);
}
return dst;
}
/************************************************************************
* See .h file for description.
************************************************************************/
MHMM_T* allocate_mhmm(ALPH_T* alph, int num_states) {
/* First allocate the struct itself. */
MHMM_T* an_mhmm = (MHMM_T*) mm_calloc(1, sizeof(MHMM_T));
/* Then allocate the states. */
an_mhmm->states
= (MHMM_STATE_T *) mm_calloc(num_states, sizeof(MHMM_STATE_T));
an_mhmm->num_states = num_states;
/* ... and the transition matrix. */
an_mhmm->trans = allocate_matrix(num_states, num_states);
/* Allocate the alphabet. */
an_mhmm->alph = alph_hold(alph);
// Allocate the background distribution.
an_mhmm->background = allocate_array(alph_size_full(an_mhmm->alph));
// Set other stuff to NULL.
an_mhmm->description = NULL;
an_mhmm->motif_file = NULL;
an_mhmm->sequence_file = NULL;
an_mhmm->hot_states = NULL;
an_mhmm->num_hot_states = 0;
return an_mhmm;
}
// ----------------------------------------------------------------
// Randomly populates lattice bonds and determines if there exists a path from
// the center site to the site diagonally below and to the right. One may then
// visually verify the path-detection computation.
static void test_A1_oo_A2(int argc, char** argv)
{
int M = 18;
int N = 18;
double p = 0.6;
int argi;
int** vbonds;
int** hbonds;
int** site_marks;
int A1[d];
int A2[d];
int ctd;
for (argi = 2; argi < argc; argi++) {
if (sscanf(argv[argi], "M=%d", &M) == 1)
;
else if (sscanf(argv[argi], "N=%d", &N) == 1)
;
else if (sscanf(argv[argi], "MN=%d", &M) == 1)
N = M;
else if (sscanf(argv[argi], "p=%lf", &p) == 1)
;
else
usage(argv[0], argv[1], 0);
}
if ((M < 3) || (N < 3))
usage(argv[0], argv[1], 1);
vbonds = allocate_matrix(M, N, 0);
hbonds = allocate_matrix(M, N, 0);
site_marks = allocate_matrix(M, N, SITECHAR);
set_A1_A2(A1, A2, M, N);
populate_bonds(vbonds, hbonds, M, N, p);
print_lattice(site_marks, vbonds, hbonds, M, N, A1, A2);
printf("\n");
ctd = A1_oo_A2(site_marks, vbonds, hbonds, M, N, A1, A2);
print_lattice(site_marks, vbonds, hbonds, M, N, A1, A2);
if (ctd)
printf("Yes\n");
else
printf("No\n");
free_matrix(vbonds, M, N);
free_matrix(hbonds, M, N);
free_matrix(site_marks, M, N);
}
// ----------------------------------------------------------------
// Over a specified number of repetitions: randomly populates lattice bonds,
// and (for p < p_c) computes the size of the largest cluster or (for p > p_c)
// computes the size of the second-largest cluster. Averages those over the
// number of lattice instantiations.
static void test_mean_finite_C0_size(int argc, char** argv)
{
int M = 18;
int N = 18;
double p = 0.6;
int reps = 1000;
int argi;
int** vbonds;
int** hbonds;
int** site_marks;
int A1[d];
int A2[d];
double mean_finite_C0_size;
for (argi = 2; argi < argc; argi++) {
if (sscanf(argv[argi], "M=%d", &M) == 1)
;
else if (sscanf(argv[argi], "N=%d", &N) == 1)
;
else if (sscanf(argv[argi], "MN=%d", &M) == 1)
N = M;
else if (sscanf(argv[argi], "p=%lf", &p) == 1)
;
else if (sscanf(argv[argi], "reps=%d", &reps) == 1)
;
else
usage(argv[0], argv[1], 1);
}
if ((M < 3) || (N < 3))
usage(argv[0], argv[1], 1);
vbonds = allocate_matrix(M, N, 0);
hbonds = allocate_matrix(M, N, 0);
site_marks = allocate_matrix(M, N, SITECHAR);
set_A1_A2(A1, A2, M, N);
mean_finite_C0_size = get_mean_finite_C0_size(
site_marks, vbonds, hbonds, M, N, p, reps, A1);
printf("M=%d N=%d p=%.4lf reps=%d <size>=%11.7lf <density>=%11.7lf\n",
M, N, p, reps, mean_finite_C0_size,
mean_finite_C0_size/M/N);
free_matrix(vbonds, M, N);
free_matrix(hbonds, M, N);
free_matrix(site_marks, M, N);
}
int main(int argc, char * argv[]) {
mtype_t * matrix = NULL ;
int i, MAX_SIZE;
double avg_time;
support_init();
MAX_ITERS = 100;
if(argc==2)
if(atoi(argv[1])>=2)
MAX_SIZE = atoi(argv[1]);
else{
printf("The argument must be an integer and larger than or equal to 2");
return -1;
}
else if(argc>2){
printf("This program takes one or no arguments, you entered too many.");
return -1;
}
else MAX_SIZE = 1024;
for ( i = 2; i <= MAX_SIZE; i = i * 2 ) {
// Allocate a matrix of size : buffer_side x buffer_side
allocate_matrix (& matrix , i );
// Clear / Initialize the matrix
clear_matrix (matrix , i );
avg_time = run_experiment_ij (matrix, 5.0, i);
printf("The average time to do scalar multiplication ij on a %d x %d matrix is %lf \n", i, i, avg_time);
}
printf("------------------------------------------------------------------------------\n");
for ( i = 2; i <= MAX_SIZE; i = i * 2 ) {
// Allocate a matrix of size : buffer_side x buffer_side
allocate_matrix (& matrix , i );
// Clear / Initialize the matrix
clear_matrix (matrix , i );
avg_time = run_experiment_ji (matrix, 5.0, i);
printf("The average time to do scalar multiplication ji on a %d x %d matrix is %lf \n", i, i, avg_time);
}
support_finalize();
return 0;
}
void work(int size)
{
matrix a, b, result1, result2, result3;
// Allocate memory for matrices
allocate_matrix(&a, size);
allocate_matrix(&b, size);
allocate_matrix(&result1, size);
//allocate_matrix(&result2, size) ;
allocate_matrix(&result3, size) ;
// Initialize matrix elements
init_matrix(a);
init_matrix(b);
init_matrix_zero(result1);
// Perform sequential matrix multiplication
mm(a, b, result1);
//init_matrix_zero(result2);
//mm_fast(a, b, result2) ;
//if (compare_matrix(result1, result2)==1)
// printf("true") ;
//free_matrix(result2);
init_matrix_zero(result3);
mm_block(a, b, result3) ;
if (compare_matrix(result1, result3)==1)
printf("true") ;
// Print the result1 matrix
// print_matrix(result1);
free_matrix(a);
free_matrix(b);
free_matrix(result1);
free_matrix(result3);
}
int main(int argc, char* argv[])
{
if(argc!=5){
fprintf(stderr,"USAGE:\n\t%s <input file> <num steps> <output file> <max number of threads> \n", argv[0]);
fprintf(stderr, "EXAMPLE:\n\t%s random.txt 500 result.txt 8\n", argv[0]);
exit(EXIT_FAILURE);
}
char* init_fname = argv[1];
sscanf(argv[2],"%d", &steps);
char* out_fname = argv[3];
int max_n_threads = atoi(argv[4]);
long time_vs_threads[max_n_threads+1];
int tmp[max_n_threads];
threads_arg=tmp;
char** init_matrix = dump_matrix_file(init_fname);
char** zero_matrix = allocate_matrix(width, height);
matrix_from = allocate_matrix(width, height);
matrix_to = allocate_matrix(width, height);
// run by different number of threads, and measure the time
for(n_threads=1; n_threads <= max_n_threads; n_threads++){
copy_matrix(init_matrix, matrix_from, width+2, height+2);
copy_matrix(zero_matrix, matrix_to, width+2, height+2);
time_vs_threads[n_threads] = walltime_of_threads(n_threads);
printf("walltime when run by %d threads: %d microseconds\n", n_threads, time_vs_threads[n_threads]);
}
save_matrix_file(out_fname, matrix_from,width,height);
char time_fname[20];
sprintf(time_fname,"time-%d-%d.txt",width,height);
save_vector(time_fname, time_vs_threads+1, max_n_threads);
free_matrix(zero_matrix,width,height);
free_matrix(init_matrix,width,height);
free_matrix(matrix_from,width,height);
free_matrix(matrix_to,width,height);
return 0;
}
// ----------------------------------------------------------------
// For given lattice dimensions and bond density, estimates the probability
// that there exists a path from the center site to the site diagonally below
// and to the right.
static void test_P_A1_oo_A2(int argc, char** argv)
{
int M = 18;
int N = 18;
double p = 0.6;
int reps = 1000;
int argi;
int** vbonds;
int** hbonds;
int** site_marks;
int A1[d];
int A2[d];
double P;
for (argi = 2; argi < argc; argi++) {
if (sscanf(argv[argi], "M=%d", &M) == 1)
;
else if (sscanf(argv[argi], "N=%d", &N) == 1)
;
else if (sscanf(argv[argi], "MN=%d", &M) == 1)
N = M;
else if (sscanf(argv[argi], "p=%lf", &p) == 1)
;
else if (sscanf(argv[argi], "reps=%d", &reps) == 1)
;
else
usage(argv[0], argv[1], 1);
}
if ((M < 3) || (N < 3))
usage(argv[0], argv[1], 1);
vbonds = allocate_matrix(M, N, 0);
hbonds = allocate_matrix(M, N, 0);
site_marks = allocate_matrix(M, N, SITECHAR);
set_A1_A2(A1, A2, M, N);
P = P_A1_oo_A2(site_marks, vbonds, hbonds, M, N, p, reps, A1, A2);
printf("M=%d N=%d p=%.4lf reps=%d PA1ooA2=%11.7lf\n", M, N, p, reps, P);
free_matrix(vbonds, M, N);
free_matrix(hbonds, M, N);
free_matrix(site_marks, M, N);
}
// ----------------------------------------------------------------
// Randomly populates lattice bonds and marks all clusters, plotting the
// results to the screen. One may then visually verify the path-detection
// computation.
static void test_cluster_numbers(int argc, char** argv)
{
int M = 18;
int N = 18;
double p = 0.6;
int argi;
int** vbonds;
int** hbonds;
int** site_marks;
int A1[d] = {-1, -1}; // Not used here
int A2[d] = {-1, -1}; // Not used here
for (argi = 2; argi < argc; argi++) {
if (sscanf(argv[argi], "M=%d", &M) == 1)
;
else if (sscanf(argv[argi], "N=%d", &N) == 1)
;
else if (sscanf(argv[argi], "MN=%d", &M) == 1)
N = M;
else if (sscanf(argv[argi], "p=%lf", &p) == 1)
;
else
usage(argv[0], argv[1], 0);
}
if ((M < 3) || (N < 3))
usage(argv[0], argv[1], 1);
vbonds = allocate_matrix(M, N, 0);
hbonds = allocate_matrix(M, N, 0);
site_marks = allocate_matrix(M, N, SITECHAR);
populate_bonds(vbonds, hbonds, M, N, p);
print_lattice(site_marks, vbonds, hbonds, M, N, A1, A2);
printf("\n");
mark_cluster_numbers(site_marks, vbonds, hbonds, M, N, 0);
print_lattice_and_cluster_numbers(site_marks, vbonds, hbonds, M, N);
sanity_check_cluster_numbers(site_marks, vbonds, hbonds, M, N);
free_matrix(vbonds, M, N);
free_matrix(hbonds, M, N);
free_matrix(site_marks, M, N);
}
void read_matrix_binaryformat (char* filename, double*** matrix, int* num_rows, int* num_cols) {
int i;
FILE* fp = fopen (filename,"rb");
fread (num_rows, sizeof(int), 1, fp);
fread (num_cols, sizeof(int), 1, fp);
allocate_matrix(matrix,(*num_rows),(*num_cols));
/* read in the entire matrix */
fread ((*matrix)[0], sizeof(double), (*num_rows)*(*num_cols), fp);
fclose (fp);
}
/***********************************************************************
* Copy a motif from one place to another.
***********************************************************************/
void copy_motif
(MOTIF_T* source,
MOTIF_T* dest)
{
ALPH_SIZE_T size;
memset(dest, 0, sizeof(MOTIF_T));
strcpy(dest->id, source->id);
strcpy(dest->id2, source->id2);
dest->length = source->length;
dest->alph = source->alph;
dest->flags = source->flags;
dest->evalue = source->evalue;
dest->num_sites = source->num_sites;
dest->complexity = source->complexity;
dest->trim_left = source->trim_left;
dest->trim_right = source->trim_right;
if (source->freqs) {
size = (dest->flags & MOTIF_HAS_AMBIGS ? ALL_SIZE : ALPH_SIZE);
// Allocate memory for the matrix.
dest->freqs = allocate_matrix(dest->length, alph_size(dest->alph, size));
// Copy the matrix.
copy_matrix(source->freqs, dest->freqs);
} else {
dest->freqs = NULL;
}
if (source->scores) {
// Allocate memory for the matrix. Note that scores don't contain ambigs.
dest->scores = allocate_matrix(dest->length, alph_size(dest->alph, ALPH_SIZE));
// Copy the matrix.
copy_matrix(source->scores, dest->scores);
} else {
dest->scores = NULL;
}
if (dest->url != NULL) {
free(dest->url);
dest->url = NULL;
}
copy_string(&(dest->url), source->url);
}
short evaluate_black(struct board *board)
{
short key,oracle;
register x;
char **matrix;
short i,*bpos;
board->sp=0;
board->intgp.j=0;
board->intgp.k=0;
memset(board->sqused,0xff,(BOARDX+1)*(BOARDY+2)*sizeof(short));
for(i=0;i<GROUPS;i++)
{
if(threat_group(board,i,BLACK))
{
board->intgp.tgroups[i]=YES;
board->intgp.j++;
}
else board->intgp.tgroups[i]=NO;
if(threat_group(board,i,WHITE))
{
board->intgp.mygroups[i]=YES;
board->intgp.k++;
}
else board->intgp.mygroups[i]=NO;
}
claimeven(board);
baseinverse(board);
vertical(board);
aftereven(board);
lowinverse(board);
highinverse(board);
baseclaim(board);
before(board);
if(board->intgp.j==0) return YES;
if(board->sp==0) return NO;
matrix=(char **)allocate_matrix(board);
build_adjacency_matrix(matrix,board);
oracle=problem_solver(board,matrix,NO,NULL);
free_matrix(matrix,board);
return oracle;
}
int main (void) {
int vertex_count = 0;
int ** matrix = load_square (&vertex_count);
int ** spanning_tree = allocate_matrix (vertex_count, vertex_count, 0);
bool * vertex_connected = allocate_array (vertex_count, (bool) false);
if (vertex_count == 0)
return 1;
vertex_connected[0] = true;
for (int pass = 1; pass < vertex_count; pass++) {
int minimum_edge = -1;
int min_i = 0;
int min_j = 0;
for (int i = 0; i < vertex_count; i++) {
if (!vertex_connected[i])
continue;
for (int j = 0; j < vertex_count; j++) {
if (matrix[i][j] == 0)
continue;
if (vertex_connected[j])
continue;
if (minimum_edge == -1 || matrix[i][j] < minimum_edge) {
minimum_edge = matrix[i][j];
min_i = i;
min_j = j;
}
}
}
spanning_tree[min_i][min_j] = minimum_edge;
spanning_tree[min_j][min_i] = minimum_edge;
vertex_connected[min_j] = true;
}
printf ("%d\n", graph_weight (matrix, vertex_count) - graph_weight (spanning_tree, vertex_count));
free_matrix (matrix, vertex_count);
free_matrix (spanning_tree, vertex_count);
free (vertex_connected);
return 0;
}
matrix_t *multiply_matrix(matrix_t *a, matrix_t *b)
{
if (a->columns != b->rows) {
fprintf(stderr, "multiply_matrix(): cannot multiply\n");
exit(1);
}
matrix_t *c = allocate_matrix(a->rows, b->columns);
stopwatch_start();
__multiply_matrix(c, a, b);
stopwatch_stop();
return c;
}
/******************************************************************************
* This function sets the transistion prob. matrix for the ith element of
a transition matrix array to a copy of the provided matrix.
******************************************************************************/
static void set_substmatrix_matrix(
SUBSTMATRIX_ARRAY_T *a,
int i,
MATRIX_T* src
) {
assert(a != NULL);
assert(i < a->length);
MATRIX_T* dst = NULL;
if (src != NULL) {
int num_rows = get_num_rows(src);
int num_cols = get_num_rows(src);
dst = allocate_matrix(num_rows, num_cols);
copy_matrix(src, dst);
}
a->substmatrix[i] = dst;
}
/******************************************************************************
* This function returns a copy of the ith matrix of a transition matrix array.
* Caller is responsible for freeing the returned copy.
******************************************************************************/
static MATRIX_T* get_substmatrix_matrix(
SUBSTMATRIX_ARRAY_T *a,
int i
) {
assert(a != NULL);
assert(i < a->length);
// Create a copy of our matrix
MATRIX_T* src = a->substmatrix[i];
MATRIX_T* dst = NULL;
if (src != NULL) {
int num_rows = get_num_rows(src);
int num_cols = get_num_cols(src);
dst = allocate_matrix(num_rows, num_cols);
copy_matrix(src, dst);
}
return dst;
}
// Return the longest common subseuqence of k-mers between the two strings
kLCSResult kLCS(const std::string& a, const std::string& b, const int k)
{
uint32_t n_kmers_a = a.size() - k + 1;
uint32_t n_kmers_b = b.size() - k + 1;
uint32_t n_rows = n_kmers_a + 1;
uint32_t n_cols = n_kmers_b + 1;
UInt32Matrix m;
allocate_matrix(m, n_rows, n_cols);
// Initialize first row/col to zero
for(uint32_t row = 0; row < m.n_rows; ++row)
set(m, row, 0, 0);
for(uint32_t col = 0; col < m.n_cols; ++col)
set(m, 0, col, 0);
// Fill matrix
for(uint32_t row = 1; row < m.n_rows; ++row) {
for(uint32_t col = 1; col < m.n_cols; ++col) {
const char* ka = a.c_str() + row - 1;
const char* kb = b.c_str() + col - 1;
uint32_t score = 0;
if(strncmp(ka, kb, k) == 0) {
uint32_t diag = get(m, row - 1, col - 1);
score = diag + 1;
} else {
uint32_t left = get(m, row, col - 1);
uint32_t up = get(m, row - 1, col);
score = std::max(left, up);
}
set(m, row, col, score);
}
}
kLCSResult result;
_kLCSBacktrack(m, a, b, k, n_rows - 1, n_cols - 1, result);
// Backtrack appends from the end to the start, reverse the vector of matches
std::reverse(result.begin(), result.end());
free_matrix(m);
return result;
}
