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

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

{(double)

, (

)

, (double)

, 0.2291, 0.0924, 0.2514, 0.9113, -5.7, 0.641318, 9.611060, 9.611060},

{13, 3, (double)

, 0.207, 0.049, 0.14, 1.5, -22, 0.671128, 35.855900, 35.963900},

{12, 3, (double)

, 0.199, 0.039, 0.11, 1.8, -34, 0.691530, 45.693600, 45.851700},

{11, 3, (double)

, 0.190, 0.031, 0.095, 2.0, -38, 0.691181, 62.874100, 63.103700},

{10, 3, (double)

, 0.179, 0.023, 0.075, 2.4, -51, 0.710529, 88.286800, 88.639100},

{16, 2, (double)

, 0.210, 0.051, 0.14, 1.5, -24, 0.666680, 36.279800, 36.452400},

{15, 2, (double)

, 0.203, 0.041, 0.12, 1.7, -31, 0.673871, 44.825700, 45.060400},

{14, 2, (double)

, 0.195, 0.032, 0.10, 1.9, -36, 0.685753, 60.736200, 61.102300},

{13, 2, (double)

, 0.185, 0.024, 0.084, 2.2, -45, 0.698480, 85.148100, 85.689400},

{12, 2, (double)

, 0.171, 0.016, 0.061, 2.8, -65, 0.713429, 127.758000, 128.582000},

{19, 1, (double)

, 0.205, 0.040, 0.11, 1.9, -43, 0.672302, 53.071400, 53.828200},

{18, 1, (double)

, 0.198, 0.032, 0.10, 2.0, -43, 0.682580, 72.342400, 73.403900},

{17, 1, (double)

, 0.189, 0.024, 0.079, 2.4, -57, 0.695035, 103.055000, 104.721000},

{16, 1, (double)

, 0.176, 0.016, 0.063, 2.8, -67, 0.712966, 170.100000, 173.003000},

{(double)

, (

)

, (double)

, 0.2318, 0.112, 0.3362, 0.6895, -4.0, 0.609639, 5.388310, 5.388310},

{13, 3, (double)

, 0.212, 0.063, 0.19, 1.1, -16, 0.639287, 18.113800, 18.202800},

{12, 3, (double)

, 0.206, 0.055, 0.17, 1.2, -18, 0.644715, 22.654600, 22.777700},

{11, 3, (double)

, 0.197, 0.042, 0.14, 1.4, -25, 0.656327, 29.861100, 30.045700},

{10, 3, (double)

, 0.186, 0.031, 0.11, 1.7, -34, 0.671150, 42.393800, 42.674000},

{9, 3, (double)

, 0.172, 0.022, 0.082, 2.1, -48, 0.694326, 66.069600, 66.516400},

{16, 2, (double)

, 0.215, 0.066, 0.20, 1.05, -15, 0.633899, 17.951800, 18.092100},

{15, 2, (double)

, 0.210, 0.058, 0.17, 1.2, -20, 0.641985, 21.940100, 22.141800},

{14, 2, (double)

, 0.202, 0.045, 0.14, 1.4, -27, 0.650682, 28.681200, 28.961900},

{13, 2, (double)

, 0.193, 0.035, 0.12, 1.6, -32, 0.660984, 42.059500, 42.471600},

{12, 2, (double)

, 0.181, 0.025, 0.095, 1.9, -41, 0.678090, 63.747600, 64.397300},

{19, 1, (double)

, 0.212, 0.057, 0.18, 1.2, -21, 0.635714, 26.311200, 26.923300},

{18, 1, (double)

, 0.207, 0.050, 0.15, 1.4, -28, 0.643523, 34.903700, 35.734800},

{17, 1, (double)

, 0.198, 0.037, 0.12, 1.6, -33, 0.654504, 48.895800, 50.148600},

{16, 1, (double)

, 0.186, 0.025, 0.10, 1.9, -42, 0.667750, 76.469100, 78.443000},

{15, 1, (double)

, 0.171, 0.015, 0.063, 2.7, -76, 0.694575, 140.053000, 144.160000},

{(double)

, (

)

, (double)

, 0.3176, 0.134, 0.4012, 0.7916, -3.2, 0.623757, 4.964660, 4.964660},

{11, 2, (double)

, 0.297, 0.082, 0.27, 1.1, -10, 0.641766, 12.673800, 12.757600},

{10, 2, (double)

, 0.291, 0.075, 0.23, 1.3, -15, 0.649362, 16.474000, 16.602600},

{9, 2, (double)

, 0.279, 0.058, 0.19, 1.5, -19, 0.659245, 22.751900, 22.950000},

{8, 2, (double)

, 0.264, 0.045, 0.15, 1.8, -26, 0.672692, 35.483800, 35.821300},

{7, 2, (double)

, 0.239, 0.027, 0.10, 2.5, -46, 0.702056, 61.238300, 61.886000},

{6, 2, (double)

, 0.201, 0.012, 0.061, 3.3, -58, 0.740802, 140.417000, 141.882000},

{13, 1, (double)

, 0.292, 0.071, 0.23, 1.2, -11, 0.647715, 19.506300, 19.893100},

{12, 1, (double)

, 0.283, 0.059, 0.19, 1.5, -19, 0.656391, 27.856200, 28.469900},

{11, 1, (double)

, 0.267, 0.041, 0.14, 1.9, -30, 0.669720, 42.602800, 43.636200},

{10, 1, (double)

, 0.243, 0.024, 0.10, 2.5, -44, 0.693267, 83.178700, 85.065600},

{9, 1, (double)

, 0.206, 0.010, 0.052, 4.0, -87, 0.731887, 210.333000, 214.842000},

{(double)

, (

)

, (double)

, 0.3430, 0.177, 0.6568, 0.5222, -1.6, 0.564057, 1.918130, 1.918130},

{25, 2, (double)

, 0.342, 0.17, 0.66, 0.52, -1.6, 0.563956, 1.731000, 1.731300},

{13, 2, (double)

, 0.336, 0.15, 0.57, 0.59, -3, 0.570979, 2.673470, 2.692300},

{9, 2, (double)

, 0.319, 0.11, 0.42, 0.76, -6, 0.587837, 5.576090, 5.667860},

{8, 2, (double)

, 0.308, 0.090, 0.35, 0.89, -9, 0.597556, 7.536950, 7.686230},

{7, 2, (double)

, 0.293, 0.070, 0.27, 1.1, -14, 0.615254, 11.586600, 11.840400},

{6, 2, (double)

, 0.268, 0.045, 0.19, 1.4, -19, 0.644054, 19.958100, 20.441200},

{11, 1, (double)

, 0.314, 0.095, 0.35, 0.90, -9, 0.590702, 8.808610, 9.223320},

{10, 1, (double)

, 0.299, 0.071, 0.27, 1.1, -14, 0.609620, 13.833800, 14.533400},

{9, 1, (double)

, 0.279, 0.048, 0.20, 1.4, -19, 0.623800, 24.252000, 25.490400},

{(double)

, (

)

, (double)

, 0.3346, 0.190, 0.7547, 0.4434, -1.4 , 0.544178, 1.377760, 1.377760},

{9, 2, (double)

, 0.310, 0.12, 0.46, 0.67, -6 , 0.570267, 4.232290, 4.334170},

{8, 2, (double)

, 0.300, 0.099, 0.39, 0.76, -7, 0.581580, 5.797020, 5.961420},

{7, 2, (double)

, 0.283, 0.072, 0.30, 0.93, -11, 0.600024, 9.040880, 9.321600},

{6, 2, (double)

, 0.259, 0.048, 0.22, 1.2, -16, 0.629344, 16.024400, 16.531600},

{11, 1, (double)

, 0.302, 0.093, 0.39, 0.78, -8, 0.576919, 7.143250, 7.619190},

{10, 1, (double)

, 0.290, 0.075, 0.28, 1.04, -15, 0.591366, 11.483900, 12.269800},

{9, 1, (double)

, 0.265, 0.044, 0.20, 1.3, -19, 0.613013, 21.408300, 22.840900},

{(double)

, (

)

, (double)

, 0.2252, 0.0868, 0.2223, 0.98, -5.0, 0.660059, 11.754300, 11.754300},

{15, 3, (double)

, 0.205, 0.049, 0.13, 1.6, -23, 0.687656, 34.578400, 34.928000},

{14, 3, (double)

, 0.200, 0.043, 0.12, 1.7, -26, 0.689768, 43.353000, 43.443800},

{13, 3, (double)

, 0.194, 0.036, 0.10, 1.9, -31, 0.697431, 50.948500, 51.081700},

{12, 3, (double)

, 0.186, 0.029, 0.085, 2.2, -41, 0.704565, 69.606500, 69.793600},

{11, 3, (double)

, 0.174, 0.020, 0.070, 2.5, -48, 0.722438, 98.653500, 98.927100},

{17, 2, (double)

, 0.204, 0.047, 0.12, 1.7, -28, 0.684799, 41.583800, 41.735800},

{16, 2, (double)

, 0.198, 0.038, 0.11, 1.8, -29, 0.691098, 51.635200, 51.843900},

{15, 2, (double)

, 0.191, 0.031, 0.087, 2.2, -44, 0.699051, 67.256700, 67.558500},

{14, 2, (double)

, 0.182, 0.024, 0.073, 2.5, -53, 0.714103, 96.315100, 96.756800},

{13, 2, (double)

, 0.171, 0.017, 0.059, 2.9, -64, 0.728738, 135.653000, 136.339000},

{21, 1, (double)

, 0.205, 0.045, 0.11, 1.8, -34, 0.683265, 48.728200, 49.218800},

{20, 1, (double)

, 0.199, 0.037, 0.10, 1.9, -35, 0.689380, 60.832000, 61.514100},

{19, 1, (double)

, 0.192, 0.029, 0.083, 2.3, -52, 0.696344, 84.019700, 84.985600},

{18, 1, (double)

, 0.183, 0.021, 0.070, 2.6, -60, 0.710525, 113.829000, 115.184000},

{17, 1, (double)

, 0.171, 0.014, 0.052, 3.3, -86, 0.727000, 175.071000, 177.196000},

{(double)

, (

)

, (double)

, 0.3400, 0.283, 1.754, 0.1938, -0.3, 0.436164, 0.161818, 0.161818},

{7, 2, (double)

, 0.305, 0.15, 0.87, 0.35, -3, 0.479087, 1.014010, 1.162730},

{6, 2, (double)

, 0.287, 0.11, 0.68, 0.42, -4, 0.499980, 1.688060, 1.951430},

{5, 2, (double)

, 0.264, 0.079, 0.45, 0.59, -7, 0.533009, 3.377010, 3.871950},

{10, 1, (double)

, 0.309, 0.15, 0.88, 0.35, -3, 0.474741, 1.372050, 1.788770},

{9, 1, (double)

, 0.294, 0.11, 0.61, 0.48, -6, 0.492716, 2.463920, 3.186150},

{8, 1, (double)

, 0.270, 0.072, 0.40, 0.68, -10, 0.521286, 5.368130, 6.763480},

{15, 3, (double)

, 0.339, 0.28, 1.70, 0.20, -0.5, 0.437688, 0.157089, 0.155299},

{14, 2, (double)

, 0.337, 0.27, 1.62, 0.21, -0.8, 0.440010, 0.206970, 0.198524},

