A RetroSearch Logo

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

Search Query:

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

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

46  return lookup

->thick_backbone[index].num_used;

64  Int4

num_hits =

lookup

->thick_backbone[index].num_used;

70

lookup_pos =

lookup

->thick_backbone[index].payload.entries;

72

lookup_pos =

lookup

->overflow +

73  lookup

->thick_backbone[index].payload.overflow_cursor;

76  for

(

i

=0;

i

<num_hits;

i

++) {

101  Uint1

*abs_start, *s_end;

111

abs_start =

subject

->sequence;

115  for

(; s <= s_end; s++) {

117  Int4

index = s[0] << 8 | s[1];

122  if

(num_hits > (max_hits - total_hits))

127

offset_pairs + total_hits,

129

total_hits += num_hits;

160  Int4

lut_word_length;

165

abs_start =

subject

->sequence;

167

scan_step =

lookup

->scan_step;

168

lut_word_length =

lookup

->lut_word_length;

172  if

(lut_word_length > 5) {

189  Int4

shift = 2 * (8 - lut_word_length);

193  for

(; s <= s_end; s += scan_step) {

194

index = s[0] << 8 | s[1];

195

index = index >> shift;

200  if

(num_hits > (max_hits - total_hits))

205

offset_pairs + total_hits,

207

total_hits += num_hits;

224  for

(; scan_range[0] <= scan_range[1]; scan_range[0] += scan_step) {

229

index = s[0] << 16 | s[1] << 8 | s[2];

230

index = (index >> shift) &

mask

;

236  if

(num_hits > (max_hits - total_hits))

241

offset_pairs + total_hits, scan_range[0]);

242

total_hits += num_hits;

254  for

(; scan_range[0] <= scan_range[1]; scan_range[0] += scan_step) {

259

index = s[0] << 8 | s[1];

260

index = (index >> shift) &

mask

;

266  if

(num_hits > (max_hits - total_hits))

271

offset_pairs + total_hits,

273

total_hits += num_hits;

290  if

(

lookup

->lut_word_length == 8 &&

lookup

->scan_step == 4)

311

offset_pairs[total_hits].qs_offsets.q_off = index;

312

offset_pairs[total_hits].qs_offsets.s_off = s_off;

317  Int4

src_off = -index;

318

index = overflow[src_off++];

320

offset_pairs[total_hits+num_hits].qs_offsets.q_off = index;

321

offset_pairs[total_hits+num_hits].qs_offsets.s_off = s_off;

323

index = overflow[src_off++];

324

}

while

(index >= 0);

331 #define SMALL_NA_ACCESS_HITS(x) \ 333  if (total_hits > max_hits) { \ 334  scan_range[0] += (x); \ 337  total_hits += s_BlastSmallNaRetrieveHits(offset_pairs, \ 338  index, scan_range[0] + (x), \ 361  const Int4

kLutWordLength = 8;

362  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

363  Int4

num_words = (scan_range[1] - scan_range[0]) / 4 + 1;

374

max_hits -=

lookup

->longest_chain;

377  switch

(num_words % 8) {

378  case

1: s -= 7; scan_range[0] -= 28;

goto

byte_7;

379  case

2: s -= 6; scan_range[0] -= 24;

goto

byte_6;

380  case

3: s -= 5; scan_range[0] -= 20;

goto

byte_5;

381  case

4: s -= 4; scan_range[0] -= 16;

goto

byte_4;

382  case

5: s -= 3; scan_range[0] -= 12;

goto

byte_3;

383  case

6: s -= 2; scan_range[0] -= 8;

goto

byte_2;

384  case

7: s -= 1; scan_range[0] -= 4;

goto

byte_1;

387  while

(scan_range[0] <= scan_range[1]) {

389

init_index = init_index << 8 | s[1];

390

index = backbone[init_index & kLutWordMask];

393

init_index = init_index << 8 | s[2];

394

index = backbone[init_index & kLutWordMask];

397

init_index = init_index << 8 | s[3];

398

index = backbone[init_index & kLutWordMask];

401

init_index = init_index << 8 | s[4];

402

index = backbone[init_index & kLutWordMask];

405

init_index = init_index << 8 | s[5];

406

index = backbone[init_index & kLutWordMask];

409

init_index = init_index << 8 | s[6];

410

index = backbone[init_index & kLutWordMask];

413

init_index = init_index << 8 | s[7];

414

index = backbone[init_index & kLutWordMask];

417

init_index = init_index << 8 | s[8];

419

index = backbone[init_index & kLutWordMask];

452  Int4

lut_word_length =

lookup

->lut_word_length;

458

max_hits -=

lookup

->longest_chain;

460  if

(lut_word_length > 5) {

477  Int4

shift = 2 * (8 - lut_word_length);

481  for

(; s <= s_end; s += scan_step) {

482

index = s[0] << 8 | s[1];

483

index = backbone[index >> shift];

485  if

(total_hits > max_hits)

510  for

(; scan_range[0] <= scan_range[1]; scan_range[0] += scan_step) {

515

index = s[0] << 16 | s[1] << 8 | s[2];

516

index = backbone[(index >> shift) &

mask

];

529  for

(; scan_range[0] <= scan_range[1]; scan_range[0] += scan_step) {

534

index = s[0] << 8 | s[1];

535

index = backbone[(index >> shift) &

mask

];

562  const Int4

kLutWordLength = 4;

563  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

571

max_hits -=

lookup

->longest_chain;

581

init_index = s[0] << 8 | s[1];

584

init_index = s[0] << 8 | s[1];

588  while

(scan_range[0] <= scan_range[1]) {

591

index = backbone[init_index];

596  if

(scan_range[0] > scan_range[1])

599

init_index = init_index << 8 | s[1];

600

index = backbone[(init_index >> 6) & kLutWordMask];

605  if

(scan_range[0] > scan_range[1])

608

index = backbone[(init_index >> 4) & kLutWordMask];

613  if

(scan_range[0] > scan_range[1])

617

index = backbone[(init_index >> 2) & kLutWordMask];

644  const Int4

kLutWordLength = 5;

645  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

653

max_hits -=

lookup

->longest_chain;

660

init_index = s[0] << 8 | s[1];

663

init_index = s[0] << 8 | s[1];

666

init_index = s[0] << 8 | s[1];

670  while

(scan_range[0] <= scan_range[1]) {

672

init_index = s[0] << 8 | s[1];

673

index = backbone[init_index >> 6];

678  if

(scan_range[0] > scan_range[1])

681

index = backbone[(init_index >> 4) & kLutWordMask];

686  if

(scan_range[0] > scan_range[1])

689

index = backbone[(init_index >> 2) & kLutWordMask];

694  if

(scan_range[0] > scan_range[1])

698

index = backbone[init_index & kLutWordMask];

724  const Int4

kLutWordLength = 6;

725  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

733

max_hits -=

lookup

->longest_chain;

740

init_index = s[0] << 8 | s[1];

743

init_index = s[0] << 8 | s[1];

746

init_index = s[0] << 8 | s[1];

750  while

(scan_range[0] <= scan_range[1]) {

752

init_index = s[0] << 8 | s[1];

753

index = backbone[init_index >> 4];

758  if

(scan_range[0] > scan_range[1])

761

index = backbone[(init_index >> 2) & kLutWordMask];

766  if

(scan_range[0] > scan_range[1])

769

index = backbone[init_index & kLutWordMask];

774  if

(scan_range[0] > scan_range[1])

777

init_index = init_index << 8 | s[2];

779

index = backbone[(init_index >> 6) & kLutWordMask];

805  const Int4

kLutWordLength = 6;

806  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

814

max_hits -=

lookup

->longest_chain;

820

init_index = s[0] << 8 | s[1];

824  while

(scan_range[0] <= scan_range[1]) {

826

init_index = s[0] << 8 | s[1];

827

index = backbone[init_index >> 4];

832  if

(scan_range[0] > scan_range[1])

836

index = backbone[init_index & kLutWordMask];

862  const Int4

kLutWordLength = 7;

863  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

871

max_hits -=

lookup

->longest_chain;

878

init_index = s[0] << 8 | s[1];

881

init_index = s[0] << 8 | s[1];

884

init_index = s[0] << 16 | s[1] << 8 | s[2];

888  while

(scan_range[0] <= scan_range[1]) {

890

init_index = s[0] << 8 | s[1];

891

index = backbone[init_index >> 2];

896  if

(scan_range[0] > scan_range[1])

899

index = backbone[init_index & kLutWordMask];

904  if

(scan_range[0] > scan_range[1])

907

init_index = init_index << 8 | s[2];

908

index = backbone[(init_index >> 6) & kLutWordMask];

913  if

(scan_range[0] > scan_range[1])

917

index = backbone[(init_index >> 4) & kLutWordMask];

943  const Int4

kLutWordLength = 7;

944  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

952

max_hits -=

lookup

->longest_chain;

958

init_index = s[0] << 8 | s[1];

962  while

(scan_range[0] <= scan_range[1]) {

964

init_index = s[0] << 8 | s[1];

965

index = backbone[init_index >> 2];

970  if

(scan_range[0] > scan_range[1])

973

init_index = init_index << 8 | s[2];

975

index = backbone[(init_index >> 6) & kLutWordMask];

1001  const Int4

kLutWordLength = 7;

1002  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

1004  Int4

total_hits = 0;

1010

max_hits -=

lookup

->longest_chain;

1017

init_index = s[0] << 8 | s[1];

1021

init_index = s[0] << 8 | s[1];

1025

init_index = s[0] << 8 | s[1];

1029  while

(scan_range[0] <= scan_range[1]) {

1031

init_index = s[0] << 8 | s[1];

1032

index = backbone[(init_index >> 2) & kLutWordMask];

1037  if

(scan_range[0] > scan_range[1])

1040

init_index = init_index << 8 | s[2];

1041

index = backbone[(init_index >> 4) & kLutWordMask];

1046  if

(scan_range[0] > scan_range[1])

1049

init_index = init_index << 8 | s[3];

1050

index = backbone[(init_index >> 6) & kLutWordMask];

1055  if

(scan_range[0] > scan_range[1])

1059

index = backbone[init_index & kLutWordMask];

1086  const Int4

kLutWordLength = 8;

1087  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

1091  Int4

total_hits = 0;

1096

max_hits -=

lookup

->longest_chain;

1102  case

1:

goto

base_1;

1103  case

2:

goto

base_2;

1104  case

3:

goto

base_3;

1107  while

(scan_range[0] <= scan_range[1]) {

1109

index = s[0] << 8 | s[1];

1110

s += scan_step_byte;

1111

index = backbone[index];

1113

scan_range[0] += scan_step;

1116  if

(scan_range[0] > scan_range[1])

1119

index = s[0] << 16 | s[1] << 8 | s[2];

1120

s += scan_step_byte;

1121

index = backbone[(index >> 6) & kLutWordMask];

1123

scan_range[0] += scan_step;

1126  if

(scan_range[0] > scan_range[1])

1129

index = s[0] << 16 | s[1] << 8 | s[2];

1130

s += scan_step_byte;

1131

index = backbone[(index >> 4) & kLutWordMask];

1133

scan_range[0] += scan_step;

1136  if

(scan_range[0] > scan_range[1])

1139

index = s[0] << 16 | s[1] << 8 | s[2];

1140

s += scan_step_byte + 1;

1141

index = backbone[(index >> 2) & kLutWordMask];

1143

scan_range[0] += scan_step;

1168  const Int4

kLutWordLength = 8;

1169  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

1173  Int4

total_hits = 0;

1178

max_hits -=

lookup

->longest_chain;

1186  while

(scan_range[0] <= scan_range[1]) {

1188

index = s[0] << 8 | s[1];

1189

s += scan_step_byte;

1190

index = backbone[index];

1192

scan_range[0] += scan_step;

1195  if

(scan_range[0] > scan_range[1])

1198

index = s[0] << 16 | s[1] << 8 | s[2];

1199

s += scan_step_byte + 1;

1200

index = backbone[(index >> 4) & kLutWordMask];

1202

scan_range[0] += scan_step;

1227  const Int4

kLutWordLength = 8;

1228  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

1232  Int4

total_hits = 0;

1237

max_hits -=

lookup

->longest_chain;

1253  while

(scan_range[0] <= scan_range[1]) {

1255

index = s[0] << 8 | s[1];

1256

s += scan_step_byte;

1257

index = backbone[index];

1259

scan_range[0] += scan_step;

1262  if

(scan_range[0] > scan_range[1])

1265

index = s[0] << 16 | s[1] << 8 | s[2];

1266

s += scan_step_byte;

1267

index = backbone[(index >> 2) & kLutWordMask];

1269

scan_range[0] += scan_step;

1272  if

(scan_range[0] > scan_range[1])

1275

index = s[1] << 16 | s[2] << 8 | s[3];

1276

s += scan_step_byte;

1277

index = backbone[(index >> 4) & kLutWordMask];

1279

scan_range[0] += scan_step;

1282  if

(scan_range[0] > scan_range[1])

1285

index = s[2] << 16 | s[3] << 8 | s[4];

1286

s += scan_step_byte + 3;

1287

index = backbone[(index >> 6) & kLutWordMask];

1289

scan_range[0] += scan_step;

1317  switch

(

lookup

->lut_word_length) {

1335  else if

(scan_step == 2)

1344  else if

(scan_step == 2)

1346  else if

(scan_step == 3)

1353  if

(scan_step == 4) {

1359  lookup

->scansub_callback =

1363  lookup

->scansub_callback =

1367  lookup

->scansub_callback =

1371  lookup

->scansub_callback =

1392  if

(

PV_TEST

(pv, index, pv_array_bts))

1417

q_off =

lookup

->next_pos[q_off];

1441

q_off =

lookup

->next_pos2[q_off];

1447 #define MB_ACCESS_HITS() \ 1448  if (s_BlastMBLookupHasHits(mb_lt, index)) { \ 1449  if (total_hits >= max_hits) \ 1451  total_hits += s_BlastMBLookupRetrieve(mb_lt, \ 1452  index, offset_pairs + total_hits, \ 1457 #define MB_ACCESS_HITS2() \ 1458  if (total_hits >= max_hits) \ 1460  if (s_BlastMBLookupHasHits(mb_lt, index)) { \ 1461  total_hits += s_BlastMBLookupRetrieve(mb_lt, \ 1462  index, offset_pairs + total_hits, \ 1465  if (s_BlastMBLookupHasHits(mb_lt, index2)) { \ 1466  total_hits += s_BlastMBLookupRetrieve2(mb_lt, \ 1467  index2, offset_pairs + total_hits, \ 1493  Int4

total_hits = 0;

1498  ASSERT

(lut_word_length == 9 ||

1499

lut_word_length == 10 ||

1500

lut_word_length == 11 ||

1501

lut_word_length == 12 ||

1502

lut_word_length == 16);

1519  Int4

shift = 2 * (12 - lut_word_length);

1523  for

( ; s <= s_end; s += scan_step) {

1525

index = s[0] << 16 | s[1] << 8 | s[2];

1526

index = index >> shift;

1529  if

(total_hits >= max_hits)

1534

offset_pairs + total_hits,

1540

}

else if

(lut_word_length == 16 && scan_step == 1) {

1546

w = (

Int8

)s[0] << 24 | (

Int8

)s[1] << 16 | (

Int8

)s[2] << 8 | s[3];

1548

w = (w << 8) | (

Int8

)s[4];

1551  for

(; scan_range[0] <= scan_range[1]; scan_range[0] += scan_step) {

1555

w = (w << 8) | (

Int8

)s[4];

1559

index = (w >> shift) &

mask

;

1566

}

else if

(lut_word_length == 16) {

1568  for

(; scan_range[0] <= scan_range[1]; scan_range[0] += scan_step) {

1573

(

Int8

)s[3] << 8 | s[4];

1575

index = (w >> shift) &

mask

;

1580

}

else if

(lut_word_length > 9) {

1581  ASSERT

(lut_word_length <= 12);

1598  for

(; scan_range[0] <= scan_range[1]; scan_range[0] += scan_step) {

1603

index = s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3];

1604

index = (index >> shift) &

mask

;

1614  for

(; scan_range[0] <= scan_range[1]; scan_range[0] += scan_step) {

1619

index = s[0] << 16 | s[1] << 8 | s[2];

1620

index = (index >> shift) &

mask

;

1645  const Int4

kLutWordLength = 9;

1646  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

1649  Int4

total_hits = 0;

1659

init_index = s[0] << 16 | s[1] << 8 | s[2];

1662

init_index = s[0] << 16 | s[1] << 8 | s[2];

1665

init_index = s[0] << 16 | s[1] << 8 | s[2];

1669  while

(scan_range[0] <= scan_range[1]) {

1671

init_index = s[0] << 16 | s[1] << 8 | s[2];

1672

index = init_index >> 6;

1677  if

(scan_range[0] > scan_range[1])

1680

index = (init_index >> 4) & kLutWordMask;

1685  if

(scan_range[0] > scan_range[1])

1688

index = (init_index >> 2) & kLutWordMask;

1693  if

(scan_range[0] > scan_range[1])

1696

index = init_index & kLutWordMask;

1721  const Int4

kLutWordLength = 9;

1722  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

1725  Int4

total_hits = 0;

1734

init_index = s[0] << 16 | s[1] << 8 | s[2];

1738  while

(scan_range[0] <= scan_range[1]) {

1740

init_index = s[0] << 16 | s[1] << 8 | s[2];

1741

index = init_index >> 6;

1746  if

(scan_range[0] > scan_range[1])

1749

index = (init_index >> 2) & kLutWordMask;

1774  const Int4

kLutWordLength = 10;

1775  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

1778  Int4

total_hits = 0;

1788

init_index = s[0] << 16 | s[1] << 8 | s[2];

1791

init_index = s[0] << 16 | s[1] << 8 | s[2];

1794

init_index = s[0] << 16 | s[1] << 8 | s[2];

1798  while

(scan_range[0] <= scan_range[1]) {

1800

init_index = s[0] << 16 | s[1] << 8 | s[2];

1801

index = init_index >> 4;

1806  if

(scan_range[0] > scan_range[1])

1809

index = (init_index >> 2) & kLutWordMask;

1814  if

(scan_range[0] > scan_range[1])

1817

index = init_index & kLutWordMask;

1822  if

(scan_range[0] > scan_range[1])

1825

init_index = init_index << 8 | s[3];

1826

index = (init_index >> 6) & kLutWordMask;

1851  const Int4

kLutWordLength = 10;

1852  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

1855  Int4

total_hits = 0;

1864

init_index = s[0] << 16 | s[1] << 8 | s[2];

1868  while

(scan_range[0] <= scan_range[1]) {

1870

init_index = s[0] << 16 | s[1] << 8 | s[2];

1871

index = init_index >> 4;

1876  if

(scan_range[0] > scan_range[1])

1879

index = init_index & kLutWordMask;

1904  const Int4

kLutWordLength = 10;

1905  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

1908  Int4

total_hits = 0;

1918

init_index = s[0] << 8 | s[1];

1922

init_index = s[0] << 16 | s[1] << 8 | s[2];

1926

init_index = s[0] << 16 | s[1] << 8 | s[2];

1930  while

(scan_range[0] <= scan_range[1]) {

1932

init_index = s[0] << 16 | s[1] << 8 | s[2];

1933

index = init_index >> 4;

1938  if

(scan_range[0] > scan_range[1])

1941

init_index = init_index << 8 | s[3];

1942

index = (init_index >> 6) & kLutWordMask;

1947  if

(scan_range[0] > scan_range[1])

1950

index = init_index & kLutWordMask;

1955  if

(scan_range[0] > scan_range[1])

1958

init_index = init_index << 8 | s[4];

1959

index = (init_index >> 2) & kLutWordMask;

1984  const Int4

kLutWordLength = 11;

1985  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

1987  Int4

total_hits = 0;

1998  case

1:

goto

base_1;

1999  case

2:

goto

base_2;

2000  case

3:

goto

base_3;

2003  while

(scan_range[0] <= scan_range[1]) {

2005

index = s[0] << 16 | s[1] << 8 | s[2];

2007

s += scan_step_byte;

2009

scan_range[0] += scan_step;

2012  if

(scan_range[0] > scan_range[1])

2015

index = s[0] << 16 | s[1] << 8 | s[2];

2016

index = index & kLutWordMask;

2017

s += scan_step_byte;

2019

scan_range[0] += scan_step;

2022  if

(scan_range[0] > scan_range[1])

2025

index = s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3];

2026

index = (index >> 6) & kLutWordMask;

2027

s += scan_step_byte;

2029

scan_range[0] += scan_step;

2032  if

(scan_range[0] > scan_range[1])

2035

index = s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3];

2036

index = (index >> 4) & kLutWordMask;

2037

s += scan_step_byte + 1;

2039

scan_range[0] += scan_step;

2061  const Int4

kLutWordLength = 11;

2062  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

2064  Int4

total_hits = 0;

2068  Int4

top_shift, bottom_shift;

2075  if

( (scan_range[0] % 2) == 0)

2089  while

(scan_range[0] <= scan_range[1]) {

2090

index = s[0] << 16 | s[1] << 8 | s[2];

2091

index = (index >> top_shift) & kLutWordMask;

2092

s += scan_step_byte;

2094

scan_range[0] += scan_step;

2097  if

(scan_range[0] > scan_range[1])

2100

index = s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3];

2101

index = (index >> bottom_shift) & kLutWordMask;

2102

s += scan_step_byte + 1;

2104

scan_range[0] += scan_step;

2126  const Int4

kLutWordLength = 11;

2127  const Int4

kLutWordMask = (1 << (2 * kLutWordLength)) - 1;

2129  Int4

total_hits = 0;

2150  while

(scan_range[0] <= scan_range[1]) {

2152

index = s[0] << 16 | s[1] << 8 | s[2];

2154

s += scan_step_byte;

2156

scan_range[0] += scan_step;

2159  if

(scan_range[0] > scan_range[1])

2162

index = s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3];

2163

index = (index >> 4) & kLutWordMask;

2164

s += scan_step_byte;

2166

scan_range[0] += scan_step;

2169  if

(scan_range[0] > scan_range[1])

2172

index = s[1] << 24 | s[2] << 16 | s[3] << 8 | s[4];

2173

index = (index >> 6) & kLutWordMask;

2174

s += scan_step_byte;

2176

scan_range[0] += scan_step;

2179  if

(scan_range[0] > scan_range[1])

2182

index = s[2] << 16 | s[3] << 8 | s[4];

2183

index = index & kLutWordMask;

2184

s += scan_step_byte + 3;

2186

scan_range[0] += scan_step;

2209  Int4

total_hits = 0;

2220  while

(index < scan_range[0] + template_length) {

2221

accum = accum << 8 | *s++;

2228  switch

(index - (scan_range[0] + template_length)) {

2242  while

(scan_range[0] <= scan_range[1]) {

2249  if

(scan_range[0] > scan_range[1])

2252

accum = accum << 8 | *s++;

2258  if

(scan_range[0] > scan_range[1])

2266  if

(scan_range[0] > scan_range[1])

2297  Int4

total_hits = 0;

2309  while

(index < scan_range[0] + template_length) {

2310

accum = accum << 8 | *s++;

2317  switch

(index - (scan_range[0] + template_length)) {

2331  while

(scan_range[0] <= scan_range[1]) {

2339  if

(scan_range[0] > scan_range[1])

2342

accum = accum << 8 | *s++;

2349  if

(scan_range[0] > scan_range[1])

2358  if

(scan_range[0] > scan_range[1])

2389  Int4

total_hits = 0;

2391  const Int4

kTemplateLength = 18;

2403  while

(index < scan_range[0] + kTemplateLength) {

2404

hi = (hi << 8) | (lo >> 24);

2405

lo = lo << 8 | *s++;

2409  switch

(index - (scan_range[0] + kTemplateLength)) {

2416

lo = (lo >> 8) | (hi << 24);

2421  while

(scan_range[0] <= scan_range[1]) {

2423

index = ((lo & 0x00000003) ) |

2424

((lo & 0x000000f0) >> 2) |

2425

((lo & 0x00003c00) >> 4) |

2426

((lo & 0x00030000) >> 6) |

2427

((lo & 0x03c00000) >> 10) |

2428

((lo & 0xf0000000) >> 12) |

2429

((hi & 0x0000000c) << 18);

2434  if

(scan_range[0] > scan_range[1])

2437

hi = (hi << 8) | (lo >> 24);

2438

lo = lo << 8 | *s++;

2440

index = ((lo & 0x000000c0) >> 6) |

2441

((lo & 0x00003c00) >> 8) |

2442

((lo & 0x000f0000) >> 10) |

2443

((lo & 0x00c00000) >> 12) |

2444

((lo & 0xf0000000) >> 16) |

2445

((hi & 0x0000003c) << 14) |

2446

((hi & 0x00000300) << 12);

2451  if

(scan_range[0] > scan_range[1])

2454

index = ((lo & 0x00000030) >> 4) |

2455

((lo & 0x00000f00) >> 6) |

2456

((lo & 0x0003c000) >> 8) |

2457

((lo & 0x00300000) >> 10) |

2458

((lo & 0x3c000000) >> 14) |

2459

((hi & 0x0000000f) << 16) |

2460

((hi & 0x000000c0) << 14);

2465  if

(scan_range[0] > scan_range[1])

2468

index = ((lo & 0x0000000c) >> 2) |

2469

((lo & 0x000003c0) >> 4) |

2470

((lo & 0x0000f000) >> 6) |

2471

((lo & 0x000c0000) >> 8) |

2472

((lo & 0x0f000000) >> 12) |

2473

((lo & 0xc0000000) >> 14) |

2474

((hi & 0x00000003) << 18) |

2475

((hi & 0x00000030) << 16);

2502  Int4

total_hits = 0;

2504  const Int4

kTemplateLength = 21;

2515  while

(index < scan_range[0] + kTemplateLength) {

2516

hi = (hi << 8) | (lo >> 24);

2517

lo = lo << 8 | *s++;

2521  switch

(index - (scan_range[0] + kTemplateLength)) {

2528

lo = (lo >> 8) | (hi << 24);

2533  while

(scan_range[0] <= scan_range[1]) {

2535

index = ((lo & 0x00000003) ) |

2536

((lo & 0x000000f0) >> 2) |

2537

((lo & 0x00000c00) >> 4) |

2538

((lo & 0x000f0000) >> 8) |

2539

((lo & 0x00c00000) >> 10) |

2540

((lo & 0xf0000000) >> 14) |

2541

((hi & 0x0000000c) << 16) |

2542

((hi & 0x00000300) << 12);

2547  if

(scan_range[0] > scan_range[1])

2550

hi = (hi << 8) | (lo >> 24);

2551

lo = lo << 8 | *s++;

2553

index = ((lo & 0x000000c0) >> 6) |

2554

((lo & 0x00003c00) >> 8) |

2555

((lo & 0x00030000) >> 10) |

2556

((lo & 0x03c00000) >> 14) |

2557

((lo & 0x30000000) >> 16) |

2558

((hi & 0x0000003c) << 12) |

2559

((hi & 0x00000300) << 10) |

2560

((hi & 0x0000c000) << 6);

2565  if

(scan_range[0] > scan_range[1])

2568

index = ((lo & 0x00000030) >> 4) |

2569

((lo & 0x00000f00) >> 6) |

2570

((lo & 0x0000c000) >> 8) |

2571

((lo & 0x00f00000) >> 12) |

2572

((lo & 0x0c000000) >> 14) |

2573

((hi & 0x0000000f) << 14) |

2574

((hi & 0x000000c0) << 12) |

2575

((hi & 0x00003000) << 8);

2580  if

(scan_range[0] > scan_range[1])

2583

index = ((lo & 0x0000000c) >> 2) |

2584

((lo & 0x000003c0) >> 4) |

2585

((lo & 0x00003000) >> 6) |

2586

((lo & 0x003c0000) >> 10) |

2587

((lo & 0x03000000) >> 12) |

2588

((lo & 0xc0000000) >> 16) |

2589

((hi & 0x00000003) << 16) |

2590

((hi & 0x00000030) << 14) |

2591

((hi & 0x00000c00) << 10);

2644  else if

(scan_step == 2)

2646  else if

(scan_step == 3)

2701  const Int4

pv_array_bts =

lookup

->pv_array_bts;

2717  if

(

lookup

->thick_backbone[hashed_index].num_words > 0) {

2719  lookup

->thick_backbone + hashed_index;

2725

((

lookup

->thick_backbone[hashed_index].num_words < 5) ?

2726  lookup

->thick_backbone[hashed_index].num_words - 1 :

2747  for

(j = 0;j <

i

;j++) {

2753

offset_pairs[num_hits].qs_offsets.q_off

2756

offset_pairs[num_hits].qs_offsets.s_off

2759  ASSERT

(offset_pairs[num_hits].qs_offsets.q_off

2795  for

(k = 0; k < cell->

num_words

; k++) {

2797  Int4

num_offsets = overflow[1];

2800  if

(word != index) {

2801

overflow += num_offsets + 2;

2810  for

(

i

= 0;

i

< num_offsets;

i

++) {

2811

offset_pairs[num_hits +

i

].qs_offsets.q_off =

2814

offset_pairs[num_hits +

i

].qs_offsets.s_off =

2817  ASSERT

(offset_pairs[num_hits +

i

].

2862  Int4

total_hits = 0;

2863  Int4

lut_word_length =

lookup

->lut_word_length;

2872  ASSERT

(lut_word_length == 16);

2876

max_hits -=

lookup

->longest_chain;

2878  if

(lut_word_length == 16 && scan_step == 1) {

2886

w = (

Int8

)s[0] << 24 | (

Int8

)s[1] << 16 | (

Int8

)s[2] << 8 | s[3];

2888

w = (w << 8) | (

Int8

)s[4];

2891  for

(; scan_range[0] <= scan_range[1]; scan_range[0] += scan_step) {

2895

w = (w << 8) | (

Int8

)s[4];

2899

index = (

Uint4

)((w >> shift) &

mask

);

2904  if

(total_hits >= max_hits)

2909

scan_range[0], offset_pairs + total_hits,

2913  else if

(lut_word_length == 16) {

2919  for

(; scan_range[0] <= scan_range[1]; scan_range[0] += scan_step) {

2922

w = (

Int8

)s[0] << 24 | (

Int8

)s[1] << 16 | (

Int8

)s[2] << 8 | s[3];

2924

w = (w << 8) | (

Int8

)s[4];

2926

index = (

Uint4

)((w >> shift) &

mask

);

2932  if

(total_hits >= max_hits)

2936

scan_range[0], offset_pairs + total_hits,

2948

printf(

"Num words not in PV:\t%d\n"

, diags.

not_pv

);

2949

printf(

"Num words not in backbone\t%d\n"

, diags.

not_backbone

);

2950

printf(

"Num hash value hits in backbone:\t%d\n"

, diags.

hits

);

2951

printf(

"\tNum query words with the same hash value\tCount\n"

);

2954  for

(ii = 0;ii < 5;ii++) {

2955

printf(

"\t%d\t%d\n"

, ii + 1, diags.

h_num_words

[ii]);

2958

printf(

"Num backbone misses:\t%d\n"

, diags.

missed

);

2959

printf(

"Num word hits:\t%d\n"

, diags.

present

);

2960

printf(

"Total hits:\t%d\n"

, total_hits);

#define COMPRESSION_RATIO

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

#define PV_ARRAY_BTS

bits-to-shift from lookup_index to pv_array index.

#define PV_TEST(lookup, index, shift)

Test the bit at position 'index' in the PV array bitfield within 'lookup'.

Uint4(* TNaLookupHashFunction)(Uint1 *, Uint4)

Hash function type for the lookup table.

#define PV_ARRAY_TYPE

The pv_array 'native' type.

Routines for creating nucleotide BLAST lookup tables.

#define NA_OFFSETS_PER_HASH

#define NA_WORDS_PER_HASH

static NCBI_INLINE Int4 ComputeDiscontiguousIndex(Uint8 accum, EDiscTemplateType template_type)

Given an accumulator containing packed bases, compute the discontiguous word index specified by templ...

EDiscTemplateType

Enumeration of all discontiguous word templates; the enumerated values encode the weight,...

@ eDiscTemplate_11_21_Coding

@ eDiscTemplate_11_18_Coding

#define NA_HITS_PER_CELL

maximum number of hits in one lookup table cell

static Int4 s_MBScanSubject_10_2(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 10-letter word hits with stride 2.

static Int4 s_BlastNaHashLookupRetieveHits(BlastNaHashLookupTable *lookup, Uint4 index, Int4 s_off, BlastOffsetPair *offset_pairs, SNaHashLookupScanDiags *diags)

static Int4 s_BlastSmallNaScanSubject_4_1(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 4-letter word hits with stride 1.

static Int4 s_BlastSmallNaScanSubject_7_1(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 7-letter word hits with stride 1.

static Int4 s_MB_DiscWordScanSubject_11_18_1(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning discontiguous words corresponding to the 11-of-18 cod...

static Int4 s_MBScanSubject_10_3(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 10-letter word hits with stride 3.

static Int4 s_BlastSmallNaScanSubject_7_3(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 7-letter word hits with stride 3.

struct SNaHashLookupScanDiags SNaHashLookupScanDiags

Diagnostics for scanning with NaHashLookupTable.

static Int4 s_BlastSmallNaScanSubject_5_1(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 5-letter word hits with stride 1.

static Int4 s_MB_DiscWordScanSubject_TwoTemplates_1(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 11- or 12-letter discontiguous words with stride 1 an...

static Int4 s_MBScanSubject_11_1Mod4(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 11-letter word hits with stride one plus a multiple o...

static Int4 s_BlastSmallNaScanSubject_Any(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 4-to-8-letter word hits with arbitrary stride.

static Int4 s_BlastSmallNaScanSubject_8_4(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 8-letter word hits with stride 4.

static Int4 s_BlastNaHashScanSubject_Any(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 9-to-12 letter word hits with arbitrary stride.

static Int4 s_BlastSmallNaScanSubject_8_3Mod4(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 8-letter word hits with stride of three plus a multip...

static Int4 s_BlastNaScanSubject_Any(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 4-to-8 letter word hits at arbitrary stride.

static Int4 s_MB_DiscWordScanSubject_11_21_1(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning discontiguous words corresponding to the 11-of-21 cod...

static NCBI_INLINE Int4 s_BlastMBLookupRetrieve2(BlastMBLookupTable *lookup, Int8 index, BlastOffsetPair *offset_pairs, Int4 s_off)

Like s_BlastMBLookupRetrieve, except the second hashtable is accessed.

static void s_SmallNaChooseScanSubject(LookupTableWrap *lookup_wrap)

Choose the most appropriate function to scan through subject sequences, assuming a small-query blastn...

static NCBI_INLINE Int4 s_BlastSmallNaRetrieveHits(BlastOffsetPair *offset_pairs, Int4 index, Int4 s_off, Int4 total_hits, Int2 *overflow)

Copy query offsets from a BlastSmallNaLookupTable.

static Int4 s_MBScanSubject_Any(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 9-to-12 letter word hits with arbitrary stride.

static NCBI_INLINE Int4 s_BlastLookupGetNumHits(BlastNaLookupTable *lookup, Int4 index)

Retrieve the number of query offsets associated with this subject word.

void * BlastChooseNucleotideScanSubjectAny(LookupTableWrap *lookup_wrap)

Return the most generic function to scan through nucleotide subject sequences.

static void s_NaHashChooseScanSubject(LookupTableWrap *lookup_wrap)

Choose the most appropriate function to scan through subject sequences, assuming a standard blastn lo...

#define SMALL_NA_ACCESS_HITS(x)

access the small-query lookup table

static void s_MBChooseScanSubject(LookupTableWrap *lookup_wrap)

Choose the most appropriate function to scan through subject sequences, assuming a megablast lookup t...

static Int4 s_BlastNaScanSubject_8_4(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 8-letter word hits with stride 4.

static NCBI_INLINE Int4 s_BlastMBLookupHasHits(BlastMBLookupTable *lookup, Int8 index)

Determine if this subject word occurs in the query.

static Int4 s_MBScanSubject_11_3Mod4(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 11-letter word hits with stride three plus a multiple...

static void s_NaChooseScanSubject(LookupTableWrap *lookup_wrap)

Choose the most appropriate function to scan through subject sequences, assuming a standard blastn lo...

#define MB_ACCESS_HITS()

access the megablast lookup table

#define MB_ACCESS_HITS2()

access the megablast lookup table with two templates

static Int4 s_MBScanSubject_9_2(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 9-letter word hits with stride 2.

static Int4 s_MB_DiscWordScanSubject_1(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 11- or 12-letter discontiguous words with stride 1.

static Int4 s_MBScanSubject_9_1(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 9-letter word hits with stride 1.

static Int4 s_MBScanSubject_10_1(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 10-letter word hits with stride 1.

static Int4 s_BlastSmallNaScanSubject_6_1(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 6-letter word hits with stride 1.

static NCBI_INLINE Int4 s_BlastMBLookupRetrieve(BlastMBLookupTable *lookup, Int8 index, BlastOffsetPair *offset_pairs, Int4 s_off)

Copy query offsets from the lookup table to the array of offset pairs.

static Int4 s_MBScanSubject_11_2Mod4(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 11-letter word hits with stride two plus a multiple o...

static Int4 s_BlastSmallNaScanSubject_8_2Mod4(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 8-letter word hits with stride of two plus a multiple...

static NCBI_INLINE void s_BlastLookupRetrieve(BlastNaLookupTable *lookup, Int4 index, BlastOffsetPair *offset_pairs, Int4 s_off)

Copy query offsets from the lookup table to the array of offset pairs.

static Int4 s_BlastSmallNaScanSubject_8_1Mod4(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 8-letter word hits with stride of one plus a multiple...

static Int4 s_BlastSmallNaScanSubject_7_2(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 7-letter word hits with stride 2.

void BlastChooseNucleotideScanSubject(LookupTableWrap *lookup_wrap)

Choose the most appropriate function to scan through nucleotide subject sequences.

static Int4 s_BlastSmallNaScanSubject_6_2(const LookupTableWrap *lookup_wrap, const BLAST_SequenceBlk *subject, BlastOffsetPair *offset_pairs, Int4 max_hits, Int4 *scan_range)

Scan the compressed subject sequence, returning 6-letter word hits with stride 2.

Routines for scanning nucleotide BLAST lookup tables.

@ eSmallNaLookupTable

lookup table for blastn with small query

@ eNaLookupTable

blastn lookup table

@ eMBLookupTable

megablast lookup table (includes both contiguous and discontiguous megablast)

@ eNaHashLookupTable

used for 16-base words

Various auxiliary BLAST utility functions.

ncbi::TMaskedQueryRegions mask

static int lookup(const char *name, const struct lookup_int *table)

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

int64_t Int8

8-byte (64-bit) signed integer

uint64_t Uint8

8-byte (64-bit) unsigned integer

if(yy_accept[yy_current_state])

#define INT4_MAX

largest nubmer represented by signed int

#define NCBI_INLINE

"inline" seems to work on our remaining in-house compilers (WorkShop, Compaq, ICC,...

#define ASSERT

macro for assert.

Structure to hold a sequence.

The lookup table structure used for Mega BLAST.

Int4 lut_word_length

number of letters in a lookup table word

void * scansub_callback

function for scanning subject sequences

Int8 hashsize

= 4^(lut_word_length)

EDiscTemplateType template_type

Type of the discontiguous word template.

Int4 scan_step

Step size for scanning the database.

Int4 longest_chain

Largest number of query positions for a given word.

Boolean discontiguous

Are discontiguous words used?

Boolean two_templates

Use two templates simultaneously.

EDiscTemplateType second_template_type

Type of the second discontiguous word template.

Int4 template_length

Length of the discontiguous word template.

The basic lookup table structure for blastn searches.

Lookup table structure for blastn searches with small queries.

Wrapper structure for different types of BLAST lookup tables.

void * lut

Pointer to the actual lookup table structure.

ELookupTableType lut_type

What kind of a lookup table it is?

Structure defining one cell of the compacted lookup table.

Int1 num_offsets[3]

number of offsets for each word if there are fewer than 3

Uint4 words[3]

words stored under this hash value

Int4 offsets[9]

offset locations for each word

Int1 num_words

number of words stored under the same hash value

Diagnostics for scanning with NaHashLookupTable.

This symbol enables the verbose option in makeblastdb and other BLAST+ search command line applicatio...

Uint4 q_off

Query offset.

Uint4 s_off

Subject offset.

struct BlastOffsetPair::@6 qs_offsets

Query/subject offset pair.

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