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__filter_8c_source.html below:

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

(not_started && *ptr ==

)

(not_started ==

)

(*buffer_ptr ==

&& buffer_ptr >

)

ptr = strstr(repeat_options,

);

(*ptr ==

|| *ptr ==

)

(!winmask_options)

ptr = strstr(winmask_options,

);

(*ptr ==

|| *ptr ==

)

(endp = *

; *endp; ++endp) {

(*endp ==

|| *endp ==

) {

ptr = strstr(winmask_options,

);

(*ptr ==

|| *ptr ==

)

arg, index, index1, window_pri=-1, linker_pri=-1, level_pri=-1;

(*ptr ==

|| *ptr ==

)

sscanf(

,

, &tmplong);

level_pri = (

)tmplong;

sscanf(

,

, &tmplong);

window_pri = (

)tmplong;

sscanf(

,

, &tmplong);

linker_pri = (

)tmplong;

[index1] = *ptr; ptr++;

(arg != 0 && arg != 3)

*window = window_pri;

*linker = linker_pri;

arg, index, index1;

(*ptr ==

|| *ptr ==

)

sscanf(

,

, &tmplong);

sscanf(

,

, &tmpdouble);

sscanf(

,

, &tmpdouble);

[index1] = *ptr; ptr++;

(arg != 0 && arg != 3)

(

** dest,

* dest_size,

* string2append)

dest_length = strlen(*dest);

string2append_length = strlen(string2append);

((dest_length + string2append_length + 1) > *dest_size) {

target_size =

(string2append_length, dest_length) * 2;

*dest = (

*)realloc((

*)*dest, target_size);

(*dest_size) = (

)target_size;

(*dest, string2append);

* retval =

;

retval_size = 0;

(filtering_options ==

) {

retval = (

*)

(retval_size,

(

));

[24] = {

};

[24] = {

};

snprintf(

,

(

),

,

[24] = {

};

(strlen(retval) != 0) {

strlen(retval) == 0

* instructions,

* ptr = instructions;

error_buffer[1024];

*filtering_options =

;

*blast_message =

;

= (

*)

(strlen(instructions),

(char));

(ptr[0] ==

&& ptr[1] ==

)

mask_at_hash =

;

(*ptr !=

)

locut = .0, hicut = .0;

snprintf(error_buffer,

(error_buffer),

,

);

segOptions->

= window;

segOptions->

= locut;

segOptions->

= hicut;

(*ptr ==

)

window = 0, level = 0, linker = 0;

snprintf(error_buffer,

(error_buffer),

,

);

dustOptions->

= level;

dustOptions->

= window;

dustOptions->

= linker;

(*ptr ==

)

snprintf(error_buffer,

(error_buffer),

,

);

(*ptr ==

)

snprintf(error_buffer,

(error_buffer),

,

);

winmaskOptions->

= taxid;

(*ptr ==

|| *ptr ==

)

(*ptr ==

)

mask_at_hash =

;

(*filtering_options)->dustOptions = dustOptions;

(*filtering_options)->segOptions = segOptions;

(*filtering_options)->repeatFilterOptions = repeatOptions;

(*filtering_options)->windowMaskerOptions = winmaskOptions;

(*filtering_options)->mask_at_hash = mask_at_hash;

num_elems = 0,

= 0;

(num_elems == 0) {

*

= ptrs[num_elems-1];

(

= num_elems-1;

> 0;

--) {

ptrs[

]->

= ptrs[

-1];

(index = 0; index < mask_loc->

; index++) {

(mask_loc ==

)

(index=0; index<mask_loc->

; index++)

memset((

*) &dna_seqlocs, 0,

(dna_seqlocs));

memcpy((

*) &dna_seqlocs,

(dna_seqlocs));

memset((

*) &mask_loc->

[ctx_idx], 0,

(dna_seqlocs));

(frame_seqloc ==

&& dna_seqlocs[0]) {

frame_seqloc = dna_seqlocs[0];

(itr = frame_seqloc; itr; itr = itr->

) {

(from < query_info->contexts[ctx_idx+

].query_length);

(to < query_info->contexts[ctx_idx+

].query_length);

(index=0; index < query_info->

; ++index)

(frame_index=frame_start; frame_index<(frame_start+

);

(from >= dna_length)

from = dna_length - 1;

(to >= dna_length)

(from < dna_length);

seq_range->

= from;

seq_range->

= to;

(loc1->

< loc2->left)

(loc1->

> loc2->left)

= 0, num_elems = 0;

(num_elems == 0) {

qsort(ptrs, (

)num_elems,

(*ptrs),

(

= 0;

< num_elems - 1;

++) {

((stop + link_value) > next_ssr->

) {

curr_tail = ptrs[

+1];

(

= 1;

< num_elems;

++) {

tail->

= ptrs[

];

(complement_mask ==

)

*complement_mask =

;

context <= query_info->last_context; ++

) {

start_offset, end_offset, filter_start, filter_end;

(start_offset <= end_offset);

start_offset, end_offset);

( ; loc; loc = loc->

) {

filter_start = end_offset - seq_range->

;

filter_end = end_offset - seq_range->

;

filter_start = start_offset + seq_range->

;

filter_end = start_offset + seq_range->

;

last_interval_open =

;

(filter_start > start_offset) {

left = start_offset;

left = filter_end + 1;

right = filter_start - 1;

tail =

((tail ? &tail : complement_mask), left, right);

(filter_end >= end_offset) {

last_interval_open =

;

left = filter_end + 1;

(last_interval_open) {

tail =

((tail ? &tail : complement_mask), left, right);

*seqloc_retval =

;

(seg_options->

> 0)

(seg_options->

> 0.0)

(seg_options->

> 0.0)

(; masks; masks = masks->

) {

query_length = 0;

context_offset;

(context < query_blk->lcase_mask->total_size);

kNumContexts = query_info->

+ 1;

(query_info && query_blk && filter_maskloc);

context <= query_info->last_context; ++

) {

&filter_per_context,

);

(*filter_maskloc)->seqloc_array[

] = filter_per_context;

(; mask_loc; mask_loc = mask_loc->

) {

index, start, stop;

start = length - 1 - mask_loc->

->

;

stop = length - 1 - mask_loc->

->

;

start = mask_loc->

->

;

(index = start; index <= stop; index++)

[index] = kMaskingLetter;

(

= 0;

< length;

++) {

(sequence[

] >= min_invalid) {

(index=0; index<filter_maskloc->

; index++)

(has_mask ==

)

context <= query_info->last_context; ++

) {

query_length = 0;

context_offset = 0;

#define sfree(x)

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

const double kSegLocut

Locut parameter for SEG.

const int kDustLinker

Parameter used by dust to link together close low-complexity segments.

const int kSegWindow

Window that SEG examines at once.

#define CODON_LENGTH

Codons are always of length 3.

#define NUM_FRAMES

Number of frames to which we translate in translating searches.

const double kSegHicut

Hicut parameter for SEG.

const int kDustLevel

Level parameter used by dust.

const int kDustWindow

Window parameter used by dust.

#define NCBI_XBLAST_EXPORT

NULL operations for other cases.

static Int2 s_ParseRepeatOptions(const char *repeat_options, char **dbname)

Parses repeat filtering options string.

void Blast_MaskUnsupportedAA(BLAST_SequenceBlk *seq, Uint1 min_invalid)

Mask protein letters that are currently unsupported.

void BlastSetUp_MaskQuery(BLAST_SequenceBlk *query_blk, const BlastQueryInfo *query_info, const BlastMaskLoc *filter_maskloc, EBlastProgramType program_number)

Masks the sequence given a BlastMaskLoc.

BlastMaskLoc * BlastMaskLocDup(const BlastMaskLoc *mask_loc)

Perform a deep copy of the BlastMaskLoc structure passed to this function.

static Int2 s_ParseDustOptions(const char *ptr, int *level, int *window, int *linker)

Parses options used for dust.

BlastMaskLoc * BlastMaskLocFree(BlastMaskLoc *mask_loc)

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

static Int4 s_BlastSeqLocLen(const BlastSeqLoc *var)

Calculates number of links in a chain of BlastSeqLoc's.

const Uint1 kProtMask

NCBISTDAA element used to mask residues in BLAST.

Int2 BLAST_ComplementMaskLocations(EBlastProgramType program_number, const BlastQueryInfo *query_info, const BlastMaskLoc *mask_loc, BlastSeqLoc **complement_mask)

This function takes the list of mask locations (i.e., regions that should not be searched or not adde...

static Int2 s_GetFilteringLocationsForOneContext(BLAST_SequenceBlk *query_blk, const BlastQueryInfo *query_info, Int4 context, EBlastProgramType program_number, const SBlastFilterOptions *filter_options, BlastSeqLoc **filter_out, Blast_Message **blast_message)

Calculates the mask locations one context at a time.

BlastSeqLoc * BlastSeqLocListDup(BlastSeqLoc *head)

Make a deep copy of the linked list of BlastSeqLoc-s pointed to by its argument.

Int2 BlastSetUp_GetFilteringLocations(BLAST_SequenceBlk *query_blk, const BlastQueryInfo *query_info, EBlastProgramType program_number, const SBlastFilterOptions *filter_options, BlastMaskLoc **filter_maskloc, Blast_Message **blast_message)

Does preparation for filtering and then calls BlastSetUp_Filter.

void Blast_MaskTheResidues(Uint1 *buffer, Int4 length, Boolean is_na, const BlastSeqLoc *mask_loc, Boolean reverse, Int4 offset)

Masks the letters in buffer.

BlastSeqLoc * BlastSeqLocNodeFree(BlastSeqLoc *loc)

Deallocate a single BlastSeqLoc structure and its contents, without following its next pointer.

void BlastSeqLocReverse(BlastSeqLoc *masks, Int4 query_length)

Converts reverse strand coordinates to forward strand in place.

static BlastSeqLoc * s_BlastSeqLocNodeDup(BlastSeqLoc *source)

Makes a copy of the BlastSeqLoc and also a copy of the SSRange element.

Int2 BlastFilteringOptionsFromString(EBlastProgramType program_number, const char *instructions, SBlastFilterOptions **filtering_options, Blast_Message **blast_message)

Produces SBlastFilterOptions from a string that has been traditionally supported in blast.

static Int2 s_ParseSegOptions(const char *ptr, Int4 *window, double *locut, double *hicut)

parses a string to set three seg options.

const Uint1 kNuclMask

BLASTNA element used to mask bases in BLAST.

Int2 BlastSetUp_Filter(EBlastProgramType program_number, Uint1 *sequence, Int4 length, Int4 offset, const SBlastFilterOptions *filter_options, BlastSeqLoc **seqloc_retval, Blast_Message **blast_message)

Runs seg filtering functions, according to the filtering options, returns BlastSeqLoc*.

static const char * s_LoadOptionsToBuffer(const char *instructions, char *buffer)

Copies filtering commands for one filtering algorithm from "instructions" to "buffer".

#define BLASTOPTIONS_BUFFER_SIZE

Allowed length of the filtering options string.

static char * s_SafeStrCat(char **dest, unsigned int *dest_size, const char *string2append)

Wrapper around strcat to ensure we don't do buffer overflows :)

static Int2 s_ParseWindowMaskerOptions(const char *winmask_options, char **dbname, int *taxid)

Parses window masker options string.

Int2 BlastMaskLocDNAToProtein(BlastMaskLoc *mask_loc, const BlastQueryInfo *query_info)

Given a BlastMaskLoc with an array of lists of DNA mask locations, substitutes that array by a new ar...

static BlastSeqLoc ** s_BlastSeqLocListToArrayOfPointers(const BlastSeqLoc *list, Int4 *count)

Converts a BlastSeqLoc list to an array of pointers, each pointing to an element of the list passed i...

static int s_SeqRangeSortByStartPosition(const void *vp1, const void *vp2)

Used for qsort, compares two SeqLoc's by starting position.

BlastSeqLoc * BlastSeqLocAppend(BlastSeqLoc **head, BlastSeqLoc *node)

Appends the BlastSeqLoc to the list of BlastSeqLoc-s pointed to by head.

void BlastSeqLocCombine(BlastSeqLoc **mask_loc, Int4 link_value)

Go through all mask locations in one sequence and combine any that overlap, deallocating the unneeded...

BlastMaskLoc * BlastMaskLocNew(Int4 total)

Allocate memory for a BlastMaskLoc.

void BlastSeqLocListReverse(BlastSeqLoc **head)

Reverse elements in the list.

BlastSeqLoc * BlastSeqLocFree(BlastSeqLoc *loc)

Deallocate all BlastSeqLoc objects in a chain.

BlastSeqLoc * BlastSeqLocNew(BlastSeqLoc **head, Int4 from, Int4 to)

Create and initialize a new sequence interval.

Int2 BlastMaskLocProteinToDNA(BlastMaskLoc *mask_loc, const BlastQueryInfo *query_info)

Given a BlastMaskLoc with an array of lists of mask locations per protein frame, recalculates all mas...

char * BlastFilteringOptionsToString(const SBlastFilterOptions *filtering_options)

Convert the filtering options structure to a string.

BLAST filtering functions.

static NCBI_INLINE Boolean BlastIsReverseStrand(Boolean is_na, Int4 context)

Determines whether this is a nucleotide query and whether this a minus strand or not.

Int2 Blast_MessageWrite(Blast_Message **blast_msg, EBlastSeverity severity, int context, const char *message)

Writes a message to a structure.

const int kBlastMessageNoContext

Declared in blast_message.h as extern const.

Int2 SRepeatFilterOptionsNew(SRepeatFilterOptions **repeat_options)

Allocates memory for SRepeatFilterOptions, fills in defaults.

SDustOptions * SDustOptionsFree(SDustOptions *dust_options)

Frees SDustOptions.

Boolean SBlastFilterOptionsMaskAtHash(const SBlastFilterOptions *filter_options)

Queries whether masking should be done only for the lookup table or for the entire search.

Int2 SBlastFilterOptionsValidate(EBlastProgramType program_number, const SBlastFilterOptions *filter_options, Blast_Message **blast_message)

Validates filter options to ensure that program and options are consistent and that options have vali...

SRepeatFilterOptions * SRepeatFilterOptionsFree(SRepeatFilterOptions *repeat_options)

Frees SRepeatFilterOptions.

Int2 SSegOptionsNew(SSegOptions **seg_options)

Allocates memory for SSegOptions, fills in defaults.

SWindowMaskerOptions * SWindowMaskerOptionsFree(SWindowMaskerOptions *winmask_options)

Frees SWindowMaskerOptions.

Int2 SWindowMaskerOptionsNew(SWindowMaskerOptions **winmask_options)

Allocates memory for SWindowMaskerOptions, fills in defaults.

Int2 SDustOptionsNew(SDustOptions **dust_options)

Allocates memory for SDustOptions, fills in defaults.

SSegOptions * SSegOptionsFree(SSegOptions *seg_options)

Frees SSegOptions.

@ eEmpty

no filtering at all.

Int2 SBlastFilterOptionsNew(SBlastFilterOptions **filter_options, EFilterOptions type)

Allocates memory for SBlastFilterOptions and.

EBlastProgramType

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

Int4 BlastQueryInfoGetQueryLength(const BlastQueryInfo *qinfo, EBlastProgramType program, Int4 query_index)

Obtains the sequence length for a given query in the query, without taking into consideration any app...

Int2 SeqBufferSeg(Uint1 *sequence, Int4 length, Int4 offset, SegParameters *sparamsp, BlastSeqLoc **seg_locs)

Runs seg on a protein sequence in ncbistdaa.

SegParameters * SegParametersNewAa(void)

Allocated SeqParameter struct for proteins and fills with default values.

void SegParametersFree(SegParameters *sparamsp)

Free SegParameters structure.

Various auxiliary BLAST utility functions.

Int1 BLAST_ContextToFrame(EBlastProgramType prog_number, Uint4 context_number)

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

unsigned int BLAST_GetNumberOfContexts(EBlastProgramType program)

Get the number of contexts for a given program.

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

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

char * dbname(DBPROCESS *dbproc)

Get name of current database.

unsigned int

A callback function used to compare two keys in a database.

Int2 FilterQueriesForMapping(Uint1 *sequence, Int4 length, Int4 offset, const SReadQualityOptions *options, BlastSeqLoc **seq_loc)

const CharType(& source)[N]

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 NULLB

terminating byte of a char* string.

#define ASSERT

macro for assert.

#define MAX(a, b)

returns larger of a and b.

Structure to hold a sequence.

Uint1 * sequence_start

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

BlastMaskLoc * lcase_mask

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

Int4 length

Length of sequence.

Uint1 * sequence_nomask

Start of query sequence without masking.

Uint1 * sequence_start_nomask

Query sequence without masking.

Uint1 * sequence

Sequence used for search (could be translation).

Boolean nomask_allocated

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

Int4 query_length

Length of this query, strand or frame.

Boolean is_valid

Determine if this context is valid or not.

Int4 query_offset

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

Structure for keeping the query masking information.

Int4 total_size

Total size of the BlastSeqLoc array below.

BlastSeqLoc ** seqloc_array

Array of masked locations.

The query related information.

Int4 first_context

Index of the first element of the context array.

BlastContextInfo * contexts

Information per context.

int num_queries

Number of query sequences.

Int4 last_context

Index of the last element of the context array.

Used to hold a set of positions, mostly used for filtering.

SSeqRange * ssr

location data on the sequence.

struct BlastSeqLoc * next

next in linked list

Structure to hold the a message from the core of the BLAST engine.

SRepeatFilterOptions * repeatFilterOptions

for organism specific repeat filtering.

SSegOptions * segOptions

low-complexity filtering for proteins sequences (includes translated nucleotides).

SReadQualityOptions * readQualityOptions

quality filtering for mapping next-generation sequences

SWindowMaskerOptions * windowMaskerOptions

organism specific filtering with window masker.

SDustOptions * dustOptions

low-complexity filtering for nucleotides.

Options for dust algorithm, applies only to nucl.

int linker

min distance to link segments.

Filtering options for organsim specific repeats filtering.

char * database

Nucleotide database for mini BLAST search.

Options for SEG algorithm, applies only to protein-protein comparisons.

int window

initial window to trigger further work.

A structure containing two integers, used e.g.

Int4 left

left endpoint of range (zero based)

Int4 right

right endpoint of range (zero based)

Filtering options for organism-specific filtering with Window Masker.

const char * database

Use winmasker database at this location.

int taxid

Select masking database for this TaxID.

Structure to hold parameters for seg search.

Int4 window

initial window size to trigger further work.

static CS_CONTEXT * context

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