{14, 1, (double)

, 0.333, 0.27, 1.43, 0.23, -1.4, 0.444817, 0.436301, 0.361947},

{13, 3, (double)

, 0.338, 0.27, 1.69, 0.20, -0.5, 0.439086, 0.178973, 0.175436},

{(double)

, (

)

, (double)

, 0.3345, 0.229, 1.029, 0.3250, -0.7, 0.511296, 0.633439, 0.633439},

{8, 2, (double)

, 0.301, 0.12, 0.54, 0.56, -5, 0.549019, 2.881650, 3.025710},

{7, 2, (double)

, 0.286, 0.093, 0.43, 0.67, -7, 0.565659, 4.534540, 4.785780},

{6, 2, (double)

, 0.264, 0.064, 0.29, 0.90, -12, 0.596330, 7.942630, 8.402720},

{11, 1, (double)

, 0.305, 0.12, 0.52, 0.59, -6, 0.543514, 3.681400, 4.108020},

{10, 1, (double)

, 0.291, 0.091, 0.41, 0.71, -9, 0.560723, 6.002970, 6.716570},

{9, 1, (double)

, 0.270, 0.060, 0.28, 0.97, -14, 0.585186, 11.360800, 12.636700},

{11, 2, (double)

, 0.323, 0.186, 0.80, 1.32, -27, 0.524062, 1.321301, 1.281671},

{12, 3, (double)

, 0.330, 0.219, 0.93, 0.82, -16, 0.516845, 0.818768, 0.811240},

