/**********************************************************************
shuffle_sequence()
shuffle a given sequences based on their content
**********************************************************************/
void shuffle_sequence(
SEQ_T* seq, /* original sequence IN */
unsigned int seed, /* seed IN */
SEQ_T** target /* target sequence OUT */
){
my_srand(seed);
assert(*target==NULL);
// reset target if not null
if (*target != NULL){
free_seq(*target);
}
*target = allocate_seq(get_seq_name(seq),"shuffled",get_seq_offset(seq),get_raw_sequence(seq));
char *raw = get_raw_sequence(*target);
/* copy original in temp string */
char* tmp = (char*)mm_calloc(get_seq_length(seq)+1,sizeof(char));
strcpy(tmp,get_raw_sequence(seq));
tmp[get_seq_length(seq)]='\0';
int i,j;
char *ss;
char *dd;
for(j=0,i=get_seq_length(seq);i>0;i--){
// Pick a random number in the range:
int pick = rand() % i;
raw[j++] = tmp[pick];
// "shift" routine here eliminates the "picked" base from the _src string:
// dd starts at the picked position: ss is one beyond that:
for( dd = tmp+pick , ss = dd + 1 ; *dd ; *dd++=*ss++ );
}
myfree(tmp);
}
/****************************************************************************
* Read priors until a new sequence is encountered or too many letters
* are read. The new priors are copied to the priors buffer of the given
* sequence starting at buffer_offset.
****************************************************************************/
void read_one_priors_segment_from_reader(
DATA_BLOCK_READER_T *prior_reader,
size_t max_size,
size_t buffer_offset,
SEQ_T *sequence
) {
assert(sequence != NULL);
char *seq_name = get_seq_name(sequence);
size_t seq_start = get_seq_offset(sequence);
// Get the priors buffer from the SEQ_T
double *priors = get_seq_priors(sequence);
if (priors == NULL) {
// Priors buffer not yet allocated
priors = mm_malloc(max_size * sizeof(double));
}
get_prior_array_from_reader(
prior_reader,
seq_name,
seq_start,
max_size,
buffer_offset,
priors
);
set_seq_priors(priors, sequence);
}
/****************************************************************************
* Extract a small alignment out of the middle of a larger alignment.
****************************************************************************/
ALIGNMENT_T* extract_subalignment
(int start,
int width,
ALIGNMENT_T* alignment)
{
int num_sequences = get_num_aligned_sequences(alignment);
SEQ_T** sequences = get_alignment_sequences(alignment);
SEQ_T** subsequences = (SEQ_T**)mm_malloc(num_sequences * sizeof(SEQ_T*));
// Extract the specified columns into a new list of sequences.
int i_seq = 0;
char* subsequence = mm_malloc((width + 1) * sizeof(char));
for (i_seq = 0; i_seq < num_sequences; i_seq++) {
SEQ_T* this_seq = sequences[i_seq];
char* raw_seq = get_raw_sequence(this_seq);
strncpy(subsequence, raw_seq + start, width);
subsequence[width] = '\0';
subsequences[i_seq] =
allocate_seq(get_seq_name(this_seq),
get_seq_description(this_seq),
get_seq_offset(this_seq),
subsequence);
}
// Extract the consensus string in the specified columns.
char* consensus = get_consensus_string(alignment);
char* subconsensus = mm_malloc(sizeof(char) * (width + 1));
strncpy(subconsensus, consensus + start, width);
subconsensus[width] = '\0';
// Allocate and return the new alignment.
ALIGNMENT_T* subalignment
= allocate_alignment(get_alignment_name(alignment),
get_alignment_description(alignment),
num_sequences,
subsequences,
subconsensus);
// Free local dynamic memory.
for (i_seq = 0; i_seq < num_sequences; i_seq++) {
free_seq(subsequences[i_seq]);
}
myfree(subsequences);
myfree(subsequence);
return(subalignment);
}
/****************************************************************************
* Remove from the alignment all columns that contain gaps for the
* specified species.
****************************************************************************/
ALIGNMENT_T* remove_alignment_gaps
(char* species,
ALIGNMENT_T* alignment)
{
// Locate this species in the alignment.
int species_index = get_index_in_string_list(species,
get_species_names(alignment));
if (species_index == -1) {
die("Can't find %s in alignment.\n", species);
}
SEQ_T* this_seq = get_alignment_sequence(species_index, alignment);
// Get the dimensions of the original matrix.
int num_sequences = get_num_aligned_sequences(alignment);
int alignment_length = get_alignment_length(alignment);
// Allocate memory for raw sequences that will constitute the new alignment.
char** raw_sequences = (char**)mm_malloc(sizeof(char*) * num_sequences);
int i_seq = 0;
for (i_seq = 0; i_seq < num_sequences; i_seq++) {
raw_sequences[i_seq]
= (char*)mm_calloc(alignment_length + 1, sizeof(char*));
}
char* consensus = get_consensus_string(alignment);
char* new_consensus
= (char*)mm_calloc(alignment_length + 1, sizeof(char*));
// Iterate over all columns.
int i_column;
int i_raw = 0;
for (i_column = 0; i_column < alignment_length; i_column++) {
// Is there a gap?
char this_char = get_seq_char(i_column, this_seq);
if ((this_char != '-') && (this_char != '.')) {
// If no gap, then copy over this column.
for (i_seq = 0; i_seq < num_sequences; i_seq++) {
SEQ_T* this_sequence = get_alignment_sequence(i_seq, alignment);
char this_char = get_seq_char(i_column, this_sequence);
raw_sequences[i_seq][i_raw] = this_char;
}
new_consensus[i_raw] = consensus[i_column];
i_raw++;
}
}
// Create new sequence objects.
SEQ_T** new_sequences = (SEQ_T**)mm_malloc(num_sequences * sizeof(SEQ_T*));
for (i_seq = 0; i_seq < num_sequences; i_seq++) {
SEQ_T* this_sequence = get_alignment_sequence(i_seq, alignment);
new_sequences[i_seq] = allocate_seq(get_seq_name(this_sequence),
get_seq_description(this_sequence),
get_seq_offset(this_sequence),
raw_sequences[i_seq]);
}
// Allocate and return the new alignment.
ALIGNMENT_T* new_alignment
= allocate_alignment(get_alignment_name(alignment),
get_alignment_description(alignment),
num_sequences,
new_sequences,
new_consensus);
// Free local dynamic memory.
for (i_seq = 0; i_seq < num_sequences; i_seq++) {
myfree(raw_sequences[i_seq]);
free_seq(new_sequences[i_seq]);
}
myfree(raw_sequences);
myfree(new_sequences);
myfree(new_consensus);
return(new_alignment);
}
/****************************************************************************
* Allocate one alignment object. Name and description may be NULL.
*
* Returns a pointer to the newly created alignment.
****************************************************************************/
ALIGNMENT_T* allocate_alignment(
char* name,
char* description,
int num_sequences,
SEQ_T** sequences,
char* consensus_string
)
{
assert(num_sequences > 0);
assert(sequences != NULL);
assert(consensus_string != NULL);
// Allocate the alignment object.
ALIGNMENT_T* new_alignment = (ALIGNMENT_T*)mm_malloc(sizeof(ALIGNMENT_T));
if (new_alignment == NULL) {
die("Error allocating alignment\n");
}
// Store the name, truncating if necessary.
if (name != NULL) {
strncpy(new_alignment->name, name, MAX_ALIGNMENT_NAME);
new_alignment->name[MAX_ALIGNMENT_NAME] = '\0';
if (strlen(new_alignment->name) != strlen(name)) {
fprintf(stderr, "Warning: truncating alignment program name %s to %s.\n",
name, new_alignment->name);
}
} else {
new_alignment->name[0] = '\0';
}
// Store the description, truncating if necessary.
if (description != NULL) {
strncpy(new_alignment->desc, description, MAX_ALIGNMENT_COMMENT);
new_alignment->desc[MAX_ALIGNMENT_COMMENT] = '\0';
} else {
new_alignment->desc[0] = '\0';
}
// Store the sequences.
new_alignment->sequences = (SEQ_T**) mm_malloc(num_sequences * sizeof(SEQ_T*));
if (new_alignment->sequences == NULL) {
die("Error allocating sequences\n");
}
new_alignment->num_sequences = num_sequences;
int seq_length = strlen(get_raw_sequence(sequences[0]));
int i;
for (i = 0; i < num_sequences; i++) {
myassert(TRUE,
strlen(get_raw_sequence(sequences[i])) == seq_length,
"Sequence #1 (%s) is length=%d, but sequence #%d (%s) is length=%d.\n<%s>\n",
get_seq_name(sequences[0]), seq_length, i,
get_seq_name(sequences[i]), strlen(get_raw_sequence(sequences[i])),
get_raw_sequence(sequences[i]));
new_alignment->sequences[i] =
allocate_seq(get_seq_name(sequences[i]),
get_seq_description(sequences[i]),
get_seq_offset(sequences[i]),
get_raw_sequence(sequences[i])
);
}
// Fill in the remaining fields.
new_alignment->length = seq_length;
copy_string(&(new_alignment->consensus_string), consensus_string);
return(new_alignment);
}
