/*********************************************************************** * Discard motifs that are not connected. ***********************************************************************/ static void throw_out_unused_motifs (MATRIX_T* transp_freq, MATRIX_T* spacer_ave, int* num_motifs, MOTIF_T* motifs) { int i_motif, j_motif; ARRAY_T* row_sums; ARRAY_T* col_sums; // Extract the margins of the transition matrix. row_sums = get_matrix_row_sums(transp_freq); col_sums = get_matrix_col_sums(transp_freq); for (i_motif = 0; i_motif < *num_motifs; i_motif++) { // Is this row or column empty? if ((get_array_item(i_motif + 1, row_sums) == 0.0) || (get_array_item(i_motif + 1, col_sums) == 0.0)) { if (verbosity >= NORMAL_VERBOSE) { fprintf(stderr, "Removing unused motif %s. No occurrences of this motif were found.\n", get_motif_id(&(motifs[i_motif]))); } // Remove the row and column from the transition matrix. remove_matrix_row(i_motif + 1, transp_freq); remove_matrix_col(i_motif + 1, transp_freq); assert(get_num_rows(transp_freq) == get_num_cols(transp_freq)); remove_matrix_row(i_motif + 1, spacer_ave); remove_matrix_col(i_motif + 1, spacer_ave); assert(get_num_rows(spacer_ave) == get_num_cols(spacer_ave)); // Remove the motif from the array. for (j_motif = i_motif + 1; j_motif < *num_motifs; j_motif++) { free_motif(&(motifs[j_motif - 1])); copy_motif(&(motifs[j_motif]), &(motifs[j_motif - 1])); } free_motif(&(motifs[j_motif - 1])); (*num_motifs)--; i_motif--; // Recalculate the row and column sums. free_array(row_sums); free_array(col_sums); row_sums = get_matrix_row_sums(transp_freq); col_sums = get_matrix_col_sums(transp_freq); } } free_array(row_sums); free_array(col_sums); }
/****************************************************************************** * 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; }
strvec MtxLP::getRowNames() const{ strvec rv; int nrows = get_num_rows(); for (int i = 1; i <= nrows; i++) rv.push_back(get_row_name(i)); return rv; }
/****************************************************************************** * 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; }
/*********************************************************************** * allocate memory for a motif ***********************************************************************/ MOTIF_T* allocate_motif(char *id, MATRIX_T* freqs){ MOTIF_T* motif = mm_malloc(sizeof(MOTIF_T)); assert(id != NULL); assert(freqs != NULL); motif->length = 0; motif->alph_size = 0; motif->ambigs = 0; motif->evalue = 0.0; motif->num_sites = 0.0; motif->complexity = 0.0; motif->freqs = duplicate_matrix(freqs); motif->scores = NULL; // Set required fields. int length = strlen(id) + 1; strncpy(motif->id, id, min(length,MAX_MOTIF_ID_LENGTH)); motif->alph_size = get_num_cols(motif->freqs); motif->length = get_num_rows(motif->freqs); motif->url = NULL; motif->trim_left = 0; motif->trim_right = 0; return motif; }
/*********************************************************************** * Compute the complexity of a motif as a number between 0 and 1. * * Motif complexity is the average K-L distance between the "motif * background distribution" and each column of the motif. The motif * background is just the average distribution of all the columns. The * K-L distance, which measures the difference between two * distributions, is the same as the information content: * * \sum_i p_i log(p_i/f_i) * * This value increases with increasing complexity. ***********************************************************************/ double compute_motif_complexity (MOTIF_T* a_motif) { double return_value; ARRAY_T* motif_background; // Mean emission distribution. int num_rows; int i_row; int num_cols; int i_col; num_cols = get_alph_size(ALPH_SIZE); num_rows = get_num_rows(a_motif->freqs); // Compute the mean emission distribution. motif_background = get_matrix_col_sums(a_motif->freqs); scalar_mult(1.0 / (double)num_rows, motif_background); // Compute the K-L distance w.r.t. the background. return_value = 0; for (i_row = 0; i_row < num_rows; i_row++) { ARRAY_T* this_emission = get_matrix_row(i_row, a_motif->freqs); for (i_col = 0; i_col < num_cols; i_col++) { ATYPE this_item = get_array_item(i_col, this_emission); ATYPE background_item = get_array_item(i_col, motif_background); // Use two logs to avoid handling divide-by-zero as a special case. return_value += this_item * (my_log(this_item) - my_log(background_item)); } } free_array(motif_background); return(return_value / (double)num_rows); }
/*********************************************************************** * 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); }
/************************************************************************** * * reverse_complement_pssm_matrix * * Turn a pssm matrix into its own reverse complement. * *************************************************************************/ static void reverse_complement_pssm ( ALPH_T alph, MATRIX_T* pssm_matrix ) { int i; ARRAY_T* left_scores; ARRAY_T* right_scores; ARRAY_T* temp_scores; // Temporary space during swap. int length = get_num_rows(pssm_matrix); // Allocate space. temp_scores = allocate_array(alph_size(alph, ALL_SIZE)); // Consider each row (position) in the motif. for (i = 0; i < (int)((length+1) / 2); i++) { left_scores = get_matrix_row(i, pssm_matrix); right_scores = get_matrix_row(length - (i + 1), pssm_matrix); // Make a temporary copy of one row. copy_array(left_scores, temp_scores); // Compute reverse complements in both directions. complement_dna_freqs(right_scores, left_scores); complement_dna_freqs(temp_scores, right_scores); } free_array(temp_scores); } // reverse_complement_pssm_matrix
/************************************************************************** * hash_pssm_matrix_pos Recursively create a single position of a hashed PSSM. * **************************************************************************/ static void hash_pssm_matrix_pos( MATRIX_T *pssm, // pssm to hash MATRIX_T *hashed_pssm, // hashed pssm int pos, // position in pssm int hashed_pos, // position in hashed pssm int n, // number of columns to hash together double score, // cumulative score; call with 0 int index // cumulative index; call with 0 ) { int i; int alen = get_num_cols(pssm); // alphabet length int w = get_num_rows(pssm); // pssm width if (n==0) { // done, set hashed_pssm entry set_matrix_cell(hashed_pos, index, score, hashed_pssm); } else { // combine next column of pssm for (i=0; i<=alen; i++) { // letters + blank // not past right edge of motif and not blank? double s = (pos<w && i!=alen) ? get_matrix_cell(pos, i, pssm) : 0; hash_pssm_matrix_pos(pssm, hashed_pssm, pos+1, // position in old pssm hashed_pos, // position working on n-1, // positions remaining to hash score+s, // score so far index*(alen+1)+i); // hashed alphabet index so far } // leter } } // hash_pssm_matrix_pos
/** * Given a matrix, find the row idx and column idx of the minimum value * that passes the score and count threshold. If none is found, then * row_idx, col_idx, and lowest will not be modified. */ void find_most_significant_within_matrix(MATRIX_T* binomial, MATRIX_T* phospho_count, int* row_idx, int* col_idx, double* lowest, MOMO_OPTIONS_T* options) { int i; int j; for (i = 0; i < get_num_rows(binomial); ++i) { for (j = 0; j < get_num_cols(binomial); ++j) { double binomial_value = get_matrix_cell_defcheck(i, j, binomial); double count_value = get_matrix_cell_defcheck(i, j, phospho_count); // 1. value cannot be nan/inf // 2. log(value) < log(options->score_threshold) // 3. value should not be the modified location if (i != options->width/2 && !isnan(binomial_value) && !isinf(binomial_value) && binomial_value < log(options->score_threshold) && count_value >= options->count_threshold) { if (binomial_value < *lowest || isnan(*lowest)) { *row_idx = i; *col_idx = j; *lowest = get_matrix_cell_defcheck(i, j, binomial); } } } } }
void check_sq_matrix(MATRIX_T *sq, int expected_size) { int i; assert(get_num_rows(sq) == expected_size); assert(get_num_cols(sq) == expected_size); for (i = 0; i < expected_size; ++i) { assert(get_array_length(get_matrix_row(i, sq)) == expected_size); } }
/*********************************************************************** * Convert transition counts to transition probabilities, and compute * average spacer lengths. * * Each matrix is indexed 0 ... n+1, where n is the number of motifs. * The entry at [i,j] corresponds to the transition from motif i to * motif j. Hence, after normalization, each row in the transition * matrix should sum to 1. ***********************************************************************/ static void normalize_spacer_counts( double trans_pseudo, double spacer_pseudo, // Pseudocount for self-loop. BOOLEAN_T keep_unused, MATRIX_T* transp_freq, MATRIX_T* spacer_ave ) { int i_row; int i_col; int num_rows; double total_spacer; double num_transitions; double ave_spacer; /* Divide the spacer lengths by the number of occurrences. */ num_rows = get_num_rows(transp_freq); for (i_row = 0; i_row < num_rows; i_row++) { for (i_col = 0; i_col < num_rows; i_col++) { total_spacer = get_matrix_cell(i_row, i_col, spacer_ave) + spacer_pseudo; num_transitions = get_matrix_cell(i_row, i_col, transp_freq); if (spacer_pseudo > 0) num_transitions++; if (num_transitions != 0.0) { ave_spacer = total_spacer / num_transitions; set_matrix_cell(i_row, i_col, ave_spacer, spacer_ave); } } } // Add pseudocounts. for (i_row = 0; i_row < num_rows; i_row++) { for (i_col = 0; i_col < num_rows; i_col++) { // Force some transitions to zero. if (// No transitions to the start state. (i_col == 0) || // No transitions from the end state. (i_row == num_rows - 1) || // No transition from start to end. ((i_row == 0) && (i_col == num_rows - 1))) { set_matrix_cell(i_row, i_col, 0.0, transp_freq); } else { // Only increment the used transitions. if ((keep_unused) || (get_matrix_cell(i_row, i_col, transp_freq) > 0.0)) { incr_matrix_cell(i_row, i_col, trans_pseudo, transp_freq); } } } } // Normalize rows. for (i_row = 0; i_row < num_rows - 1; i_row++) { if (array_total(get_matrix_row(i_row, transp_freq)) > 0.0) { normalize(SLOP, get_matrix_row(i_row, transp_freq)); } } }
void MILPP::initialize(int nr_cols, int nr_rows) { cons_matrix_.resize(nr_rows, nr_cols); col_to_row_mapping_.resize(nr_cols); for (int i = 0; i < get_num_cols(); i++) { col_to_row_mapping_[i] = new set<int>(); } row_to_col_mapping_.resize(nr_rows); for (int i = 0; i < get_num_rows(); i++) { row_to_col_mapping_[i] = new set<int>(); } /* Compute problem parameters and set default values if required */ obj_coefs_.resize(nr_cols); cols_lower_bounds_.resize(nr_cols); cols_upper_bounds_.resize(nr_cols); /* Allocate rows related variables */ rows_lower_bounds_.resize(nr_rows); rows_upper_bounds_.resize(nr_rows); rows_senses_.resize(nr_rows); /* Initialize cols related arrays */ for (int i = 0; i < get_num_cols(); i++) { set_col_lower_bound(i, 0.); set_col_upper_bound(i, 1.); set_obj_coef(i, 0.); } /* Initialize rows related arrays */ for (int i = 0; i < get_num_rows(); i++) { set_row_lower_bound(i, 0.); /* The actual upper bound values will be assigned later. */ set_row_upper_bound(i, 0.); /* Set default row sense */ set_row_sense(i, ROW_SENSE_LOWER); } }
void init_domain (float ** domain_ptr,int rank) { int i,j,start,end,rows; start = get_start(rank); end = get_end(rank); rows = get_num_rows(rank); for (j=start;j<end;j++) { for (i=0;i<(int)floor(WIDTH/H);i++) { domain_ptr[j-start][i] = 0.0; } } }
KARLIN_INPUT_T *make_karlin_input( MATRIX_T *matrix, /* scoring matrix */ ARRAY_T *probs /* letter freq distribution */ ) { int i, j; double escore; long lowest, highest; ARRAY_T *score_probs; int nscores; int alen = get_num_rows(matrix); /* size of alphabet */ KARLIN_INPUT_T *karlin_input; /* data to return */ /* find the highest and lowest scores in the scoring matrix */ lowest = 1; highest = -1; for (i=0; i<alen; i++) { for (j=0; j<alen; j++) { double s = get_matrix_cell(i, j, matrix); if (s < lowest) lowest = s; if (s > highest) highest = s; } } if (lowest >= 0) die("Lowest score in scoring matrix must be negative, is %f.", (double)lowest); if (highest<= 0) die("Highest score in scoring matrix must be positve, is %f.", (double)highest); /* allocate the array of score probabilities and set to 0 */ nscores = highest - lowest + 1; score_probs = allocate_array(nscores); init_array(0, score_probs); /* compute the probabilities of different scores */ escore = 0; for (i=0; i<alen; i++) { for (j=0; j<alen; j++) { int s = get_matrix_cell(i, j, matrix); double pi = get_array_item(i, probs); double pj = get_array_item(j, probs); double sp = get_array_item(s-lowest, score_probs); set_array_item(s-lowest, sp + pi*pj, score_probs); /* cumulative prob. of score */ escore += pi*pj*s; /*printf("i %d j %d s %d pi %f pj %f sp %f escore %f\n",i,j,s, pi, pj, sp, escore);*/ } } karlin_input = (KARLIN_INPUT_T *)mm_malloc(sizeof(KARLIN_INPUT_T)); karlin_input->low = lowest; karlin_input->high = highest; karlin_input->escore = escore; karlin_input->prob = score_probs; return(karlin_input); } /* make_karlin_input */
/** * If autoresize is enabled and col or row doesn't exist, the matrix * will be resized. */ inline void set_coefficient(int i, int j, double v, bool autoresize=true) { if (autoresize) { int nr = ((i + 1) > get_num_rows()) ? (i + 1) : -1; int nc = ((j + 1) > get_num_cols()) ? (j + 1) : -1; if (nr || nc) resize(nr, nc); } slave_matrix_.modifyCoefficient(i, j, v); }
/** * Given a bg frequency matrix and a phospho count matrix, we will convert the bg * freq matrix into a binomial matrix. No reason to keep a bg freq matrix, so we will recycle. */ void convert_bg_freqs_to_binomial(MATRIX_T* phospho_count, MATRIX_T* bg_freqs, int num_phospho_seqs) { int i; int j; for (i = 0; i < get_num_rows(bg_freqs); ++i) { for (j = 0; j < get_num_cols(bg_freqs); ++j) { double p = get_matrix_cell_defcheck(i, j, bg_freqs); double cxj = get_matrix_cell_defcheck(i, j, phospho_count); int n = num_phospho_seqs; double log_value = log_betai(cxj, n-cxj+1, p); set_matrix_cell_defcheck(i, j, log_value, bg_freqs); } } }
// function that adds twos around the movement range where a player can attack // THIS FUNCTION ONLY WORKS PROPERLY FOR ATTACK RANGES 1 AND 2. void Valid_board::add_attack_spots(int range){ for(int i = 0; i < valid_tiles.size(); i++){ // nested loops go through each element for(int j = 0; j < valid_tiles[0].size(); j++){ if(valid_tiles[i][j]==1){ // if the tile is a 1, for( int k = range; k >= 1; k--){ // for each time in the range // Checks k tiles in each of the four directions, and if the tile is a 0, makes it a 2 to indicate that you can attack there if(i-k >= 0 && valid_tiles[i-k][j] == 0) valid_tiles[i-k][j] = 2; if(i+k < get_num_rows() && valid_tiles[i+k][j] == 0) valid_tiles[i+k][j] = 2; if(j-k >= 0 && valid_tiles[i][j-k] == 0) valid_tiles[i][j-k] = 2; if(j+k < get_num_cols() && valid_tiles[i][j+k] == 0) valid_tiles[i][j+k] = 2; } // if the range is 2, you need to add diagonal spots as well if(range > 1){ if(i-1 >= 0 && j-1 >= 0 && valid_tiles[i-1][j-1] == 0) valid_tiles[i-1][j-1] = 2; if(i-1 >= 0 && j+1 < get_num_cols() && valid_tiles[i-1][j+1] == 0) valid_tiles[i-1][j+1] = 2; if(i+1 < get_num_rows() && j-1 >= 0 && valid_tiles[i+1][j-1] == 0) valid_tiles[i+1][j-1] = 2; if(i+1 < get_num_rows() && j+1 < get_num_cols() && valid_tiles[i+1][j+1] == 0) valid_tiles[i+1][j+1] = 2; } } } } }
/************************************************************************* * Converts the motif frequency matrix into a odds matrix: taken from old ama-scan.c *************************************************************************/ void convert_to_odds_matrix(MOTIF_T* motif, ARRAY_T* bg_freqs){ const int asize = alph_size(get_motif_alph(motif), ALPH_SIZE); int motif_position_index,alph_index; MATRIX_T *freqs; freqs = get_motif_freqs(motif); const int num_motif_positions = get_num_rows(freqs); for (alph_index=0;alph_index<asize;++alph_index){ double bg_likelihood = get_array_item(alph_index, bg_freqs); for (motif_position_index=0;motif_position_index<num_motif_positions;++motif_position_index){ freqs->rows[motif_position_index]->items[alph_index] /= bg_likelihood; } } }
void MILPP::set_cons_matrix(const PackedMatrix* matrix) { cons_matrix_ = *matrix; for (int i = 0; i < get_num_rows(); i++) { PackedVector* row = get_row(i); for (int j = 0; j < row->get_num_elements(); j++) { col_to_row_mapping_[ row->get_index_by_pos(j) ]->insert(i); row_to_col_mapping_[i]->insert( row->get_index_by_pos(j) ); } } }
/************************************************************************* * Copies the motif frequency matrix and converts it into a odds matrix *************************************************************************/ MATRIX_T* create_odds_matrix(MOTIF_T *motif, ARRAY_T* bg_freqs){ const int asize = alph_size(get_motif_alph(motif), ALPH_SIZE); int pos, aidx; MATRIX_T *odds; odds = duplicate_matrix(get_motif_freqs(motif)); const int num_pos = get_num_rows(odds); for (aidx = 0; aidx < asize; ++aidx) { double bg_likelihood = get_array_item(aidx, bg_freqs); for (pos = 0; pos < num_pos; ++pos) { odds->rows[pos]->items[aidx] /= bg_likelihood; } } return odds; }
float get_convergence_sqd (float ** current_ptr,float ** next_ptr,int rank) { int i,j,my_start,my_end,my_num_rows; float sum; my_start = get_start(rank); my_end = get_end(rank); my_num_rows = get_num_rows(rank); sum = 0.0; for (j=my_start;j<=my_end;j++) { for (i=0;i<(int)floor(WIDTH/H);i++) { sum += pow(next_ptr[global_to_local(rank,j)][i]-current_ptr[global_to_local(rank,j)][i],2); } } return sum; }
/****************************************************************************** * 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; }
stomap* MtxLP::getColSto(string name) const{ stomap* rv = new stomap; int n = ncol(name); if (n == 0) throw runtime_error(name + ": no such row!"); int len = get_num_rows(); int *inds = new int[len + 1]; double *vals = new double[len + 1]; len = get_mat_col(n, inds, vals); for (int i = 1; i <= len; i++){ if (inds[i] <= mtxlen) (*rv)[get_row_name(inds[i])] = vals[i]; } delete inds; delete vals; return rv; }
void Board::display() const { for (int r = get_num_rows() - 1; r >= 0; r--) { std::cout << r << ":| "; for (int c = 0; c < get_num_cols(); c++) { std::cout << get_cell(c, r) << " "; } std::cout << std::endl; } std::cout << " -"; for (int c = 0; c < get_num_cols(); c++) { std::cout << "--"; } std::cout << "\n"; std::cout << " "; for (int c = 0; c < get_num_cols(); c++) { std::cout << c << " "; } std::cout << "\n\n"; }
/*********************************************************************** * Allocate memory for a MEME motif ***********************************************************************/ MOTIF_T* allocate_motif( char *id, ALPH_T alph, MATRIX_T* scores, MATRIX_T* freqs ) { MOTIF_T* motif = mm_malloc(sizeof(MOTIF_T)); assert(id != NULL); if (freqs == NULL && scores == NULL) { die( "A matrix of scores, or frequencies, or both, " "must be provided when allocating a motif\n" ); } motif->length = get_num_rows(freqs); motif->alph = alph; motif->flags = 0; motif->evalue = 0.0; motif->log_evalue = -HUGE_VAL; motif->num_sites = 0.0; motif->complexity = 0.0; int length = strlen(id) + 1; strncpy(motif->id, id, MIN(length, MAX_MOTIF_ID_LENGTH)); if (scores != NULL) { motif->scores = duplicate_matrix(scores); } if (freqs != NULL) { motif->freqs = duplicate_matrix(freqs); } motif->url = NULL; motif->trim_left = 0; motif->trim_right = 0; return motif; }
/*********************************************************************** * Takes a matrix of meme scores and converts them into letter * probabilities. * * The probablility can be got by: * p = (2 ^ (s / 100)) * bg * ***********************************************************************/ MATRIX_T* convert_scores_into_freqs (ALPH_T alph, MATRIX_T *scores, ARRAY_T *bg, int site_count, double pseudo_count) { int asize, length; double freq, score, total_count, counts, bg_freq; MATRIX_T *freqs; int row, col; assert(alph != INVALID_ALPH); assert(scores != NULL); assert(bg != NULL); length = get_num_rows(scores); asize = alph_size(alph, ALPH_SIZE); freqs = allocate_matrix(length, asize); total_count = site_count + pseudo_count; for (col = 0; col < asize; ++col) { bg_freq = get_array_item(col, bg); for (row = 0; row < length; ++row) { score = get_matrix_cell(row, col, scores); // convert to a probability freq = pow(2.0, score / 100.0) * bg_freq; // remove the pseudo count freq = ((freq * total_count) - (bg_freq * pseudo_count)) / site_count; if (freq < 0) freq = 0; else if (freq > 1) freq = 1; set_matrix_cell(row, col, freq, freqs); } } for (row = 0; row < length; ++row) { normalize_subarray(0, asize, 0.0, get_matrix_row(row, freqs)); } return freqs; }
/*********************************************************************** * Converts a TRANSFAC motif to a MEME motif. * Caller is responsible for freeing the returned MOTIF_T. ***********************************************************************/ MOTIF_T *convert_transfac_motif_to_meme_motif( char *id, int pseudocount, ARRAY_T *bg, TRANSFAC_MOTIF_T *motif ) { MATRIX_T *counts = get_transfac_counts(motif); if (counts == NULL) { die( "Unable to convert TRANSFAC motif %s to MEME motif: " "missing counts matrix.", id ); }; // Convert the motif counts to frequencies. int num_bases = get_num_cols(counts); int motif_width = get_num_rows(counts); int motif_position = 0; MATRIX_T *freqs = allocate_matrix(motif_width, num_bases); for (motif_position = 0; motif_position < motif_width; ++motif_position) { int i_base = 0; int num_seqs = 0; // motif columns may have different counts for (i_base = 0; i_base < num_bases; i_base++) { num_seqs += get_matrix_cell(motif_position, i_base, counts); } for (i_base = 0; i_base < num_bases; i_base++) { double freq = (get_matrix_cell(motif_position, i_base, counts) + (pseudocount * get_array_item(i_base, bg))) / (num_seqs + pseudocount); set_matrix_cell(motif_position, i_base, freq, freqs); } } MOTIF_T *meme_motif = allocate_motif(id, DNA_ALPH, NULL, freqs); calc_motif_ambigs(meme_motif); return meme_motif; }
bool edt_server::write_opengl_texture_to_quad() { double xfrac = static_cast<double>(get_num_columns()) / _opengl_texture_size_x; double yfrac = static_cast<double>(get_num_rows()) / _opengl_texture_size_y; // Flip over while writing. // Set the texture and vertex coordinates and write the quad to OpenGL. glBegin(GL_QUADS); glTexCoord2d(0.0, yfrac); glVertex2d(-1.0, -1.0); glTexCoord2d(xfrac, yfrac); glVertex2d(1.0, -1.0); glTexCoord2d(xfrac, 0.0); glVertex2d(1.0, 1.0); glTexCoord2d(0.0, 0.0); glVertex2d(-1.0, 1.0); glEnd(); return true; }
MATRIX_T *convert_score_to_target( MATRIX_T *score, /* score matrix */ ARRAY_T *prob /* letter frequencies */ ) { int i, j; KARLIN_INPUT_T *karlin_input; double lambda, K, H; MATRIX_T *target; /* target freq. matrix */ int alen = get_num_rows(score); /* alphabet length */ /* make input for karlin() */ karlin_input = make_karlin_input(score, prob); /* get lambda */ karlin(karlin_input->low, karlin_input->high, karlin_input->prob->items, &lambda, &K, &H); /*printf("lambda %f K %f H %f\n", lambda, K, H);*/ /* calculate target frequencies */ target = allocate_matrix(alen, alen); for (i=0; i<alen; i++) { for (j=0; j<alen; j++) { double pi = get_array_item(i, prob); double pj = get_array_item(j, prob); double sij = get_matrix_cell(i, j, score); double f = pi * pj * exp(lambda * sij); set_matrix_cell(i, j, f, target); } } // Free local dynamic memory. free_array(karlin_input->prob); myfree(karlin_input); return(target); } /* convert_score_to_target */