blosum62_20_values[BLOSUM62_20_VALUES_MAX] = {

{(double)

, (

)

, (double)

, 0.03391, 0.125, 0.4544, 0.07462, -3.2,0.0,0.0,0.0},

{100, 12, (double)

, 0.0300, 0.056, 0.21, 0.14, -15,0.0,0.0,0.0},

{95, 12, (double)

, 0.0291, 0.047, 0.18, 0.16, -20,0.0,0.0,0.0},

{90, 12, (double)

, 0.0280, 0.038, 0.15, 0.19, -28,0.0,0.0,0.0},

{85, 12, (double)

, 0.0267, 0.030, 0.13, 0.21, -31,0.0,0.0,0.0},

{80, 12, (double)

, 0.0250, 0.021, 0.10, 0.25, -39,0.0,0.0,0.0},

{105, 11, (double)

, 0.0301, 0.056, 0.22, 0.14, -16,0.0,0.0,0.0},

{100, 11, (double)

, 0.0294, 0.049, 0.20, 0.15, -17,0.0,0.0,0.0},

{95, 11, (double)

, 0.0285, 0.042, 0.16, 0.18, -25,0.0,0.0,0.0},

{90, 11, (double)

, 0.0271, 0.031, 0.14, 0.20, -28,0.0,0.0,0.0},

{85, 11, (double)

, 0.0256, 0.023, 0.10, 0.26, -46,0.0,0.0,0.0},

{115, 10, (double)

, 0.0308, 0.062, 0.22, 0.14, -20,0.0,0.0,0.0},

{110, 10, (double)

, 0.0302, 0.056, 0.19, 0.16, -26,0.0,0.0,0.0},

{105, 10, (double)

, 0.0296, 0.050, 0.17, 0.17, -27,0.0,0.0,0.0},

{100, 10, (double)

, 0.0286, 0.041, 0.15, 0.19, -32,0.0,0.0,0.0},

{95, 10, (double)

, 0.0272, 0.030, 0.13, 0.21, -35,0.0,0.0,0.0},

{90, 10, (double)

, 0.0257, 0.022, 0.11, 0.24, -40,0.0,0.0,0.0},

{85, 10, (double)

, 0.0242, 0.017, 0.083, 0.29, -51,0.0,0.0,0.0},

{115, 9, (double)

, 0.0306, 0.061, 0.24, 0.13, -14,0.0,0.0,0.0},

{110, 9, (double)

, 0.0299, 0.053, 0.19, 0.16, -23,0.0,0.0,0.0},

{105, 9, (double)

, 0.0289, 0.043, 0.17, 0.17, -23,0.0,0.0,0.0},

{100, 9, (double)

, 0.0279, 0.036, 0.14, 0.20, -31,0.0,0.0,0.0},

{95, 9, (double)

, 0.0266, 0.028, 0.12, 0.23, -37,0.0,0.0,0.0},

{120, 8, (double)

, 0.0307, 0.062, 0.22, 0.14, -18,0.0,0.0,0.0},

{115, 8, (double)

, 0.0300, 0.053, 0.20, 0.15, -19,0.0,0.0,0.0},

{110, 8, (double)

, 0.0292, 0.046, 0.17, 0.17, -23,0.0,0.0,0.0},

{105, 8, (double)

, 0.0280, 0.035, 0.14, 0.20, -31,0.0,0.0,0.0},

{100, 8, (double)

, 0.0266, 0.026, 0.12, 0.23, -37,0.0,0.0,0.0},

{125, 7, (double)

, 0.0306, 0.058, 0.22, 0.14, -18,0.0,0.0,0.0},

{120, 7, (double)

, 0.0300, 0.052, 0.19, 0.16, -23,0.0,0.0,0.0},

{115, 7, (double)

, 0.0292, 0.044, 0.17, 0.17, -24,0.0,0.0,0.0},

{110, 7, (double)

, 0.0279, 0.032, 0.14, 0.20, -31,0.0,0.0,0.0},

{105, 7, (double)

, 0.0267, 0.026, 0.11, 0.24, -41,0.0,0.0,0.0},

{120,10,5, 0.0298, 0.049, 0.19, 0.16, -21,0.0,0.0,0.0},

{115,10,5, 0.0290, 0.042, 0.16, 0.18, -25,0.0,0.0,0.0},

{110,10,5, 0.0279, 0.033, 0.13, 0.21, -32,0.0,0.0,0.0},

{105,10,5, 0.0264, 0.024, 0.10, 0.26, -46,0.0,0.0,0.0},

{100,10,5, 0.0250, 0.018, 0.081, 0.31, -56,0.0,0.0,0.0},

{125,10,4, 0.0301, 0.053, 0.18, 0.17, -25,0.0,0.0,0.0},

{120,10,4, 0.0292, 0.043, 0.15, 0.20, -33,0.0,0.0,0.0},

{115,10,4, 0.0282, 0.035, 0.13, 0.22, -36,0.0,0.0,0.0},

{110,10,4, 0.0270, 0.027, 0.11, 0.25, -41,0.0,0.0,0.0},

{105,10,4, 0.0254, 0.020, 0.079, 0.32, -60,0.0,0.0,0.0},

{130,10,3, 0.0300, 0.051, 0.17, 0.18, -27,0.0,0.0,0.0},

{125,10,3, 0.0290, 0.040, 0.13, 0.22, -38,0.0,0.0,0.0},

{120,10,3, 0.0278, 0.030, 0.11, 0.25, -44,0.0,0.0,0.0},

{115,10,3, 0.0267, 0.025, 0.092, 0.29, -52,0.0,0.0,0.0},

{110,10,3, 0.0252, 0.018, 0.070, 0.36, -70,0.0,0.0,0.0},

{135,10,2, 0.0292, 0.040, 0.13, 0.22, -35,0.0,0.0,0.0},

{130,10,2, 0.0283, 0.034, 0.10, 0.28, -51,0.0,0.0,0.0},

{125,10,2, 0.0269, 0.024, 0.077, 0.35, -71,0.0,0.0,0.0},

{120,10,2, 0.0253, 0.017, 0.059, 0.43, -90,0.0,0.0,0.0},

{115,10,2, 0.0234, 0.011, 0.043, 0.55, -121,0.0,0.0,0.0},

{100,14,3, 0.0258, 0.023, 0.087, 0.33, -59,0.0,0.0,0.0},

{105,13,3, 0.0263, 0.024, 0.085, 0.31, -57,0.0,0.0,0.0},

{110,12,3, 0.0271, 0.028, 0.093, 0.29, -54,0.0,0.0,0.0},

{115,11,3, 0.0275, 0.030, 0.10, 0.27, -49,0.0,0.0,0.0},

{125,9,3, 0.0283, 0.034, 0.12, 0.23, -38,0.0,0.0,0.0},

{130,8,3, 0.0287, 0.037, 0.12, 0.23, -40,0.0,0.0,0.0},

{125,7,3, 0.0287, 0.036, 0.12, 0.24, -44,0.0,0.0,0.0},

{140,6,3, 0.0285, 0.033, 0.12, 0.23, -40,0.0,0.0,0.0},

{105,14,3, 0.0270, 0.028, 0.10, 0.27, -46,0.0,0.0,0.0},

{110,13,3, 0.0279, 0.034, 0.10, 0.27, -50,0.0,0.0,0.0},

{115,12,3, 0.0282, 0.035, 0.12, 0.24, -42,0.0,0.0,0.0},

{120,11,3, 0.0286, 0.037, 0.12, 0.24, -44,0.0,0.0,0.0},

blosum62_20_prefs[BLOSUM62_20_VALUES_MAX] = {

{(double)

, (

)

, (double)

, 0.28768, 0.282, 1.69, 0.1703, -0.3, 0.43828, 0.16804, 0.16804},

{15, 2, (double)

, 0.2835, 0.255, 1.49, 0.19, -1, 0.44502, 0.24613, 0.22743}

{ 0, 0, 1.39, 0.747, 1.38, 1.00, 0, 100 },

{ 3, 3, 1.39, 0.747, 1.38, 1.00, 0, 100 }

{ 0, 0, 1.383, 0.738, 1.36, 1.02, 0, 100 },

{ 1, 2, 1.36, 0.67, 1.2, 1.1, 0, 98 },

{ 0, 2, 1.26, 0.43, 0.90, 1.4, -1, 91 },

{ 2, 1, 1.35, 0.61, 1.1, 1.2, -1, 98 },

{ 1, 1, 1.22, 0.35, 0.72, 1.7, -3, 88 }

{ 0, 0, 0.69, 0.73, 1.34, 0.515, 0, 100 },

{ 2, 4, 0.68, 0.67, 1.2, 0.55, 0, 99 },

{ 0, 4, 0.63, 0.43, 0.90, 0.7, -1, 91 },

{ 4, 2, 0.675, 0.62, 1.1, 0.6, -1, 98 },

{ 2, 2, 0.61, 0.35, 0.72, 1.7, -3, 88 }

{ 0, 0, 1.374, 0.711, 1.31, 1.05, 0, 100 },

{ 2, 2, 1.37, 0.70, 1.2, 1.1, 0, 99 },

{ 1, 2, 1.35, 0.64, 1.1, 1.2, -1, 98 },

{ 0, 2, 1.25, 0.42, 0.83, 1.5, -2, 91 },

{ 2, 1, 1.34, 0.60, 1.1, 1.2, -1, 97 },

{ 1, 1, 1.21, 0.34, 0.71, 1.7, -2, 88 }

{ 0, 0, 0.675, 0.65, 1.1, 0.6, -1, 99 },

{ 2, 4, 0.67, 0.59, 1.1, 0.6, -1, 98 },

{ 0, 4, 0.62, 0.39, 0.78, 0.8, -2, 91 },

{ 4, 2, 0.67, 0.61, 1.0, 0.65, -2, 98 },

{ 2, 2, 0.56, 0.32, 0.59, 0.95, -4, 82 }

{ 0, 0, 1.28, 0.46, 0.85, 1.5, -2, 96 },

{ 2, 2, 1.33, 0.62, 1.1, 1.2, 0, 99 },

{ 1, 2, 1.30, 0.52, 0.93, 1.4, -2, 97 },

{ 0, 2, 1.19, 0.34, 0.66, 1.8, -3, 89 },

{ 3, 1, 1.32, 0.57, 1.0, 1.3, -1, 99 },

{ 2, 1, 1.29, 0.49, 0.92, 1.4, -1, 96 },

{ 1, 1, 1.14, 0.26, 0.52, 2.2, -5, 85 }

{ 0, 0, 0.55, 0.21, 0.46, 1.2, -5, 87 },

{ 4, 4, 0.63, 0.42, 0.84, 0.75, -2, 99 },

{ 2, 4, 0.615, 0.37, 0.72, 0.85, -3, 97 },

{ 0, 4, 0.55, 0.21, 0.46, 1.2, -5, 87 },

{ 3, 3, 0.615, 0.37, 0.68, 0.9, -3, 97 },

{ 6, 2, 0.63, 0.42, 0.84, 0.75, -2, 99 },

{ 5, 2, 0.625, 0.41, 0.78, 0.8, -2, 99 },

{ 4, 2, 0.61, 0.35, 0.68, 0.9, -3, 96 },

{ 2, 2, 0.515, 0.14, 0.33, 1.55, -9, 81 }

{ 6, 3, 0.389, 0.25, 0.56, 0.7, -5, 95},

{ 5, 3, 0.375, 0.21, 0.47, 0.8, -6, 92},

{ 4, 3, 0.351, 0.14, 0.35, 1.0, -9, 86},

{ 6, 2, 0.362, 0.16, 0.45, 0.8, -4, 88},

{ 5, 2, 0.330, 0.092, 0.28, 1.2, -13, 81},

{ 4, 2, 0.281, 0.046, 0.16, 1.8, -23, 69}

{ 0, 0, 0.22, 0.061, 0.22, 1.0, -15, 74 },

{ 6, 5, 0.28, 0.21, 0.47, 0.6 , -7, 93 },

{ 5, 5, 0.27, 0.17, 0.39, 0.7, -9, 90 },

{ 4, 5, 0.25, 0.10, 0.31, 0.8, -10, 83 },

{ 3, 5, 0.23, 0.065, 0.25, 0.9, -11, 76 }

{ 3, 2, 1.09, 0.31, 0.55, 2.0, -2, 99 },

{ 2, 2, 1.07, 0.27, 0.49, 2.2, -3, 97 },

{ 1, 2, 1.02, 0.21, 0.36, 2.8, -6, 92 },

{ 0, 2, 0.80, 0.064, 0.17, 4.8, -16, 72 },

{ 4, 1, 1.08, 0.28, 0.54, 2.0, -2, 98 },

{ 3, 1, 1.06, 0.25, 0.46, 2.3, -4, 96 },

{ 2, 1, 0.99, 0.17, 0.30, 3.3, -10, 90 }

{ 5, 5, 0.208, 0.030, 0.072, 2.9, -47, 77}

{ 10, 6, 0.163, 0.068, 0.16, 1.0, -19, 85 },

{ 8, 6, 0.146, 0.039, 0.11, 1.3, -29, 76 }

(matrix->

) {

( matrix->

)

( !retval->

) {

retval->

= (

*)

(ncols,

(

));

retval->

= ncols;

retval->

= nrows;

( !retval->

) {

( !retval->

) {

( !gbp)

;

(sbp->

[index] || sbp->

[index])

use_old_fsc = getenv(

);

* ambig_buffer;

index1, index2, degen;

k_number_non_ambig_bp = 4;

matrix[index1][index2] = 0;

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

degeneracy[index1] = 1;

(index1=k_number_non_ambig_bp; index1<

; index1++) {

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

degeneracy[index1] = degen;

matrix[index1][index2] =

(

)

( (

) ((degeneracy[index2]-1)*penalty +

reward)/ (double) degeneracy[index2]);

(index1 != index2)

matrix[index2][index1] = matrix[index1][index2];

matrix[index1][index2] = penalty;

matrix[index2][index1] = penalty;

rowIdx,colIdx,

,base;

index1, index2;

lambda_upper = 0;

lambda_lower = 0;

kCommentChar =

;

* kTokenStr =

;

( fgets(fbuf,

(fbuf),

) ) {

(strchr(fbuf,

) ==

) {

( (*cp) &&

(*cp) ) cp++;

(*cp == kCommentChar) {

( (ncp = strstr( cp, (

*)

)) !=

) {

( (*cp) &&

(*cp) ) cp++;

lp = (

*)strtok(cp, kTokenStr);

(lp !=

) {

lp = (

*)strtok(

, kTokenStr);

( sscanf(lp,

, &fval ) != 1 )

lp = (

*)strtok(

, kTokenStr);

*strchr(cp,

) =

;

(

(*cp) && !alphabet[0] ) {

lp = (

*)strtok(cp, kTokenStr);

(lp !=

) {

alphabet[j++] =

((

)(*lp));

lp = (

*)strtok(

, kTokenStr);

( (*cp) &&

(*cp) ) cp++;

(

(*cp) || *cp ==

) {

lp = (

*)strtok(cp, kTokenStr);

(lp !=

) {

( sscanf(lp,

, &

) != 1 )

matrix[rowIdx][colIdx] =

;

lp = (

*)strtok(

, kTokenStr);

( j != alphaSize )

( numFreqs != 4 ||

!= alphaSize )

( freqs[

] && freqs[j] )

sum += freqs[

] * freqs[j] *

exp(

* matrix[

][j] );

+= freqs[

] * freqs[j];

}

( sum < 1.0 );

( lambda_upper - lambda_lower > (

).00001 ) {

= ( lambda_lower + lambda_upper ) / 2.0;

( freqs[

] && freqs[j] )

sum += freqs[

] * freqs[j] *

exp(

* matrix[

][j] );

+= freqs[

] * freqs[j];

a1cnt = 0, a2cnt = 0;

index1, index2;

x_index, u_index, o_index, c_index;

kCommentChar =

;

* kTokenStr =

;

(strchr(

,

) ==

) {

(

[0] == kCommentChar) {

((cp = strchr(

, kCommentChar)) !=

)

lp = (

*)strtok(

, kTokenStr);

(lp !=

) {

a2chars[a2cnt++] = ch;

lp = (

*)strtok(

, kTokenStr);

((cp = strchr(

,

)) ==

) {

((cp = strchr(

, kCommentChar)) !=

)

((lp = (

*)strtok(

, kTokenStr)) ==

)

((cp = strtok(

, kTokenStr)) ==

) {

(a1cnt >=

(a1chars)) {

a1chars[a1cnt++] = ch;

m = &matrix[(

)ch][0];

(cp !=

) {

(index2 >= (

) a2cnt) {

(sscanf(temp,

, &xscore) != 1) {

xscore += (xscore >= 0. ? 0.5 : -0.5);

score = (

)xscore;

m[(

)a2chars[index2++]] = score;

cp = strtok(

, kTokenStr);

matrix[u_index][index1] = matrix[c_index][index1];

matrix[index1][u_index] = matrix[index1][c_index];

matrix[o_index][index1] = matrix[x_index][index1];

matrix[index1][o_index] = matrix[index1][x_index];

index1, index2;

score = matrix[index1][index2];

x_index, u_index, o_index, c_index;

matrix[u_index][

] = matrix[c_index][

];

matrix[

][u_index] = matrix[

][c_index];

matrix[o_index][

] = matrix[x_index][

];

matrix[

][o_index] = matrix[

][x_index];

matrix_found =

;

matrix_found =

;

matrix_found =

;

* matrix_path = get_path(sbp->

,

);

* full_matrix_path =

;

path_len = strlen(matrix_path);

buflen = path_len + strlen(sbp->

);

full_matrix_path = (

*)

((buflen + 1) *

(char));

(!full_matrix_path) {

memcpy(full_matrix_path, matrix_path, path_len);

memcpy(full_matrix_path + path_len, sbp->

, buflen - path_len);

full_matrix_path[buflen] =

;

(matrix_path);

( (

=fopen(full_matrix_path,

)) ==

) {

(full_matrix_path);

matrix_found =

;

(matrix_found ==

)

alphabet_stop, index;

p = rfp->

[index];

rfp->

[index] /= sum;

rfp->

[index] *= norm;

(index=0; index<

(

); index++)

rcp->

[index] = 0;

(lp =

, lpmax = lp+length; lp < lpmax; lp++)

alphabet_max, index;

rfp->

[index] = 0.0;

alphabet_max, index;

sum += rcp->

[index];

rfp->

[index] = rcp->

[index] / sum;

(lo >= 0 || hi <= 0 ||

range = score_max - score_min + 1;

sfp->

= (

*)

(range,

(

));

sfp->

-= score_min;

score, obs_min, obs_max;

score_sum, score_avg;

alphabet_start, alphabet_end, index1, index2;

(score = sfp->

; score <= sfp->score_max; score++)

sfp->

[score] = 0.0;

(index1=alphabet_start; index1<alphabet_end; index1++)

(index2=alphabet_start; index2<alphabet_end; index2++)

score = matrix[index1][index2];

sfp->

[score] += rfp1->

[index1] * rfp2->

[index2];

(score = sfp->

; score <= sfp->score_max; score++)

(sfp->

[score] > 0.)

score_sum += sfp->

[score];

(score_sum > 0.0001 || score_sum < -0.0001)

(score = obs_min; score <= obs_max; score++)

sfp->

[score] /= score_sum;

score_avg += score * sfp->

[score];

*alignmentScoreProbabilities =

;

lowAlignmentScore, highAlignmentScore;

innerSum;

oldsum, oldsum2;

firstTermClosedForm;

*probArrayStartLow;

*ptrP, *ptr1, *ptr2, *ptr1e;

expMinusLambda;

(

<= 0. ||

<= 0.) {

probArrayStartLow = &sfp->

[low];

(

= 1, divisor = -low; i <= range && divisor > 1; ++

) {

(probArrayStartLow[

] != 0.0)

firstTermClosedForm =

/

;

expMinusLambda = exp((

) -

);

(low == -1 && high == 1) {

K = (sfp->

[low*divisor] - sfp->

[high*divisor]) *

(sfp->

[low*divisor] - sfp->

[high*divisor]) / sfp->

[low*divisor];

(low == -1 || high == 1) {

= (score_avg * score_avg) / firstTermClosedForm;

firstTermClosedForm * (1.0 - expMinusLambda);

alignmentScoreProbabilities =

(

*)

((iterlimit*range + 1),

(*alignmentScoreProbabilities));

(alignmentScoreProbabilities ==

)

lowAlignmentScore = highAlignmentScore = 0;

alignmentScoreProbabilities[0] = innerSum = oldsum = oldsum2 = 1.;

(iterCounter = 0;

((iterCounter < iterlimit) && (innerSum > sumlimit));

outerSum += innerSum /= ++iterCounter) {

lowAlignmentScore += low;

highAlignmentScore += high;

(ptrP = alignmentScoreProbabilities +

(highAlignmentScore-lowAlignmentScore);

ptrP >= alignmentScoreProbabilities;

*ptrP-- =innerSum) {

ptr1 = ptrP -

;

ptr1e = ptrP -

;

ptr2 = probArrayStartLow +

;

(innerSum = 0.; ptr1 >= ptr1e; ) {

innerSum += *ptr1 * *ptr2;

(ptrP - alignmentScoreProbabilities <= range)

(

= lowAlignmentScore + 1;

< 0;

++ ) {

innerSum = *++ptrP + innerSum * expMinusLambda;

innerSum *= expMinusLambda;

(;

<= highAlignmentScore; ++

)

innerSum += *++ptrP;

ratio = oldsum / oldsum2;

(ratio >= (1.0 - sumlimit*0.001)) {

(alignmentScoreProbabilities !=

)

(alignmentScoreProbabilities);

(innerSum > sumlimit) {

outerSum += innerSum = oldsum / ++iterCounter;

K = -exp((

)-2.0*outerSum) /

(alignmentScoreProbabilities !=

)

(alignmentScoreProbabilities);

x0, x,

= 0,

= 1;

x0 = exp( -lambda0 );

x = ( 0 < x0 && x0 < 1 ) ? x0 : .5;

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

, fold =

;

wasNewton = isNewton;

(

= low + d;

< 0;

+= d ) {

=

* x + probs[

];

=

* x + probs[0] - 1;

(

= d;

<= high;

+= d ) {

=

* x + probs[

];

}

(

< 0 ) {

(

-

< 2 *

* ( 1 -

) * tolx ) {

x = (

+

) / 2;

;

( k >= maxNewton ||

( wasNewton &&

(

) > .9 *

(fold) ) ||

p = -

/

;

( y <= a || y >=

) {

(

( p ) < tolx * x * (1-x) )

;

sprob = sfp->

;

(

= 1, d = -low;

<= high-low && d > 1; ++

) {

(sprob[

+low] != 0.0) {

, etonlam, sum, scale;

*probs = sfp->

;

etonlam = exp( -

);

sum = low * probs[low];

( score = low + 1; score <= high; score++ ) {

sum = score * probs[score] + etonlam * sum;

( scale > 0.0 ) {

kbp->

= kbp->

= kbp->

= -1.;

kbp->

= HUGE_VAL;

context <= query_info->last_context; ++

) {

context_offset;

valid_context =

;

(valid_context ==

)

(status = 1);

(!kbp_to || !kbp_from)

kbp_to->

= kbp_from->

;

kbp_to->

= kbp_from->

;

(matrix_info ==

)

(matrix_info);

matrix_info->

= values;

matrix_info->

= prefs;

matrix_info =

(

, blosum62_20_values, blosum62_20_prefs, BLOSUM62_20_VALUES_MAX);

(!standard_only) {

index, max_number_values=0;

* lambda_array=

,* K_array=

,* H_array=

,* alpha_array=

,* beta_array=

;

(matrix ==

)

matrix_info = vnp->

;

values = matrix_info->

;

prefs = matrix_info->

;

found_matrix =

;

*open = open_array = (

*)

(max_number_values,

(

));

*extension = extension_array =

*

= lambda_array =

(

*)

(max_number_values,

(

));

*K = K_array = (

*)

(max_number_values,

(

));

*

= H_array = (

*)

(max_number_values,

(

));

*alpha = alpha_array = (

*)

(max_number_values,

(

));

*beta = beta_array = (

*)

(max_number_values,

(

));

*pref_flags = pref_flags_array =

(index=0; index<max_number_values; index++)

open_array[index] = (

) values[index][0];

extension_array[index] = (

) values[index][1];

lambda_array[index] = values[index][3];

K_array[index] = values[index][4];

H_array[index] = values[index][5];

alpha_array[index] = values[index][6];

beta_array[index] = values[index][7];

pref_flags_array[index] = prefs[index];

max_number_values;

* gapOpen_arr,* gapExtend_arr,* pref_flags;

* alpha_arr,* beta_arr;

&gapExtend_arr,

,

,

, &alpha_arr, &beta_arr,

((0 == gap_open) && (0 == gap_extend)) {

(

= 1;

< num_values;

++) {

(*alpha) = alpha_arr[

];

(*beta) = beta_arr[

];

(

= 1;

< num_values;

++) {

((gapOpen_arr[

] == gap_open) &&

(gapExtend_arr[

] == gap_extend)) {

(*alpha) = alpha_arr[

];

(*beta) = beta_arr[

];

(num_values > 0) {

(*alpha) = alpha_arr[0];

(*beta) = beta_arr[0];

*alpha = kbp_ungapped->

/ kbp_ungapped->

;

(gapOpen_arr);

(gapExtend_arr);

*non_affine =

;

*non_affine =

;

(*gap_existence_max) *= divisor;

(*gap_extend_max) *= divisor;

normal[

][0] *= divisor;

normal[

][1] *= divisor;

normal[

][2] /= divisor;

normal[

][5] /= divisor;

linear[0][0] *= divisor;

linear[0][1] *= divisor;

linear[0][2] /= divisor;

linear[0][5] /= divisor;

divisor =

(reward, penalty);

*round_down =

;

*non_affine =

;

(reward == 1 && penalty == -5) {

*gap_extend_max = 3;

}

(reward == 1 && penalty == -4) {

*gap_extend_max = 2;

}

(reward == 2 && penalty == -7) {

*round_down =

;

*gap_extend_max = 4;

}

(reward == 1 && penalty == -3) {

*gap_extend_max = 2;

}

(reward == 2 && penalty == -5) {

*round_down =

;

*gap_extend_max = 4;

}

(reward == 1 && penalty == -2) {

*gap_extend_max = 2;

}

(reward == 2 && penalty == -3) {

*round_down =

;

*gap_extend_max = 4;

}

(reward == 3 && penalty == -4) {

*round_down =

;

*gap_extend_max = 3;

}

(reward == 1 && penalty == -1) {

*gap_extend_max = 2;

}

(reward == 3 && penalty == -2) {

*gap_extend_max = 5;

}

(reward == 4 && penalty == -5) {

*gap_extend_max = 8;

}

(reward == 5 && penalty == -4) {

*gap_extend_max = 10;

snprintf(

,

(

),

,

(*array_size > 0)

(kValues_non_affine)

* gap_existence,

* gap_extension)

* gapOpen_arr,* gapExtend_arr,* pref_flags;

(num_values <= 0)

(

= 1;

< num_values;

++) {

(*gap_existence) = gapOpen_arr[

];

(*gap_extension) = gapExtend_arr[

];

(gapOpen_arr);

(gapExtend_arr);

* gap_existence,

* gap_extension)

gap_existence_max=0;

gap_extension_max=0;

&gap_existence_max, &gap_extension_max, &round_down,

);

(*gap_existence == 0 && *gap_extension == 0 && non_affine)

(index < array_size)

(*gap_existence == normal[index][0] && *gap_extension == normal[index][1])

(*gap_existence < gap_existence_max || *gap_extension < gap_extension_max)

*gap_existence = gap_existence_max;

*gap_extension = gap_extension_max;

gap_existence_max = 0;

gap_extension_max = 0;

&non_affine, &gap_existence_max,

&gap_extension_max, &round_down,

);

max_number_values=0;

matrix_info = vnp->

;

values = matrix_info->

;

found_matrix =

;

(index=0; index<max_number_values; index++)

snprintf(

,

(

),

, (

)

(values[index][0]), (

)

(values[index][1]));

snprintf(

,

(

),

, (

)

(values[index][0]), (

)

(values[index][1]), (

)

(values[index][2]));

gap_extend, matrix_name,

);

(status && error_return)

snprintf(

,

(

),

, matrix_name);

matrix_info = vnp->

;

snprintf(

,

(

),

, matrix_info->

);

(status == 2)

snprintf(

,

(

),

, (

) gap_open, (

) gap_extend, matrix_name);

gap_extend,

* matrix_name,

max_number_values=0;

(matrix_name ==

)

matrix_info = vnp->

;

values = matrix_info->

;

found_matrix =

;

(index=0; index<max_number_values; index++)

(

(values[index][0]) == gap_open &&

kbp->

= values[index][3];

kbp->

= values[index][4];

kbp->

= values[index][5];

found_values =

;

(found_values ==

)

(status && error_return) {

snprintf(

,

(

),

, matrix_name);

matrix_info = vnp->

;

snprintf(

,

(

),

, matrix_info->

);

}

(status == 2) {

snprintf(

,

(

),

, (

) gap_open, (

) gap_extend, matrix_name);

gap_extend,

* matrix_name)

max_number_values=0;

(matrix_name ==

)

matrix_info = vnp->

;

values = matrix_info->

;

found_matrix =

;

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

(

(values[index][0]) == gap_open &&

(values[index][1]) == gap_extend) {

gbp->

= values[index][3];

gbp->

= values[index][8];

gbp->

= gap_open + gap_extend;

gbp->

= values[index][6];

gbp->

= values[index][9];

gbp->

= values[index][10];

gbp->

= values[0][6];

gbp->

= 2.0 * gbp->

* (gbp->

- gbp->

);

found_values =

;

status = found_values ? 0 : 2;

*

= (

*)

( buffer_sz ,

(

));

out_sz = snprintf(ptr, (

)buffer_sz,

, matrix_name);

buffer_sz -= ( 1 + out_sz );

( buffer_sz < 0 ) buffer_sz = 0;

matrix_info = vnp->

;

out_sz = snprintf(ptr,(

)buffer_sz,

, matrix_info->

);

buffer_sz -= out_sz ;

( buffer_sz < 0 ) buffer_sz = 0;

index, max_number_values=0;

ptr =

= (

*)

((

)buffer_sz,

(char));

out_sz = snprintf(ptr, (

)buffer_sz,

,

(

) gap_open, (

) gap_extend, matrix_name);

buffer_sz -= ( 1 + out_sz );

( buffer_sz < 0 ) buffer_sz = 0;

matrix_info = vnp->

;

values = matrix_info->

;

found_matrix =

;

(index=0; index<max_number_values; index++)

out_sz = snprintf(ptr, (

)buffer_sz,

, (

)

(values[index][0]), (

)

(values[index][1]));

out_sz = snprintf(ptr, (

)buffer_sz,

, (

)

(values[index][0]), (

)

(values[index][1]), (

)

(values[index][2]));

buffer_sz -= out_sz ;

( buffer_sz < 0 ) buffer_sz = 0;

kGapOpenIndex = 0;

kGapExtIndex = 1;

kLambdaIndex = 2;

kKIndex = 3;

kHIndex = 4;

num_combinations = 0;

gap_open_max, gap_extend_max;

(kbp && kbp_ungap);

(gap_open == 0 && gap_extend == 0 && linear)

kbp->

= linear[0][kLambdaIndex];

kbp->

= linear[0][kKIndex];

kbp->

= linear[0][kHIndex];

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

(normal[index][kGapOpenIndex] == gap_open &&

normal[index][kGapExtIndex] == gap_extend) {

kbp->

= normal[index][kLambdaIndex];

kbp->

= normal[index][kKIndex];

kbp->

= normal[index][kHIndex];

(index == num_combinations) {

(gap_open >= gap_open_max && gap_extend >= gap_extend_max) {

}

(error_return) {

buffer_sz = 8192;

out_sz = snprintf(

, (

)buffer_sz,

,

(

) gap_open, (

) gap_extend, (

) reward, (

) penalty);

buffer_sz -= ( 1 + out_sz );

( buffer_sz < 0 ) buffer_sz = 0;

(

= 0;

< num_combinations; ++

)

out_sz = snprintf(

+

, (

)buffer_sz,

,

(

) normal[

][kGapOpenIndex], (

) normal[

][kGapExtIndex]);

buffer_sz -= out_sz ;

( buffer_sz < 0 ) buffer_sz = 0;

out_sz = snprintf(

+

, (

)buffer_sz,

,

(

) gap_open_max, (

) gap_extend_max);

buffer_sz -= out_sz ;

( buffer_sz < 0 ) buffer_sz = 0;

out_sz = snprintf(

+

, (

)buffer_sz,

,

(

) gap_open_max, (

) gap_extend_max);

buffer_sz -= out_sz ;

( buffer_sz < 0 ) buffer_sz = 0;

((reward == 1 && penalty == -1) ||

(reward == 2 && penalty == -3))

*alpha,

*beta)

kGapOpenIndex = 0;

kGapExtIndex = 1;

kAlphaIndex = 5;

kBetaIndex = 6;

num_combinations = 0;

gap_open_max = 0, gap_extend_max = 0;

(alpha && beta && kbp);

(gapped_calculation && normal) {

(gap_open == 0 && gap_extend == 0 && linear)

*alpha = linear[0][kAlphaIndex];

*beta = linear[0][kBetaIndex];

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

(normal[index][kGapOpenIndex] == gap_open &&

normal[index][kGapExtIndex] == gap_extend) {

*alpha = normal[index][kAlphaIndex];

*beta = normal[index][kBetaIndex];

*alpha = kbp->

/kbp->

;

Lambda, K,

;

kSmallFloat = 1.0e-297;

(Lambda < 0. || K < 0. ||

< 0.0)

=

(

, kSmallFloat);

= (

) (ceil(

((

)(K * searchsp /

)) / Lambda ));

(1. - decayrate) *

(decayrate, nsegs - 1);

gap_decay_rate)

e = *

, esave;

(kbp->

== -1. || kbp->

== -1. || kbp->

== -1.)

( gap_decay_rate > 0 && gap_decay_rate < 1 ) {

(esave <= 0. || !s_changed)

( gap_decay_rate > 0 && gap_decay_rate < 1 ) {

Lambda, K,

;

(Lambda < 0. || K < 0. ||

< 0.) {

(

) searchsp * exp((

)(-Lambda *

) + kbp->

);

(p < 0.0 || p > 1.0) {

y = exp(x - callback_args->

);

exp(callback_args->

- y);

callback_args->

= callback_args->

- s;

mx = (s > 0. ? callback_args->

+ 3. : 3.);

mean, stddev, stddev4;

kSumpEpsilon = 0.002;

(

< 101) {

stddev4 = 4.*stddev;

est_mean = -

*

;

(s <= est_mean - stddev4)

mean =

* (1. - logr) - 0.5;

(s <= mean - stddev4)

= mean + 6.*stddev;

memset((

*)&callback_args, 0,

(callback_args));

callback_args.

= kSumpEpsilon;

}

(s < mean && d < 0.4 && itmin++ < 4);

(d < 1. ? d : 1.);

kTab2[] = {

0.01669, 0.0249, 0.03683, 0.05390, 0.07794, 0.1111, 0.1559, 0.2146,

0.2890, 0.3794, 0.4836, 0.5965, 0.7092, 0.8114, 0.8931, 0.9490,

0.9806, 0.9944, 0.9989

kTab3[] = {

0.9806, 0.9944, 0.9989, 0.0001682,0.0002542,0.0003829,0.0005745,0.0008587,

0.001278, 0.001893, 0.002789, 0.004088, 0.005958, 0.008627, 0.01240, 0.01770,

0.02505, 0.03514, 0.04880, 0.06704, 0.09103, 0.1220, 0.1612, 0.2097,

0.2682, 0.3368, 0.4145, 0.4994, 0.5881, 0.6765, 0.7596, 0.8326,

0.8922, 0.9367, 0.9667, 0.9846, 0.9939, 0.9980

kTab4[] = {

2.658e-07,4.064e-07,6.203e-07,9.450e-07,1.437e-06,2.181e-06,3.302e-06,4.990e-06,

7.524e-06,1.132e-05,1.698e-05,2.541e-05,3.791e-05,5.641e-05,8.368e-05,0.0001237,

0.0001823,0.0002677,0.0003915,0.0005704,0.0008275,0.001195, 0.001718, 0.002457,

0.003494, 0.004942, 0.006948, 0.009702, 0.01346, 0.01853, 0.02532, 0.03431,

0.04607, 0.06128, 0.08068, 0.1051, 0.1352, 0.1719, 0.2157, 0.2669,

0.3254, 0.3906, 0.4612, 0.5355, 0.6110, 0.6849, 0.7544, 0.8168,

0.8699, 0.9127, 0.9451, 0.9679, 0.9827, 0.9915, 0.9963

*

[] = { kTab2, kTab3, kTab4 };

kTabsize[] = {

(kTab2)-1,

(kTab3)-1,

(kTab4)-1 };

(s >=

*

+

) {

* exp(

*

(s)-s-

-

);

= (

) (

= s+s+(4*

));

= kTabsize[

=

- 2] -

;

starting_points,

subject_length,

weight_divisor)

sum_e = searchsp_eff * exp(-xsum);

pair_search_space;

pair_search_space = (double)subject_length * (

)query_length;

(pair_search_space) + 2 * (num-1)*

((

)starting_points);

((double) searchsp_eff / (

) pair_search_space);

( weight_divisor == 0.0 || (sum_e /= weight_divisor) >

) {

num,

xsum,

query_length,

subject_length,

weight_divisor)

sum_e = searchsp_eff * exp(-xsum);

pair_search_space;

pair_search_space = (double)subject_length*(

)query_length;

xsum -=

(pair_search_space) +

(num-1)*(

((

) query_start_points) +

((

) subject_start_points));

((double) searchsp_eff / (

) pair_search_space);

( weight_divisor == 0.0 || (sum_e /= weight_divisor) >

) {

subject_length,

weight_divisor)

lcl_subject_length;

lcl_query_length;

lcl_query_length = (double) query_length;

lcl_subject_length = (double) subject_length;

sum_e = searchsp_eff * exp(-xsum);

xsum -= num*

(lcl_subject_length*lcl_query_length)

((double) searchsp_eff / (lcl_query_length * lcl_subject_length));

( weight_divisor == 0.0 || (sum_e /= weight_divisor) >

) {

denominator = length;

(

= 0;

< length;

++) {

frequency[sequence[

]]++;

(frequency[

] == 0)

resProb[

] = ((double) frequency[

]) /((double) denominator);

* lambda_array =

;

(num_lambdas > 0) {

retval = lambda_array[0];

(lambda_array);

(lambda_array);

*queryProbArray,

*scoreArray,

minScore, maxScore;

minScore = maxScore = 0;

(

= 0;

< matrixLength;

++) {

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

(matrix[

][j] < minScore))

minScore = matrix[

][j];

(matrix[

][j] > maxScore)

maxScore = matrix[

][j];

return_sfp->

= minScore;

return_sfp->

= maxScore;

memset(scoreArray, 0, (maxScore - minScore + 1) *

(

));

return_sfp->

= &(scoreArray[-minScore]);

recipLength = 1.0 / (double) matrixLength;

(

= 0;

< matrixLength;

++) {

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

(matrix[

][j] >= minScore)

return_sfp->

[matrix[

][j]] += recipLength *

(

= minScore;

<= maxScore;

++)

* rps_query_seq,

db_seq_length,

* * returnMatrix;

initialUngappedLambda;

scaledInitialUngappedLambda;

correctUngappedLambda;

index, inner_index;

(posMatrix, db_seq_length, resProb, scoreArray,

(initialUngappedLambda > 0.0);

scaledInitialUngappedLambda = initialUngappedLambda / scalingFactor;

scaledInitialUngappedLambda);

(correctUngappedLambda == -1.0)

finalLambda = correctUngappedLambda/scaledInitialUngappedLambda;

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

(inner_index = 0; inner_index < alphabet_size; inner_index++) {

returnMatrix[index][inner_index] =

posMatrix[index][inner_index];

temp = ((double)(posMatrix[index][inner_index])) * finalLambda;

returnMatrix;

compressed_alphabet_size,

compressed_letter;

[

] = compressed_alphabet_size;

(

= j = compressed_letter = 0; trans_string[

] != 0;

++) {

c = trans_string[

];

compressed_letter++;

[aa_letter] = compressed_letter;

rev_table[compressed_letter][j++] = aa_letter;

rev_table[compressed_letter][j] = -1;

(compressed_letter == compressed_alphabet_size - 1);

* compressed_prob,

compressed_alphabet_size,

compressed_prob[

] = 0.0;

prob_sum = 0.;

prob_sum += rfp->

[aa];

compressed_prob[aa] = rfp->

[aa] / prob_sum;

matrix_scale_factor,

compressed_alphabet_size =

matrix_scale_factor /=

;

(std_freqs ==

)

compressed_alphabet_size,

**scores = new_matrix->

;

(s = 0; s < compressed_alphabet_size; s++) {

aa = rev_table[s][

];

+= std_freqs->

[q][aa] * compressed_prob[aa];

*

=

;

compressed_alphabet_size,

matrix_scale_factor)

* alphabet_string = compressed_alphabet_size == 10 ?

(compressed_alphabet_size == 10 ||

compressed_alphabet_size == 15);

compressed_alphabet_size,

matrix_scale_factor, rev_table) < 0) {

new_alphabet;

alpha_d_lambda,

* length_adjustment)

kMaxIterations = 20;

m = (double) query_length;

= (double) db_length;

= (double) db_num_seqs;

ell_min = 0, ell_max;

ell_next = 0;

mb = m *

+

;

c =

* m -

(m,

) / K;

*length_adjustment = 0;

ell_max = 2 * c / (mb + sqrt(mb * mb - 4 *

* c));

(

= 1;

<= kMaxIterations;

++) {

ss = (m - ell) * (

-

* ell);

ell_bar = alpha_d_lambda * (logK +

(ss)) + beta;

(ell_bar >= ell) {

(ell_bar - ell_min <= 1.0) {

(ell_min == ell_max) {

(ell_min <= ell_bar && ell_bar <= ell_max) {

ell_next = (

== 1) ? ell_max : (ell_min + ell_max) / 2;

*length_adjustment = (

) ell_min;

ell = ceil(ell_min);

( ell <= ell_max ) {

ss = (m - ell) * (

-

* ell);

(alpha_d_lambda * (logK +

(ss)) + beta >= ell) {

*length_adjustment = (

) ell;

*length_adjustment = (

) ell_min;

converged ? 0 : 1;

db_scale_factor = (gbp->

) ?

(

)gbp->

/(double)n_ : 1.0;

lambda_ = kbp->

;

k_ = kbp->

;

ai_hat_ = gbp->

* scale_factor;

bi_hat_ = gbp->

;

alphai_hat_= gbp->

* scale_factor;

betai_hat_ = gbp->

;

sigma_hat_ = gbp->

* scale_factor;

tau_hat_ = gbp->

;

aj_hat_ = ai_hat_;

bj_hat_ = bi_hat_;

alphaj_hat_= alphai_hat_;

betaj_hat_ = betai_hat_;

const_val = 0.39894228040143267793994605993438;

m_li_y, vi_y, sqrt_vi_y, m_F, P_m_F;

n_lj_y, vj_y, sqrt_vj_y, n_F, P_n_F;

c_y, p1, p2, area;

m_li_y = m_ - (ai_hat_*y_ + bi_hat_);

vi_y =

(2.0*alphai_hat_/lambda_, alphai_hat_*y_+betai_hat_);

sqrt_vi_y = sqrt(vi_y);

m_F = m_li_y/sqrt_vi_y;

P_m_F =

(-m_F / sqrt(2.0)) / 2.0;

p1 = m_li_y * P_m_F + sqrt_vi_y * const_val * exp(-0.5*m_F*m_F);

n_lj_y = n_ - (aj_hat_*y_ + bj_hat_);

vj_y =

(2.0*alphaj_hat_/lambda_, alphaj_hat_*y_+betaj_hat_);

sqrt_vj_y = sqrt(vj_y);

n_F = n_lj_y/sqrt_vj_y;

P_n_F =

(-n_F / sqrt(2.0)) / 2.0;

p2 = n_lj_y * P_n_F + sqrt_vj_y * const_val * exp(-0.5*n_F*n_F);

c_y =

(2.0*sigma_hat_/lambda_, sigma_hat_*y_+tau_hat_);

area = p1 * p2 + c_y * P_m_F * P_n_F;

e_value = area * k_ * exp(-lambda_ * y_) * db_scale_factor;

db_scale_factor = (gbp->

) ?

=

((

)(

(db_scale_factor/e0) / kbp->

), 2);

(

-

> 1) {

#define sfree(x)

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

const char * kBlastErrMsg_CantCalculateUngappedKAParams

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.

Boolean Blast_QueryIsPssm(EBlastProgramType p)

Returns true if the query is PSSM.

Boolean Blast_QueryIsTranslated(EBlastProgramType p)

Returns true if the query is translated.

EBlastProgramType

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

void ** _PSIAllocateMatrix(unsigned int ncols, unsigned int nrows, unsigned int data_type_sz)

Generic 2 dimensional matrix allocator.

void ** _PSIDeallocateMatrix(void **matrix, unsigned int ncols)

Generic 2 dimensional matrix deallocator.

Private interface for Position Iterated BLAST API, contains the PSSM generation engine.

static Int4 pam30_prefs[11]

Quality values for PAM30 matrix, each element corresponds to same element number in array pam30_value...

static Int4 prot_identity_prefs[2]

static Int2 BlastScoreBlkProteinMatrixRead(BlastScoreBlk *sbp, FILE *fp)

Read in the matrix from the FILE *fp.

static Blast_ResComp * BlastResCompDestruct(Blast_ResComp *rcp)

Deallocates Blast_ResComp structure and associated arrays.

BlastScoreBlk * BlastScoreBlkFree(BlastScoreBlk *sbp)

Deallocates BlastScoreBlk as well as all associated structures.

static BLAST_LetterProb Robinson_prob[]

amino acid background frequencies from Robinson and Robinson

Int1 CompressedReverseLookup[BLASTAA_SIZE+1][BLASTAA_SIZE+1]

2-D array mapping compressed letters to sets of ordinary protein letters

#define BLOSUM45_VALUES_MAX

Number of different combinations supported for BLOSUM45.

static Blast_GumbelBlk * s_BlastGumbelBlkNew()

static Int4 blosum45_prefs[14]

Quality values for BLOSUM45 matrix, each element corresponds to same element number in array blosum45...

Int2 BLAST_GetProteinGapExistenceExtendParams(const char *matrixName, Int4 *gap_existence, Int4 *gap_extension)

Extract the recommended gap existence and extension values.

double BLAST_GapDecayDivisor(double decayrate, unsigned nsegs)

Compute a divisor used to weight the evalue of a collection of "nsegs" distinct alignments.

static double s_GetUngappedBeta(Int4 reward, Int4 penalty)

Returns the beta statistical parameter value, given the nucleotide substitution scores.

static const array_of_8 blastn_values_5_4[]

Karlin-Altschul parameter values for substitution scores 5 and -4.

static double s_BlastSumP(Int4 r, double s)

Estimate the Sum P-value by calculation or interpolation, as appropriate.

#define BLAST_SCORE_RANGE_MAX

maximum allowed range of BLAST scores.

double BLAST_LargeGapSumE(Int2 num, double xsum, Int4 query_length, Int4 subject_length, Int8 searchsp_eff, double weight_divisor)

Calculates the e-value if a collection of distinct alignments with arbitrarily large gaps between the...

static array_of_8 blosum80_values[10]

Supported values (gap-existence, extension, etc.) for BLOSUM80.

double array_of_8[11]

Holds values (gap-opening, extension, etc.) for a matrix.

static const array_of_8 blastn_values_3_4[]

Karlin-Altschul parameter values for substitution scores 3 and -4.

static Int4 blosum50_prefs[16]

Quality values for BLOSUM50 matrix, each element corresponds to same element number in array blosum50...

#define PAM70_VALUES_MAX

Number of different combinations supported for PAM70.

Int2 Blast_GetNuclAlphaBeta(Int4 reward, Int4 penalty, Int4 gap_open, Int4 gap_extend, Blast_KarlinBlk *kbp, Boolean gapped_calculation, double *alpha, double *beta)

Extract the alpha and beta settings for these substitution and gap scores.

void Blast_FillResidueProbability(const Uint1 *sequence, Int4 length, double *resProb)

Given a sequence of 'length' amino acid residues, compute the probability of each residue and put tha...

#define BLOSUM90_VALUES_MAX

Number of different combinations supported for BLOSUM90.

static Int4 blosum90_prefs[8]

Quality values for BLOSUM90 matrix, each element corresponds to same element number in array blosum90...

static ListNode * BlastMatrixValuesDestruct(ListNode *vnp)

Free linked list of MatrixValues and all associated data.

struct BLAST_LetterProb BLAST_LetterProb

Records probability of letter appearing in sequence.

#define BLAST_KARLIN_LAMBDA0_DEFAULT

Initial guess for the value of Lambda in BlastKarlinLambdaNR.

static Int2 s_SplitArrayOf8(const array_of_8 *input, const array_of_8 **normal, const array_of_8 **non_affine, Boolean *split)

Splits an ArrayOf8 into two arrays of supported gap costs.

double Blast_KarlinLambdaNR(Blast_ScoreFreq *sfp, double initialLambdaGuess)

Calculates the parameter Lambda given an initial guess for its value.

Int4 ** RPSRescalePssm(double scalingFactor, Int4 rps_query_length, const Uint1 *rps_query_seq, Int4 db_seq_length, Int4 **posMatrix, BlastScoreBlk *sbp)

Rescale the PSSM, using composition-based statistics, for use with RPS BLAST.

Blast_ResFreq * Blast_ResFreqFree(Blast_ResFreq *rfp)

Deallocates Blast_ResFreq and prob0 element.

SCompressedAlphabet * SCompressedAlphabetFree(SCompressedAlphabet *alphabet)

Free a compressed alphabet and score matrix.

static Int2 BlastScoreBlkProteinMatrixLoad(BlastScoreBlk *sbp)

Sets sbp->matrix->data field using sbp->name field using the matrices in the toolkit (util/tables/raw...

char * BLAST_PrintMatrixMessage(const char *matrix_name, Boolean standard_only)

Prints a messages about the allowed matrices, BlastKarlinBlkGappedFill should return 1 before this is...

double BLAST_SmallGapSumE(Int4 starting_points, Int2 num, double xsum, Int4 query_length, Int4 subject_length, Int8 searchsp_eff, double weight_divisor)

Calculates the e-value for alignments with "small" gaps (typically under fifty residues/basepairs) fo...

static const array_of_8 blastn_values_1_2[]

Karlin-Altschul parameter values for substitution scores 1 and -2.

double BLAST_SpougeStoE(Int4 y_, Blast_KarlinBlk *kbp, Blast_GumbelBlk *gbp, Int4 m_, Int4 n_)

Calculates the Expect value based upon the Spouge's FSC method.

static MatrixInfo * MatrixInfoNew(const char *name, array_of_8 *values, Int4 *prefs, Int4 max_number)

Allocates New MatrixInfo*.

#define BLOSUM62_VALUES_MAX

Number of different combinations supported for BLOSUM62.

double BLAST_KarlinEtoP(double x)

Convert an E-value to a P-value.

Int2 BlastScoreBlkNuclMatrixCreate(BlastScoreBlk *sbp)

Fill in the matrix for blastn using the penaly and rewards The query sequence alphabet is blastna,...

Int2 Blast_KarlinBlkGappedCalc(Blast_KarlinBlk *kbp, Int4 gap_open, Int4 gap_extend, const char *matrix_name, Blast_Message **error_return)

Fills in lambda, H, and K values, as calculated by Stephen Altschul in Methods in Enzy.

static array_of_8 blosum62_values[12]

Supported values (gap-existence, extension, etc.) for BLOSUM62.

static void RPSFillScores(Int4 **matrix, Int4 matrixLength, double *queryProbArray, double *scoreArray, Blast_ScoreFreq *return_sfp, Int4 range, Int4 alphabet_size)

the routine RPSFillScores computes the probability of each score weighted by the probability of each ...

SBlastScoreMatrix * SBlastScoreMatrixFree(SBlastScoreMatrix *matrix)

Deallocates SBlastScoreMatrix structure.

static Int2 Blast_ResFreqResComp(const BlastScoreBlk *sbp, Blast_ResFreq *rfp, const Blast_ResComp *rcp)

Calculate the residue frequencies associated with the provided ResComp This function takes into accou...

#define PROT_IDENTITY_VALUES_MAX

Blast_KarlinBlk * Blast_KarlinBlkNew(void)

Callocs a Blast_KarlinBlk.

static MatrixInfo * MatrixInfoDestruct(MatrixInfo *matrix_info)

Deallocates MatrixInfo as well as name string.

Blast_KarlinBlk * Blast_KarlinBlkFree(Blast_KarlinBlk *kbp)

Deallocates the KarlinBlk.

static Int2 BlastScoreBlkMaxScoreSet(BlastScoreBlk *sbp)

Sets maximum and minimum scores on the BlastScoreBlk for a given matrix.

Int2 BLAST_ScoreSetAmbigRes(BlastScoreBlk *sbp, char ambiguous_res)

Set the ambiguous residue (e.g, 'N', 'X') in the BlastScoreBlk*.

static double BlastKarlinLtoH(Blast_ScoreFreq *sfp, double lambda)

Calculate H, the relative entropy of the p's and q's.

Int2 Blast_KarlinBlkUngappedCalc(Blast_KarlinBlk *kbp, Blast_ScoreFreq *sfp)

Computes the parameters lambda, H K for use in calculating the statistical significance of high-scori...

double BLAST_KarlinPtoE(double p)

Convert a P-value to an E-value.

static const array_of_8 blastn_values_2_7[]

Karlin-Altschul parameter values for substitution scores 2 and -7.

struct MatrixInfo MatrixInfo

Used to temporarily store matrix values for retrieval.

static const array_of_8 blastn_values_1_3[]

Karlin-Altschul parameter values for substitution scores 1 and -3.

static array_of_8 blosum90_values[8]

Supported values (gap-existence, extension, etc.) for BLOSUM90.

#define BLOSUM80_VALUES_MAX

Number of different combinations supported for BLOSUM80.

static double BlastKarlinLHtoK(Blast_ScoreFreq *sfp, double lambda, double H)

The following procedure computes K.

static Int4 pam250_prefs[16]

Quality values for PAM250 matrix, each element corresponds to same element number in array pam250_val...

Int2 Blast_ScoreBlkKbpUngappedCalc(EBlastProgramType program, BlastScoreBlk *sbp, Uint1 *query, const BlastQueryInfo *query_info, Blast_Message **blast_message)

Calculate and fill the ungapped Karlin-Altschul parameters in the BlastScoreBlk structure (fields kbp...

static const array_of_8 blastn_values_2_5[]

Karlin-Altschul parameter values for substitution scores 2 and -5.

struct SRombergCbackArgs SRombergCbackArgs

Internal data structure used by Romberg integration callbacks.

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

Calculates residues frequencies given a standard distribution.

static const array_of_8 blastn_values_3_2[]

Karlin-Altschul parameter values for substitution scores 3 and -2.

static Int2 s_BuildCompressedScoreMatrix(BlastScoreBlk *sbp, SCompressedAlphabet *new_alphabet, double matrix_scale_factor, CompressedReverseLookup rev_table)

Compute a (non-square) score matrix for a compressed alphabet.

char * BLAST_PrintAllowedValues(const char *matrix_name, Int4 gap_open, Int4 gap_extend)

Prints a messages about the allowed open etc values for the given matrix, BlastKarlinBlkGappedFill sh...

Int2 Blast_KarlinBlkGappedLoadFromTables(Blast_KarlinBlk *kbp, Int4 gap_open, Int4 gap_extend, const char *matrix_name, Boolean standard_only)

Attempts to fill KarlinBlk for given gap opening, extensions etc.

static Int2 s_AdjustGapParametersByGcd(array_of_8 *normal, array_of_8 *linear, int size, Int4 *gap_existence_max, Int4 *gap_extend_max, int divisor)

Adjust Lambda and H if reward and penalty have a non-1 gcd.

static Int4 blosum62_prefs[12]

Quality values for BLOSUM62 matrix, each element corresponds to same element number in array blosum62...

static Int2 Blast_ResFreqClr(const BlastScoreBlk *sbp, Blast_ResFreq *rfp)

Sets prob elements of Blast_ResFreq to zero.

static const array_of_8 blastn_values_1_4[]

Karlin-Altschul parameter values for substitution scores 1 and -4.

Int2 Blast_GetStdAlphabet(Uint1 alphabet_code, Uint1 *residues, Uint4 residues_size)

Fills a buffer with the 'standard' alphabet (given by STD_AMINO_ACID_FREQS[index]....

SCompressedAlphabet * SCompressedAlphabetNew(BlastScoreBlk *sbp, Int4 compressed_alphabet_size, double matrix_scale_factor)

Allocate a new compressed alphabet and score matrix.

Blast_ScoreFreq * Blast_ScoreFreqFree(Blast_ScoreFreq *sfp)

Deallocates the score frequencies structure.

static BLAST_LetterProb nt_prob[]

nucleotide probabilities (25% each letter)

static Int2 BlastResCompStr(const BlastScoreBlk *sbp, Blast_ResComp *rcp, char *str, Int4 length)

Store the composition of a (query) string.

Int2 Blast_GumbelBlkCalc(Blast_GumbelBlk *gbp, Int4 gap_open, Int4 gap_extend, const char *matrix_name, Blast_Message **error_return)

Fills in gumbel parameters to estimate p-value using FSC.

static Blast_ResComp * BlastResCompNew(const BlastScoreBlk *sbp)

Allocated the Blast_ResComp* for a given alphabet.

static const char * s_alphabet10

23-to-10 letter compressed alphabet.

static const array_of_8 blastn_values_1_5[]

Supported substitution and gap costs with corresponding quality values for nucleotide sequence compar...

static Int4 BlastKarlinEtoS_simple(double E, const Blast_KarlinBlk *kbp, Int8 searchsp)

Calculates score from expect value and search space.

#define BLAST_KARLIN_K_SUMLIMIT_DEFAULT

K_SUMLIMIT_DEFAULT == sumlimit used in BlastKarlinLHtoK()

SBlastScoreMatrix * SBlastScoreMatrixNew(size_t ncols, size_t nrows)

Allocates a new SBlastScoreMatrix structure of the specified dimensions.

static array_of_8 pam70_values[9]

Supported values (gap-existence, extension, etc.) for PAM70.

Int2 Blast_KarlinBlkNuclGappedCalc(Blast_KarlinBlk *kbp, Int4 gap_open, Int4 gap_extend, Int4 reward, Int4 penalty, Blast_KarlinBlk *kbp_ungap, Boolean *round_down, Blast_Message **error_return)

Retrieves Karlin-Altschul parameters from precomputed tables, given the substitution and gap scores.

static double s_BlastSumPCalc(int r, double s)

Evaluate the following double integral, where r = number of segments.

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.

#define STD_AMINO_ACID_FREQS

points to the standard amino acid frequencies to use.

double BLAST_KarlinStoE_simple(Int4 S, Blast_KarlinBlk *kbp, Int8 searchsp)

Calculates the Expect value based upon the search space and some Karlin-Altschul parameters.

static array_of_8 pam30_values[11]

Supported values (gap-existence, extension, etc.) for PAM30.

int BlastScoreBlkCheck(BlastScoreBlk *sbp)

Check that score blk is valid, returns zero if it is.

static Int2 Blast_ResFreqNormalize(const BlastScoreBlk *sbp, Blast_ResFreq *rfp, double norm)

Normalizes all the residue frequencies and then normalizes them to "norm".

Int2 Blast_ScoreBlkKbpIdealCalc(BlastScoreBlk *sbp)

Calculates the Karlin-Altschul parameters assuming standard residue compositions for the query and su...

static Blast_GumbelBlk * s_BlastGumbelBlkFree(Blast_GumbelBlk *gbp)

static array_of_8 blosum45_values[14]

Supported values (gap-existence, extension, etc.) for BLOSUM45.

Boolean BLAST_CheckRewardPenaltyScores(Int4 reward, Int4 penalty)

Check the validity of the reward and penalty scores.

double BLAST_UnevenGapSumE(Int4 query_start_points, Int4 subject_start_points, Int2 num, double xsum, Int4 query_length, Int4 subject_length, Int8 searchsp_eff, double weight_divisor)

Calculates the e-value of a collection multiple distinct alignments with asymmetric gaps between the ...

static double s_OuterIntegralCback(double x, void *vp)

Callback for the Romberg integration function.

void BLAST_GetAlphaBeta(const char *matrixName, double *alpha, double *beta, Boolean gapped, Int4 gap_open, Int4 gap_extend, const Blast_KarlinBlk *kbp_ungapped)

Extract the alpha and beta settings for this matrixName, and these gap open and gap extension costs.

static double RPSfindUngappedLambda(const char *matrixName)

Gets the ungapped lambda calculated for the matrix in question given standard residue composition for...

Blast_ScoreFreq * Blast_ScoreFreqNew(Int4 score_min, Int4 score_max)

Creates a new structure to keep track of score frequencies for a scoring system.

Int2 BLAST_Cutoffs(Int4 *S, double *E, Blast_KarlinBlk *kbp, Int8 searchsp, Boolean dodecay, double gap_decay_rate)

Calculate the cutoff score from the expected number of HSPs or vice versa.

static Int2 Blast_ResFreqString(const BlastScoreBlk *sbp, Blast_ResFreq *rfp, char *string, Int4 length)

Fills in residue frequences for a given sequence.

static Int2 BlastKarlinReportAllowedValues(const char *matrix_name, Blast_Message **error_return)

Fills in error_return with strings describing the allowed values.

static Int2 BlastScoreBlkNucleotideMatrixRead(BlastScoreBlk *sbp, FILE *fp)

Read in a custom nucleotide matrix from the FILE *fp.

static const array_of_8 blastn_values_2_3[]

Karlin-Altschul parameter values for substitution scores 2 and -3.

static double NlmKarlinLambdaNR(double *probs, Int4 d, Int4 low, Int4 high, double lambda0, double tolx, Int4 itmax, Int4 maxNewton, Int4 *itn)

Find positive solution to.

static void s_BuildCompressedTranslation(const char *trans_string, Uint1 *table, Int4 compressed_alphabet_size, CompressedReverseLookup rev_table)

parse the string defining the conversion between the ordinary protein alphabet and a compressed alpha...

SPsiBlastScoreMatrix * SPsiBlastScoreMatrixNew(size_t ncols)

Allocates a new SPsiBlastScoreMatrix structure of dimensions ncols by BLASTAA_SIZE.

Int2 Blast_KarlinBlkCopy(Blast_KarlinBlk *kbp_to, Blast_KarlinBlk *kbp_from)

Copies contents of one Karlin block to another.

Int2 BLAST_GetNucleotideGapExistenceExtendParams(Int4 reward, Int4 penalty, Int4 *gap_existence, Int4 *gap_extension)

Extract the recommended gap existence and extension values.

#define PAM250_VALUES_MAX

Number of different combinations supported for PAM250.

#define BLOSUM50_VALUES_MAX

Number of different combinations supported for BLOSUM50.

#define PAM30_VALUES_MAX

Number of different combinations supported for PAM30.

#define BLAST_KARLIN_K_ITER_MAX

upper limit on iterations for BlastKarlinLHtoK

static array_of_8 blosum50_values[16]

Supported values (gap-existence, extension, etc.) for BLOSUM50.

static array_of_8 prot_idenity_values[2]

Int4 BLAST_SpougeEtoS(double e0, Blast_KarlinBlk *kbp, Blast_GumbelBlk *gbp, Int4 m, Int4 n)

Estimate the score for a specified expect value.

static Int4 blosum80_prefs[10]

Quality values for BLOSUM80 matrix, each element corresponds to same element number in array blosum80...

#define BLAST_KARLIN_LAMBDA_ITER_DEFAULT

LAMBDA_ITER_DEFAULT == no.

Int2 Blast_GumbelBlkLoadFromTables(Blast_GumbelBlk *gbp, Int4 gap_open, Int4 gap_extend, const char *matrix_name)

Attempts to fill GumbelBlk for given gap opening, extensions etc.

Int4 BLAST_ComputeLengthAdjustment(double K, double logK, double alpha_d_lambda, double beta, Int4 query_length, Int8 db_length, Int4 db_num_seqs, Int4 *length_adjustment)

Computes the adjustment to the lengths of the query and database sequences that is used to compensate...

BlastScoreBlk * BlastScoreBlkNew(Uint1 alphabet, Int4 number_of_contexts)

Allocates and initializes BlastScoreBlk.

#define BLAST_KARLIN_LAMBDA_ACCURACY_DEFAULT

LAMBDA_ACCURACY_DEFAULT == accuracy to which Lambda should be calc'd.

static ListNode * BlastLoadMatrixValues(Boolean standard_only)

Loads all the matrix values, returns a ListNode* chain that contains MatrixInfo*'s.

static Int4 pam70_prefs[9]

Quality values for PAM70 matrix, each element corresponds to same element number in array pam70_value...

static Int2 BlastScoreChk(Int4 lo, Int4 hi)

Check that the lo and hi score are within the allowed ranges.

static const array_of_8 blastn_values_1_1[]

Karlin-Altschul parameter values for substitution scores 1 and -1.

static Int2 s_GetNuclValuesArray(Int4 reward, Int4 penalty, Int4 *array_size, array_of_8 **normal, array_of_8 **non_affine, Int4 *gap_open_max, Int4 *gap_extend_max, Boolean *round_down, Blast_Message **error_return)

Returns the array of values corresponding to the given match/mismatch scores, the number of supported...

struct Blast_ResComp Blast_ResComp

Intermediate structure to store the composition of a sequence.

static const char * s_alphabet15

23-to-15 letter compressed alphabet.

static Int2 BlastScoreFreqCalc(const BlastScoreBlk *sbp, Blast_ScoreFreq *sfp, Blast_ResFreq *rfp1, Blast_ResFreq *rfp2)

Calculates the score frequencies.

static double s_InnerIntegralCback(double s, void *vp)

Callback for the Romberg integration function.

static const array_of_8 blastn_values_4_5[]

Karlin-Altschul parameter values for substitution scores 4 and -5.

static Int2 Blast_GetMatrixValues(const char *matrix, Int4 **open, Int4 **extension, double **lambda, double **K, double **H, double **alpha, double **beta, Int4 **pref_flags)

Obtains arrays of the allowed opening and extension penalties for gapped BLAST for the given matrix.

static Int2 s_GetCompressedProbs(BlastScoreBlk *sbp, double *compressed_prob, Int4 compressed_alphabet_size, CompressedReverseLookup rev_table)

Calculate conditional probability of each letter in each group.

SPsiBlastScoreMatrix * SPsiBlastScoreMatrixFree(SPsiBlastScoreMatrix *matrix)

Deallocates a SPsiBlastScoreMatrix structure.

Int2 Blast_ScoreBlkMatrixFill(BlastScoreBlk *sbp, GET_MATRIX_PATH get_path)

This function fills in the BlastScoreBlk structure.

#define BLAST_NUM_STAT_VALUES

Number of statistical parameters in each row of the precomputed tables.

static array_of_8 pam250_values[16]

Supported values (gap-existence, extension, etc.) for PAM250.

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

#define BLAST_SCORE_MIN

minimum allowed score (for one letter comparison).

char *(* GET_MATRIX_PATH)(const char *, Boolean)

callback to resolve the path to blast score matrices

#define BLAST_MATRIX_NOMINAL

Defines for the matrix 'preferences' (as specified by S.

#define BLAST_SCORE_MAX

maximum allowed score (for one letter comparison).

#define BLAST_MATRIX_BEST

This is the best value, only one per matrix.

ncbi::TMaskedQueryRegions mask

double ErfC(double z)

Complementary error function.

static bool is_valid(const char *num, int type, CONV_RESULT *cr)

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

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

static const char * str(char *buf, int n)

const Uint1 BLASTNA_TO_NCBI4NA[]

Translates between blastna and ncbi4na.

const Uint1 IUPACNA_TO_NCBI4NA[]

Translates between iupacna and ncbi4na.

#define BLASTAA_SIZE

Size of aminoacid alphabet.

#define NCBI4NA_SEQ_CODE

== Seq_code_ncbi4na

#define BLASTNA_SEQ_CODE

Identifies the blastna alphabet, for use in blast only.

#define BLASTAA_SEQ_CODE

== Seq_code_ncbistdaa

const Uint1 AMINOACID_TO_NCBISTDAA[]

Translates between ncbieaa and ncbistdaa.

#define BLASTNA_SIZE

Size of nucleic acid alphabet.

const Uint1 IUPACNA_TO_BLASTNA[]

Translates between iupacna and blastna.

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

int8_t Int1

1-byte (8-bit) signed integer

unsigned int

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

static const string kTable

<!DOCTYPE HTML >< html > n< header > n< title > PubSeq Gateway Help Page</title > n< style > n table

for(len=0;yy_str[len];++len)

SFreqRatios * _PSIMatrixFrequencyRatiosFree(SFreqRatios *freq_ratios)

Deallocate the frequency ratios structure.

SFreqRatios * _PSIMatrixFrequencyRatiosNew(const char *matrix_name)

Retrive the matrix's frequency ratios.

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

Prototypes for portable math library (ported from C Toolkit)

double BLAST_Log1p(double x)

Natural logarithm with shifted input.

long BLAST_Nint(double x)

Nearest integer.

double BLAST_Powi(double x, Int4 n)

Integral power of x.

double BLAST_Expm1(double x)

Exponentional with base e.

double BLAST_LnFactorial(double x)

Logarithm of the factorial.

double BLAST_RombergIntegrate(double(*f)(double, void *), void *fargs, double p, double q, double eps, Int4 epsit, Int4 itmin)

Romberg numerical integrator.

Int4 BLAST_Gcd(Int4 a, Int4 b)

Greatest common divisor.

double BLAST_LnGammaInt(Int4 n)

log(gamma(n)), integral n

#define DIM(A)

dimension of an array.

ListNode * ListNodeCopyStr(ListNode **head, Uint1 choice, const char *str)

Add a node to the list with a provided choice, and attached data pointing to a provided string.

#define INT4_MAX

largest nubmer represented by signed int

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.

ListNode * ListNodeAddPointer(ListNode **head, Uint1 choice, void *value)

Add a node to the list with a given choice and data pointer.

#define INT2_MAX

largest number represented by signed (two byte) short

ListNode * ListNodeFreeData(ListNode *vnp)

Free nodes as well as data (vnp->ptr) assuming it is one contiguous chunk.

ListNode * ListNodeFree(ListNode *vnp)

Free all list's nodes, does not attempt to free data.

#define NULLB

terminating byte of a char* string.

#define ASSERT

macro for assert.

#define INT4_MIN

Smallest (most negative) number represented by signed int.

#define MAX(a, b)

returns larger of a and b.

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

double lambda(size_t dimMatrix_, const Int4 *const *scoreMatrix_, const double *q_)

void split(std::vector< std::string > *strVec, const std::string &str_, const std::string &split_)

const SNCBIPackedScoreMatrix * NCBISM_GetStandardMatrix(const char *name)

TNCBIScore NCBISM_GetScore(const SNCBIPackedScoreMatrix *sm, int aa1, int aa2)

Look up an entry in a packed score matrix.

static const sljit_gpr r1

static const sljit_gpr r2

Records probability of letter appearing in sequence.

double p

probability of residue.

The context related information.

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.

The query related information.

Int4 first_context

Index of the first element of the context array.

BlastContextInfo * contexts

Information per context.

Structure used for scoring calculations.

Boolean protein_alphabet

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

Blast_KarlinBlk ** kbp

Karlin-Altschul parameters.

Blast_KarlinBlk ** kbp_psi

K-A parameters for position-based alignments.

Blast_ScoreFreq ** sfp

score frequencies for scoring matrix.

double scale_factor

multiplier for all cutoff and dropoff scores

Int2 ambig_occupy

How many occupied?

Blast_KarlinBlk ** kbp_gap

K-A parameters for gapped alignments.

Int2 ambig_size

size of array above.

char * name

name of scoring matrix.

SPsiBlastScoreMatrix * psi_matrix

PSSM and associated data.

Int2 alphabet_start

numerical value of 1st letter.

Int2 alphabet_size

size of alphabet.

Uint1 alphabet_code

NCBI alphabet code.

Int4 penalty

penalty for mismatch in blastn.

Uint1 * ambiguous_res

Array of ambiguous res.

Int4 number_of_contexts

Used by sfp and kbp, how large are these.

Boolean read_in_matrix

If TRUE, matrix is read in, otherwise produce one from penalty and reward above.

SBlastScoreMatrix * matrix

scoring matrix data

ListNode * comments

Comments about scoring matrix.

Blast_KarlinBlk * kbp_ideal

Ideal values (for query with average database composition).

Blast_KarlinBlk ** kbp_gap_std

K-A parameters for std (not position-based) alignments.

Blast_KarlinBlk ** kbp_std

K-A parameters for ungapped alignments.

Int4 reward

reward for match in blastn.

Blast_KarlinBlk ** kbp_gap_psi

K-A parameters for psi alignments.

Blast_GumbelBlk * gbp

Gumbel parameters for FSC.

Structure to hold the Gumbel parameters (for FSC).

Boolean filled

flag indicate the values of gbp are prepared

double Tau

2*G*(alpha_un - Sigma)

double Alpha_un

Ungapped alpha.

double Sigma

cov(L) = sigma y + tau

double a

avg(L) = a y + b

double G

G is the total penalty for extension.

double Beta

2*G*(alpha_un - alpha)

Int8 db_length

total length of database

double Lambda

the unscaled Lambda value

double Alpha

var(L) = alpha y + beta

Structure to hold the Karlin-Altschul parameters.

double paramC

for use in seed.

double K

K value used in statistics.

double Lambda

Lambda value used in statistics.

double H

H value used in statistics.

double logK

natural log of K value used in statistics

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

Intermediate structure to store the composition of a sequence.

Int4 * comp

store composition of a string.

Int4 * comp0

Same array as above, starts at zero.

Uint1 alphabet_code

indicates alphabet.

Stores the letter frequency of a sequence or database.

Uint1 alphabet_code

indicates alphabet.

double * prob0

probs, zero offset.

double * prob

letter probs, (possible) non-zero offset.

Holds score frequencies used in calculation of Karlin-Altschul parameters for an ungapped search.

double * sprob0

arrays for frequency of given score

double score_avg

average score, must be negative for local alignment.

Int4 score_max

highest allowed scores

Int4 obs_min

lowest observed (actual) scores

double * sprob

arrays for frequency of given score, shifted down by score_min.

Int4 score_min

lowest allowed scores

Int4 obs_max

highest observed (actual) scores

A generic linked list node structure.

struct ListNode * next

next in linked list

Used to temporarily store matrix values for retrieval.

Int4 * prefs

Preferences for display.

Int4 max_number_values

number of values (e.g., BLOSUM90_VALUES_MAX).

char * name

name of matrix (e.g., BLOSUM90).

array_of_8 * values

The values (gap-opening, extension etc.).

Scoring matrix used in BLAST.

size_t nrows

number of rows

double lambda

derived value of the matrix lambda -RMH-

double * freqs

array of assumed matrix background frequencies -RMH-

size_t ncols

number of columns

int ** data

actual scoring matrix data, stored in row-major form

Scoring matrix data used for compressed protein alphabets.

Uint1 * compress_table

translation table (AA->compressed)

Int4 compressed_alphabet_size

letters in the compressed alphabet

SBlastScoreMatrix * matrix

score matrix

Stores the frequency ratios along with their bit scale factor.

double ** data

The actual frequency ratios.

Scoring matrix data used in PSI-BLAST.

SBlastScoreMatrix * pssm

position-specific score matrix

double ** freq_ratios

PSSM's frequency ratios, dimensions are specified in pssm data above.

Blast_KarlinBlk * kbp

Karlin-Altschul block associated with this PSSM.

Internal data structure used by Romberg integration callbacks.

double adj1

Nat log of r**(r-2)/((r-1)! (r-2)!)

int num_hsps

number of HSPs

double sdvir

score divided by number of HSPs.

int num_hsps_minus_2

number of HSPs minus 2

double epsilon

convergence criteria for Romberg integration.

int g(Seg_Gsm *spe, Seq_Mtf *psm, Thd_Gsm *tdg)

static CS_CONTEXT * context

static Uint4 letter(char c)

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