Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/blast__util_8c_source.html below:

NCBI C++ ToolKit: src/algo/blast/core/blast_util.c Source File

m = 0,

= 0, e = 0;

(ranges ==

|| num_ranges <= 0) {

(ranges[m].left > target) {

( (target > ranges[

].right) && (

< (num_ranges-1) ) ) {

(*seq_blk ==

) {

(seq_blk && *seq_blk);

(buffer_allocated) {

(*seq_blk)->sequence_start_allocated =

;

(*seq_blk)->sequence = (*seq_blk)->sequence_start+1;

(*seq_blk)->sequence_start =

;

(*seq_blk)->sequence_start_nomask = (*seq_blk)->sequence_start;

(*seq_blk)->sequence_nomask = (*seq_blk)->sequence;

(*seq_blk)->nomask_allocated =

;

(*seq_blk)->length = length;

(*seq_blk)->bases_offset = 0;

* sequence,

seq_blk->

= seqlen;

* sequence)

num_seq_ranges,

( !seq_blk || !seq_ranges ) {

(num_seq_ranges >= 1);

(copy_seq_ranges) {

( !

) {

-1; }

memcpy((

*)

,

(

*) seq_ranges,

num_seq_ranges *

(*seq_ranges));

[num_seq_ranges - 1].right = seq_blk->

;

(*copy)->sequence_allocated =

;

(*copy)->sequence_start_allocated =

;

(*copy)->oof_sequence_allocated =

;

(*copy)->lcase_mask_allocated =

;

(*copy)->seq_ranges_allocated =

;

(program ==

)

(

(

, program) == 0)

(

(

, program) == 0)

(

(

, program) == 0)

(

(

, program) == 0)

(

(

, program) == 0)

(

(

, program) == 0)

(

(

, program) == 0)

(

(

, program) == 0)

(

(

, program) == 0)

(

(

, program) == 0)

(

(

, program) == 0)

(program ==

)

*program =

(

);

*program =

(

);

*program =

(

);

*program =

(

);

*program =

(

);

*program =

(

);

*program =

(

);

*program =

(

);

*program =

(

);

*program =

(

);

*program =

(

);

*program =

(

);

*program =

(

);

, j, k, index0, index1, index2;

mapping[4] = { 8,

((codon[0] | codon[1] | codon[2]) > 15) {

(

= 0;

< 4;

++) {

(codon[0] & mapping[

]) {

(j = 0; j < 4; j++) {

(codon[1] & mapping[j]) {

index1 = index0 + (j * 4);

(k = 0; k < 4; k++) {

(codon[2] & mapping[k]) {

index, index_prot;

nucl_seq = (frame >= 0 ? (

*)query_seq : (

*)(query_seq_rev+1));

prot_seq[0] =

;

codon[0] = nucl_seq[index];

codon[1] = nucl_seq[index+1];

codon[2] = nucl_seq[index+2];

prot_seq[index_prot] = residue;

prot_seq[index_prot] =

;

index_prot - 1;

new_seq[-1] = new_seq[-2] = new_seq[-3] = 0;

new_seq[

-3] = new_seq[

-2] = new_seq[

-1] = 0;

max_start =

(3,

);

(

= 0;

< max_start;

++) {

curr_letter = curr_letter << 2 | (old_seq[

] & 3);

new_seq[

- max_start] = curr_letter;

(;

<

;

++) {

curr_letter = curr_letter << 2 | (old_seq[

] & 3);

new_seq[

- max_start] = curr_letter;

max_start =

(3,

);

(

= 0;

< max_start;

++) {

curr_letter = curr_letter << 2;

new_seq[

- (max_start -

)] = curr_letter;

total_remainder;

byte_value, codon=-1;

last_remainder, last_byte, remainder;

* nt_seq_end,* nt_seq_start;

* prot_seq_start;

byte_value1,byte_value2,byte_value3,byte_value4,byte_value5;

(nt_seq ==

|| prot_seq ==

||

prot_seq_start = prot_seq;

remainder = length%4;

nt_seq_end = (

*) (nt_seq + (length)/4 - 1);

last_remainder = (4*(length/4) - frame + 1)%

;

total_remainder = last_remainder+remainder;

byte_value = *nt_seq;

(nt_seq < nt_seq_end) {

codon = (byte_value >> 2);

*prot_seq = translation[codon];

codon = ((byte_value & 3) << 4);

byte_value = *nt_seq;

codon += (byte_value >> 4);

*prot_seq = translation[codon];

(nt_seq >= nt_seq_end) {

codon = ((byte_value & 15) << 2);

byte_value = *nt_seq;

codon += (byte_value >> 6);

*prot_seq = translation[codon];

(nt_seq >= nt_seq_end) {

codon = byte_value & 63;

*prot_seq = translation[codon];

byte_value = *nt_seq;

(nt_seq < (nt_seq_end-10)) {

byte_value1 = *(++nt_seq);

byte_value2 = *(++nt_seq);

byte_value3 = *(++nt_seq);

codon = (byte_value >> 2);

*prot_seq = translation[codon];

codon = ((byte_value & 3) << 4);

codon += (byte_value1 >> 4);

*prot_seq = translation[codon];

byte_value4 = *(++nt_seq);

codon = ((byte_value1 & 15) << 2);

codon += (byte_value2 >> 6);

*prot_seq = translation[codon];

codon = byte_value2 & 63;

byte_value5 = *(++nt_seq);

*prot_seq = translation[codon];

codon = (byte_value3 >> 2);

*prot_seq = translation[codon];

byte_value = *(++nt_seq);

codon = ((byte_value3 & 3) << 4);

codon += (byte_value4 >> 4);

*prot_seq = translation[codon];

codon = ((byte_value4 & 15) << 2);

codon += (byte_value5 >> 6);

*prot_seq = translation[codon];

codon = byte_value5 & 63;

*prot_seq = translation[codon];

byte_value = *nt_seq;

codon = byte_value & 63;

*prot_seq = translation[codon];

}

(

== 0) {

byte_value = *nt_seq;

codon = ((byte_value) >> 2);

*prot_seq = translation[codon];

byte_value = *(nt_seq_end);

last_byte = *(nt_seq_end+1);

codon = (last_byte >> 2);

}

(

== 2) {

codon = ((byte_value & 15) << 2);

codon += (last_byte >> 6);

}

(

== 3) {

codon = ((byte_value & 3) << 4);

codon += (last_byte >> 4);

*prot_seq = translation[codon];

nt_seq_start = (

*) nt_seq;

= remainder+frame;

codon = (last_byte >> 6);

byte_value = *nt_seq;

codon += ((byte_value & 15) << 2);

}

(

== 1) {

codon = (last_byte >> 4);

byte_value = *nt_seq;

codon += ((byte_value & 3) << 4);

}

(

== 2) {

codon = (last_byte >> 2);

*prot_seq = translation[codon];

= 3 + (remainder + frame + 1);

byte_value = *nt_seq;

(nt_seq > nt_seq_start) {

codon = (byte_value & 63);

*prot_seq = translation[codon];

codon = (byte_value >> 6);

byte_value = *nt_seq;

codon += ((byte_value & 15) << 2);

*prot_seq = translation[codon];

(nt_seq <= nt_seq_start) {

codon = (byte_value >> 4);

byte_value = *nt_seq;

codon += ((byte_value & 3) << 4);

*prot_seq = translation[codon];

(nt_seq <= nt_seq_start) {

codon = (byte_value >> 2);

*prot_seq = translation[codon];

byte_value = *nt_seq;

(nt_seq > (nt_seq_start+10)) {

byte_value1 = *(--nt_seq);

byte_value2 = *(--nt_seq);

byte_value3 = *(--nt_seq);

codon = (byte_value & 63);

*prot_seq = translation[codon];

codon = (byte_value >> 6);

codon += ((byte_value1 & 15) << 2);

*prot_seq = translation[codon];

byte_value4 = *(--nt_seq);

codon = (byte_value1 >> 4);

codon += ((byte_value2 & 3) << 4);

*prot_seq = translation[codon];

codon = (byte_value2 >> 2);

*prot_seq = translation[codon];

byte_value5 = *(--nt_seq);

codon = (byte_value3 & 63);

*prot_seq = translation[codon];

byte_value = *(--nt_seq);

codon = (byte_value3 >> 6);

codon += ((byte_value4 & 15) << 2);

*prot_seq = translation[codon];

codon = (byte_value4 >> 4);

codon += ((byte_value5 & 3) << 4);

*prot_seq = translation[codon];

codon = (byte_value5 >> 2);

*prot_seq = translation[codon];

byte_value = *nt_seq;

codon = (byte_value & 63);

*prot_seq = translation[codon];

}

(

== 2) {

codon = (byte_value >> 2);

*prot_seq = translation[codon];

(

)(prot_seq - prot_seq_start);

** rev_sequence_ptr)

* rev_sequence;

conversion_table[16] = {

(!rev_sequence_ptr)

rev_sequence[0] = rev_sequence[length+1] =

;

(index = 0; index < length; ++index) {

rev_sequence[length-index] = conversion_table[sequence[index]];

*rev_sequence_ptr = rev_sequence;

context_number = context_number %

;

(context_number) {

0: frame = 1;

;

1: frame = 2;

;

2: frame = 3;

;

3: frame = -1;

;

4: frame = -2;

;

5: frame = -3;

;

:

();

;

index, new_index;

(index=0, new_index=0; new_index < new_length-1;

new_buffer[new_index] =

new_buffer[new_index] =

(; index < length; index++) {

0: shift = 6;

;

1: shift = 4;

;

2: shift = 2;

;

new_buffer[new_index] |=

*packed_seq = new_buffer;

(

= 0; ; ++

) {

*seq++ = tmp_seq[

];

index1, index2, index3, bp1, bp2, bp3;

mapping[4] = {2,

(genetic_code ==

)

(translation ==

)

(index1=0; index1<4; index1++)

(index2=0; index2<4; index2++)

(index3=0; index3<4; index3++)

codon = (mapping[bp1]<<4) + (mapping[bp2]<<2) + (mapping[bp3]);

translation[(index3<<4) + (index2<<2) + index1] =

genetic_code[codon];

codon = (mapping[index1]<<4) + (mapping[index2]<<2) +

translation[(index1<<4) + (index2<<2) + index3] =

genetic_code[codon];

nucl_length,

* genetic_code,

** translation_buffer_ptr,

** frame_offsets_ptr,

** mixed_seq_ptr)

* translation_buffer,* mixed_seq;

* translation_table =

,* translation_table_rc =

;

* nucl_seq_rev;

* frame_offsets;

buffer_length =2*(nucl_length+1)+2;

((translation_buffer =

frame_offsets[0] = 0;

nucl_length, nucl_seq, frame, translation_buffer+

);

nucl_length, nucl_seq, frame, translation_buffer+

);

nucl_length, frame, translation_buffer+

, genetic_code);

(nucl_seq_rev);

(translation_table);

(translation_table_rc);

(mixed_seq_ptr) {

*mixed_seq_ptr = mixed_seq = (

*)

(2*nucl_length+3);

(

= 0;

<= nucl_length; ++

) {

*seq++ = translation_buffer[frame_offsets[index+

]+

];

(translation_buffer_ptr)

*translation_buffer_ptr = translation_buffer;

(translation_buffer);

(frame_offsets_ptr)

*frame_offsets_ptr = frame_offsets;

(frame_offsets);

** translation_buffer_ptr,

* protein_length,

** mixed_seq_ptr)

* translation_buffer;

(!mixed_seq_ptr) {

((translation_buffer =

(nucl_seq_rev);

nucl_length, frame, translation_buffer,

*protein_length = length;

frame_sign = ((frame < 0) ? -1 : 1);

((translation_buffer = (

*)

(nucl_length+2)) ==

)

(nucl_seq_rev);

nucl_length, (

)(frame_sign*index),

translation_buffer+

, genetic_code);

frame_offsets[index-1] =

;

*mixed_seq_ptr = (

*)

(nucl_length+2);

*protein_length = nucl_length;

(index = 0, seq = *mixed_seq_ptr; index <= nucl_length;

*seq = translation_buffer[frame_offsets[index%

] +

(nucl_seq_rev);

(translation_buffer_ptr)

*translation_buffer_ptr = translation_buffer;

(translation_buffer);

(frame >= -3 && frame <= 3 && frame != 0);

(frame == 1 || frame == -1);

frame == 1 ? 0 : 1;

(

< e - 1) {

(index=0; index<target_t->

; index++)

(target_t->

)

* gen_code_string,

retval->

= !is_ooframe;

(nucl_seq_rev);

* retval =

;

retval[

] = standard_probabilities->

[

];

* retval =

;

retval =

(

);

(p = retval; *p !=

; p++) {

*p =

((

)(*p));

( !progress_info ) {

(progress_info);

( !progress_info ) {

ESubjectMaskingType

Define the possible subject masking types.

#define COMPRESSION_RATIO

Compression ratio of nucleotide bases (4 bases in 1 byte)

#define sfree(x)

Safe free a pointer: belongs to a higher level header.

#define CODON_LENGTH

Codons are always of length 3.

#define NUM_STRANDS

Number of frames in a nucleotide sequence.

#define NUM_FRAMES

Number of frames to which we translate in translating searches.

@ ePrelimSearch

Preliminary stage.

BLAST filtering functions.

BlastMaskLoc * BlastMaskLocFree(BlastMaskLoc *mask_loc)

Deallocate memory for a BlastMaskLoc structure as well as the BlastSeqLoc's pointed to.

Boolean Blast_QueryIsTranslated(EBlastProgramType p)

Returns true if the query is translated.

Boolean Blast_SubjectIsNucleotide(EBlastProgramType p)

Returns true if the subject is nucleotide.

Boolean Blast_QueryIsNucleotide(EBlastProgramType p)

Returns true if the query is nucleotide.

Boolean Blast_QueryIsProtein(EBlastProgramType p)

Returns true if the query is protein.

Boolean Blast_ProgramIsValid(EBlastProgramType p)

Returns true if program is not undefined.

EBlastProgramType

Defines the engine's notion of the different applications of the BLAST algorithm.

Boolean Blast_SubjectIsTranslated(EBlastProgramType p)

Returns true if the subject is translated.

Uint4 QueryInfo_GetSeqBufLen(const BlastQueryInfo *qinfo)

Get the number of bytes required for the concatenated sequence buffer, given a query info structure.

Definitions and prototypes used by blast_stat.c to calculate BLAST statistics.

Blast_ResFreq * Blast_ResFreqFree(Blast_ResFreq *rfp)

Deallocates Blast_ResFreq and prob0 element.

Int2 Blast_ResFreqStdComp(const BlastScoreBlk *sbp, Blast_ResFreq *rfp)

Calculates residues frequencies given a standard distribution.

Blast_ResFreq * Blast_ResFreqNew(const BlastScoreBlk *sbp)

Allocates a new Blast_ResFreq structure and fills in the prob element based upon the contents of sbp.

Int4 BLAST_FrameToContext(Int2 frame, EBlastProgramType program)

Convert translation frame or strand into a context number suitable for indexing into the BlastQueryIn...

BLAST_SequenceBlk * BlastSequenceBlkFree(BLAST_SequenceBlk *seq_blk)

Deallocate memory for a sequence block.

static void s_BlastSequenceBlkFreeSeqRanges(BLAST_SequenceBlk *seq_blk)

Auxiliary function to free the BLAST_SequenceBlk::seq_ranges field if applicable.

Int2 BlastSeqBlkSetSeqRanges(BLAST_SequenceBlk *seq_blk, SSeqRange *seq_ranges, Uint4 num_seq_ranges, Boolean copy_seq_ranges, ESubjectMaskingType mask_type)

Sets the seq_range and related fields appropriately in the BLAST_SequenceBlk structure.

void SBlastProgressReset(SBlastProgress *progress_info)

Resets the progress structure to its original state (as if newly allocated) for a fresh start without...

Int4 SSeqRangeArrayLessThanOrEqual(const SSeqRange *ranges, Int4 num_ranges, Int4 target)

Returns the index of the range, such that this element is the first range that either contains the ta...

Int2 BlastSeqBlkSetSequence(BLAST_SequenceBlk *seq_blk, const Uint1 *sequence, Int4 seqlen)

Stores the sequence in the sequence block structure.

SBlastProgress * SBlastProgressNew(void *user_data)

Allocates and initializes a new SBlastProgress structure.

SSeqRange SSeqRangeNew(Int4 start, Int4 stop)

Create a new SSeqRange structure with both fields initialized.

size_t BLAST_GetTranslatedProteinLength(size_t nucleotide_length, unsigned int context)

Calculates the length of frame for a translated protein.

SBlastProgress * SBlastProgressFree(SBlastProgress *progress_info)

Deallocates a SBlastProgress structure.

Int2 BLAST_CreateMixedFrameDNATranslation(BLAST_SequenceBlk *query_blk, const BlastQueryInfo *query_info)

Initialize the mixed-frame sequence for out-of-frame gapped extension.

Int2 BlastNumber2Program(EBlastProgramType number, char **program)

Return string name for program given a number.

static Uint1 s_CodonToAA(Uint1 *codon, const Uint1 *codes)

Translate 3 nucleotides into an amino acid MUST have 'X' as unknown amino acid.

Int2 BlastSeqBlkSetCompressedSequence(BLAST_SequenceBlk *seq_blk, const Uint1 *sequence)

Stores the compressed nucleotide sequence in the sequence block structure for the subject sequence wh...

int Blast_GetPartialTranslation(const Uint1 *nucl_seq, Int4 nucl_length, Int2 frame, const Uint1 *genetic_code, Uint1 **translation_buffer_ptr, Int4 *protein_length, Uint1 **mixed_seq_ptr)

Get one frame translation - needed when only parts of subject sequences are translated.

Int2 BlastTargetTranslationNew(BLAST_SequenceBlk *subject_blk, const Uint1 *gen_code_string, EBlastProgramType program_number, Boolean is_ooframe, SBlastTargetTranslation **target)

Sets up structure for target translation.

Int2 BlastSetUp_SeqBlkNew(const Uint1 *buffer, Int4 length, BLAST_SequenceBlk **seq_blk, Boolean buffer_allocated)

Allocates memory for *sequence_blk and then populates it.

Int1 BLAST_ContextToFrame(EBlastProgramType prog_number, Uint4 context_number)

This function translates the context number of a context into the frame of the sequence.

Int2 BLAST_PackDNA(const Uint1 *buffer, Int4 length, EBlastEncoding encoding, Uint1 **packed_seq)

Convert a sequence in ncbi4na or blastna encoding into a packed sequence in ncbi2na encoding.

SBlastTargetTranslation * BlastTargetTranslationFree(SBlastTargetTranslation *target_t)

Free SBlastTargetTranslation.

Int2 BlastCompressBlastnaSequence(BLAST_SequenceBlk *seq_blk)

Adds a specialized representation of sequence data to a sequence block.

Int4 BLAST_GetTranslation(const Uint1 *query_seq, const Uint1 *query_seq_rev, Int4 nt_length, Int2 frame, Uint1 *prot_seq, const Uint1 *genetic_code)

GetTranslation to get the translation of the nucl.

void BlastSequenceBlkClean(BLAST_SequenceBlk *seq_blk)

Deallocate memory only for the sequence in the sequence block.

Int2 BLAST_GetAllTranslations(const Uint1 *nucl_seq, EBlastEncoding encoding, Int4 nucl_length, const Uint1 *genetic_code, Uint1 **translation_buffer_ptr, Uint4 **frame_offsets_ptr, Uint1 **mixed_seq_ptr)

Translate nucleotide into 6 frames.

unsigned int BLAST_GetNumberOfContexts(EBlastProgramType p)

Get the number of contexts for a given program.

Int2 BlastProgram2Number(const char *program, EBlastProgramType *number)

Set number for a given program type.

Int2 GetReverseNuclSequence(const Uint1 *sequence, Int4 length, Uint1 **rev_sequence_ptr)

Reverse a nucleotide sequence in the blastna encoding, adding sentinel bytes on both ends.

Int2 BlastSeqBlkNew(BLAST_SequenceBlk **retval)

Allocates a new sequence block structure.

Int4 BSearchInt4(Int4 n, Int4 *A, Int4 size)

The following binary search routine assumes that array A is filled.

static Uint1 * s_BlastGetTranslationTable(const Uint1 *genetic_code, Boolean reverse_complement)

Gets the translation array for a given genetic code.

char * BLAST_StrToUpper(const char *string)

Returns a copy of the input string with all its characters turned to uppercase.

void BlastSequenceBlkCopy(BLAST_SequenceBlk **copy, BLAST_SequenceBlk *src)

Copies contents of the source sequence block without copying sequence buffers; sets all "field_alloca...

void __sfree(void **x)

Implemented in blast_util.c.

double * BLAST_GetStandardAaProbabilities()

Get the standard amino acid probabilities.

Int4 BLAST_TranslateCompressedSequence(Uint1 *translation, Int4 length, const Uint1 *nt_seq, Int2 frame, Uint1 *prot_seq)

Translate a nucleotide sequence without ambiguity codes.

Various auxiliary BLAST utility functions.

#define NCBI2NA_MASK

Bit mask for obtaining a single base from a byte in ncbi2na format.

#define FENCE_SENTRY

This sentry value is used as a 'fence' around the valid portions of partially decoded sequences.

#define IS_residue(x)

Does character encode a residue?

EBlastEncoding

Different types of sequence encodings for sequence retrieval from the BLAST database.

#define BLASTAA_SIZE

Size of aminoacid alphabet.

const Uint1 NCBI4NA_TO_BLASTNA[]

Translates between ncbi4na and blastna.

#define BLASTAA_SEQ_CODE

== Seq_code_ncbistdaa

const Uint1 AMINOACID_TO_NCBISTDAA[]

Translates between ncbieaa and ncbistdaa.

@ eBlastEncodingNcbi4na

NCBI4na.

@ eBlastEncodingNucleotide

Special encoding for preliminary stage of BLAST: permutation of NCBI4na.

@ eBlastEncodingNcbi2na

NCBI2na.

uint8_t Uint1

1-byte (8-bit) unsigned integer

int16_t Int2

2-byte (16-bit) signed integer

int32_t Int4

4-byte (32-bit) signed integer

uint32_t Uint4

4-byte (32-bit) unsigned integer

int8_t Int1

1-byte (8-bit) signed integer

const struct ncbi::grid::netcache::search::fields::SIZE size

#define INT1_MAX

largest number represented by signed short (one byte)

#define MIN(a, b)

returns smaller of a and b.

void * BlastMemDup(const void *orig, size_t size)

Copies memory using memcpy and malloc.

Uint1 Boolean

bool replacment for C

#define TRUE

bool replacment for C indicating true.

#define FALSE

bool replacment for C indicating false.

#define ABS(a)

returns absolute value of a (|a|)

#define NULLB

terminating byte of a char* string.

#define ASSERT

macro for assert.

void copy(Njn::Matrix< S > *matrix_, const Njn::Matrix< T > &matrix0_)

Structure to hold a sequence.

Uint1 * sequence_start

Start of sequence, usually one byte before sequence as that byte is a NULL sentinel byte.

Uint1 * compressed_nuc_seq_start

start of compressed_nuc_seq

Uint4 num_seq_ranges

Number of elements in seq_ranges.

Boolean sequence_allocated

TRUE if memory has been allocated for sequence.

BlastMaskLoc * lcase_mask

Locations to be masked from operations on this sequence: lookup table for query; scanning for subject...

SSeqRange * seq_ranges

Ranges of the sequence to search.

Boolean lcase_mask_allocated

TRUE if memory has been allocated for lcase_mask.

Int4 length

Length of sequence.

ESubjectMaskingType mask_type

type of subject masking

Uint1 * sequence_nomask

Start of query sequence without masking.

Boolean seq_ranges_allocated

TRUE if memory has been allocated for seq_ranges.

Uint1 * sequence_start_nomask

Query sequence without masking.

Uint1 * sequence

Sequence used for search (could be translation).

Boolean oof_sequence_allocated

TRUE if memory has been allocated for oof_sequence.

Boolean nomask_allocated

If false the two above are just pointers to sequence and sequence_start.

Uint1 * compressed_nuc_seq

4-to-1 compressed version of sequence

Boolean sequence_start_allocated

TRUE if memory has been allocated for sequence_start.

Uint1 * oof_sequence

Mixed-frame protein representation of a nucleotide sequence for out-of-frame alignment.

Int4 query_length

Length of this query, strand or frame.

Int4 query_offset

Offset of this query, strand or frame in the concatenated super-query.

The query related information.

BlastContextInfo * contexts

Information per context.

Int4 last_context

Index of the last element of the context array.

Structure used for scoring calculations.

Boolean protein_alphabet

TRUE if alphabet_code is for a protein alphabet (e.g., ncbistdaa etc.), FALSE for nt.

Int2 alphabet_size

size of alphabet.

Uint1 alphabet_code

NCBI alphabet code.

Stores the letter frequency of a sequence or database.

double * prob

letter probs, (possible) non-zero offset.

Progress monitoring structure.

EBlastStage stage

Stage of the BLAST search currently in progress.

void * user_data

Pointer to user-provided data.

Information about target translations.

EBlastProgramType program_number

Program being run.

Int4 * range

start and stop of translated sequences.

Int4 num_frames

how many frames, one dimension of translation_buffer.

const Uint1 * gen_code_string

Genetic code string for translation.

BLAST_SequenceBlk * subject_blk

target sequence being translated.

Uint1 ** translations

two dimensional array for translations.

Boolean partial

specifies that nucleotide sequence is too long to translated.

A structure containing two integers, used e.g.

Int4 left

left endpoint of range (zero based)

Int4 right

right endpoint of range (zero based)

static CS_CONTEXT * context

static Uint4 reverse_complement(Uint4 seq, Uint1 size)

voidp calloc(uInt items, uInt size)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4