← Back to branch summary

~ubuntu-branches/ubuntu/edgy/ncbi-tools6/edgy

« back to all changes in this revision

Viewing changes to algo/blast/core/blast_options.c

  • Committer: Bazaar Package Importer
  • Author(s): Barry deFreese
  • Date: 2006-07-19 23:28:07 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20060719232807-et3cdmcjgmnyleyx
Tags: 6.1.20060507-3ubuntu1
Re-merge with Debian

Show diffs side-by-side

added added

removed removed

Lines of Context:
algo/blast/core/blast_options.c
1
 
/* $Id: blast_options.c,v 1.175 2005/11/16 14:27:03 madden Exp $
 
1
/* $Id: blast_options.c,v 1.183 2006/04/25 16:06:53 camacho Exp $
2
2
 * ===========================================================================
3
3
 *
4
4
 *                            PUBLIC DOMAIN NOTICE
34
34
 
35
35
#ifndef SKIP_DOXYGEN_PROCESSING
36
36
static char const rcsid[] = 
37
 
    "$Id: blast_options.c,v 1.175 2005/11/16 14:27:03 madden Exp $";
 
37
    "$Id: blast_options.c,v 1.183 2006/04/25 16:06:53 camacho Exp $";
38
38
#endif /* SKIP_DOXYGEN_PROCESSING */
39
39
 
40
40
#include <algo/blast/core/blast_options.h>
41
41
#include <algo/blast/core/blast_filter.h>
42
42
 
43
 
const int kUngappedHSPNumMax = 400;
 
43
const int kUngappedHSPNumMax = 400;  /**< Suggested max. number of HSPs for an ungapped search. */
 
44
 
44
45
const double kPSSM_NoImpalaScaling = 1.0;
45
46
 
46
47
SDustOptions* SDustOptionsFree(SDustOptions* dust_options)
173
174
 
174
175
       if (filter_options == NULL)
175
176
       {
176
 
           Blast_MessageWrite(blast_message, eBlastSevWarning, 2, 1, "SBlastFilterOptionsValidate: NULL filter_options");
 
177
           Blast_MessageWrite(blast_message, eBlastSevWarning, kBlastMessageNoContext, 
 
178
              "SBlastFilterOptionsValidate: NULL filter_options");
177
179
           return 1;
178
180
       }
179
181
 
182
184
           if (program_number != eBlastTypeBlastn)
183
185
           {
184
186
               if (blast_message)
185
 
                  Blast_MessageWrite(blast_message, eBlastSevWarning, 2, 1, 
 
187
                  Blast_MessageWrite(blast_message, eBlastSevError, kBlastMessageNoContext,
186
188
                   "SBlastFilterOptionsValidate: Repeat filtering only supported with blastn");
187
189
               return 1;
188
190
           }
189
 
           if (filter_options->repeatFilterOptions->database == NULL)
 
191
           if (filter_options->repeatFilterOptions->database == NULL ||
 
192
               strlen(filter_options->repeatFilterOptions->database) == 0)
190
193
           {
191
194
               if (blast_message)
192
 
                  Blast_MessageWrite(blast_message, eBlastSevWarning, 2, 1, 
 
195
                  Blast_MessageWrite(blast_message, eBlastSevError, kBlastMessageNoContext,
193
196
                   "SBlastFilterOptionsValidate: No repeat database specified for repeat filtering");
194
197
               return 1;
195
198
           }
200
203
           if (program_number != eBlastTypeBlastn)
201
204
           {
202
205
               if (blast_message)
203
 
                  Blast_MessageWrite(blast_message, eBlastSevWarning, 2, 1, 
 
206
                  Blast_MessageWrite(blast_message, eBlastSevError, kBlastMessageNoContext,
204
207
                   "SBlastFilterOptionsValidate: Dust filtering only supported with blastn");
205
208
               return 1;
206
209
           }
211
214
           if (program_number == eBlastTypeBlastn)
212
215
           {
213
216
               if (blast_message)
214
 
                  Blast_MessageWrite(blast_message, eBlastSevWarning, 2, 1, 
 
217
                  Blast_MessageWrite(blast_message, eBlastSevError, kBlastMessageNoContext,
215
218
                   "SBlastFilterOptionsValidate: SEG filtering is not supported with blastn");
216
219
               return 1;
217
220
           }
314
317
   /* Except in one special case of greedy gapped extension, we always do 
315
318
      ungapped extension. Let the special case unset this option. */
316
319
   (*options)->ungapped_extension = TRUE;
 
320
   (*options)->program_number = program;
317
321
 
318
322
   return 0;
319
323
}
324
328
   const BlastInitialWordOptions* options, 
325
329
   Blast_Message* *blast_msg)
326
330
{
327
 
   Int4 code=2;
328
 
   Int4 subcode=1;
329
331
 
330
332
   ASSERT(options);
331
333
 
335
337
       (!Blast_ProgramIsPhiBlast(program_number)) &&
336
338
       options->x_dropoff <= 0.0)
337
339
   {
338
 
      Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode,
 
340
      Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
339
341
                            "x_dropoff must be greater than zero");
340
 
         return (Int2) code;
 
342
         return (Int2) -1;
341
343
   }
342
344
   
343
345
   return 0;
405
407
        (*options)->compositionBasedStats = TRUE;
406
408
    }
407
409
 
 
410
    (*options)->program_number = program;
 
411
 
408
412
        return 0;
409
413
}
410
414
 
470
474
          options->ePrelimGapExt == eGreedyExt ||
471
475
          options->eTbackExt == eGreedyTbck)
472
476
                {
473
 
                        Int4 code=2;
474
 
                        Int4 subcode=1;
475
 
                        Blast_MessageWrite(blast_msg, eBlastSevWarning, code, subcode, 
 
477
                        Blast_MessageWrite(blast_msg, eBlastSevWarning, kBlastMessageNoContext,
476
478
                            "Greedy extension only supported for BLASTN");
477
 
                        return (Int2) code;
 
479
                        return (Int2) 2;
478
480
                }
479
481
        }
480
482
 
519
521
      (*options)->gap_extend = BLAST_GAP_EXTN_NUCL;
520
522
   }
521
523
   (*options)->decline_align = INT2_MAX;
522
 
   (*options)->gapped_calculation = TRUE;
 
524
   if (program_number != eBlastTypeTblastx) {
 
525
       (*options)->gapped_calculation = TRUE;
 
526
   }
 
527
   (*options)->program_number = program_number;
523
528
   
524
529
   return 0;
525
530
}
557
562
   if (gap_extend >= 0)
558
563
      options->gap_extend = gap_extend;
559
564
 
 
565
   options->program_number = program_number;
 
566
 
560
567
   return 0;
561
568
}
562
569
 
571
578
   if (program_number == eBlastTypeTblastx && 
572
579
              options->gapped_calculation)
573
580
   {
574
 
                Int4 code=2;
575
 
                Int4 subcode=1;
576
 
      Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
 
581
      Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
577
582
         "Gapped search is not allowed for tblastx");
578
 
                return (Int2) code;
 
583
                return (Int2) 2;
579
584
   }
580
585
 
581
586
        if (program_number == eBlastTypeBlastn ||
583
588
        {
584
589
                if (options->penalty >= 0)
585
590
                {
586
 
                        Int4 code=2;
587
 
                        Int4 subcode=1;
588
 
                        Blast_MessageWrite(blast_msg, eBlastSevWarning, code, subcode, 
 
591
                        Blast_MessageWrite(blast_msg, eBlastSevWarning, kBlastMessageNoContext,
589
592
                            "BLASTN penalty must be negative");
590
 
                        return (Int2) code;
 
593
                        return (Int2) 2;
591
594
                }
592
595
                if (options->gapped_calculation && options->gap_open > 0 && options->gap_extend == 0) 
593
596
                {
594
 
                        Int4 code=2;
595
 
                        Int4 subcode=1;
596
 
                        Blast_MessageWrite(blast_msg, eBlastSevWarning, 
597
 
                           code, subcode, 
 
597
                        Blast_MessageWrite(blast_msg, eBlastSevWarning, kBlastMessageNoContext,
598
598
                           "BLASTN gap extension penalty cannot be 0");
599
 
                        return (Int2) code;
 
599
                        return (Int2) 2;
600
600
                }
601
601
        }
602
602
        else
611
611
                        if (status == 1)
612
612
                        {
613
613
                                char* buffer;
614
 
                                Int4 code=2;
615
 
                                Int4 subcode=1;
616
614
 
617
615
                                buffer = BLAST_PrintMatrixMessage(options->matrix); 
618
 
            Blast_MessageWrite(blast_msg, eBlastSevError,
619
 
                               code, subcode, buffer);
 
616
                                Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext, buffer);
620
617
                                sfree(buffer);
621
 
                                return (Int2) code;
 
618
                                return (Int2) 2;
622
619
                                
623
620
                        }
624
621
                        else if (status == 2)
625
622
                        {
626
623
                                char* buffer;
627
 
                                Int4 code=2;
628
 
                                Int4 subcode=1;
629
624
 
630
625
                                buffer = BLAST_PrintAllowedValues(options->matrix, 
631
626
                        options->gap_open, options->gap_extend, 
632
627
                        options->decline_align); 
633
 
            Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
634
 
                               buffer);
 
628
                                Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext, buffer);
635
629
                                sfree(buffer);
636
 
                                return (Int2) code;
 
630
                                return (Int2) 2;
637
631
                        }
638
632
                    }
639
633
               }
642
636
        if (program_number != eBlastTypeBlastx && 
643
637
       program_number != eBlastTypeTblastn && options->is_ooframe)
644
638
        {
645
 
      Int4 code=2;
646
 
      Int4 subcode=1;
647
 
      Blast_MessageWrite(blast_msg, eBlastSevWarning, code, subcode, 
648
 
         "Out-of-frame only permitted for blastx and tblastn");
649
 
      return (Int2) code;
 
639
          Blast_MessageWrite(blast_msg, eBlastSevWarning, kBlastMessageNoContext,
 
640
             "Out-of-frame only permitted for blastx and tblastn");
 
641
          return (Int2) 2;
650
642
        }
651
643
 
652
644
        return 0;
791
783
       break;
792
784
   }
793
785
 
 
786
   (*options)->program_number = program_number;
 
787
 
794
788
   return 0;
795
789
}
796
790
 
797
791
Int2 
798
792
BLAST_FillLookupTableOptions(LookupTableOptions* options, 
799
 
   EBlastProgramType program_number, Boolean is_megablast, Int4 threshold,
800
 
   Int4 word_size, Boolean variable_wordsize)
 
793
   EBlastProgramType program_number, Boolean is_megablast, 
 
794
   Int4 threshold, Int4 word_size)
801
795
{
802
796
   if (!options)
803
797
      return 1;
827
821
      options->lut_type = RPS_LOOKUP_TABLE;
828
822
   if (word_size)
829
823
      options->word_size = word_size;
830
 
   if (program_number == eBlastTypeBlastn) {
831
 
      options->variable_wordsize = variable_wordsize;
832
 
   }
833
824
   return 0;
834
825
}
835
826
 
924
915
   const LookupTableOptions* options, Blast_Message* *blast_msg)
925
916
 
926
917
{
927
 
   Int4 code=2;
928
 
   Int4 subcode=1;
929
918
   const Boolean kPhiBlast = Blast_ProgramIsPhiBlast(program_number);
930
919
 
931
920
        if (options == NULL)
932
921
                return 1;
933
922
 
934
923
    if (options->phi_pattern && !kPhiBlast) {
935
 
        Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
 
924
        Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
936
925
            "PHI pattern can be specified only for blastp and blastn");
937
 
        return (Int2) code;
 
926
        return (Int2) 2;
938
927
    }
939
928
 
940
929
    /* For PHI BLAST, the subsequent word size tests are not needed. */
945
934
        (!Blast_ProgramIsRpsBlast(program_number)) &&
946
935
        options->threshold <= 0)
947
936
        {
948
 
                Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
 
937
                Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
949
938
                         "Non-zero threshold required");
950
 
                return (Int2) code;
 
939
                return (Int2) 2;
951
940
        }
952
941
 
953
942
        if (options->word_size <= 0)
954
943
        {
955
944
        if ( !Blast_ProgramIsRpsBlast(program_number)) {
956
 
            Blast_MessageWrite(blast_msg, eBlastSevError, 
957
 
                                       code, subcode, 
 
945
            Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
958
946
                                     "Word-size must be greater than zero");
959
 
            return (Int2) code;
 
947
            return (Int2) 2;
960
948
        }
961
949
        } else if (program_number == eBlastTypeBlastn && options->word_size < 4)
962
950
        {
963
 
                Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
964
 
                         "Word-size must be 4" 
965
 
                         "or greater for nucleotide comparison");
966
 
                return (Int2) code;
 
951
                Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext, 
 
952
                  "Word-size must be 4 or greater for nucleotide comparison");
 
953
                return (Int2) 2;
967
954
        } else if (program_number != eBlastTypeBlastn && options->word_size > 5)
968
955
        {
969
 
                Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
 
956
                Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
970
957
                         "Word-size must be less"
971
958
                         "than 6 for protein comparison");
972
 
                return (Int2) code;
 
959
                return (Int2) 2;
973
960
        }
974
961
 
975
 
 
976
 
        /* FIXME: is this really needed?? */
977
 
        if (options->variable_wordsize && 
978
 
          ((options->word_size % 4) != 0) ) {
979
 
         Blast_MessageWrite(blast_msg, eBlastSevWarning, code, subcode, 
980
 
                            "Word size must be divisible by 4 if only full "
981
 
                            "bytes of subject sequences are matched to query");
982
 
         return (Int2) code;
983
 
      }
984
 
 
985
962
        if (program_number != eBlastTypeBlastn && 
986
963
       options->lut_type == MB_LOOKUP_TABLE)
987
964
        {
988
 
                Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
 
965
                Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
989
966
                         "Megablast lookup table only supported with blastn");
990
 
                return (Int2) code;
 
967
                return (Int2) 2;
991
968
        }
992
969
 
993
 
   if (options->lut_type == MB_LOOKUP_TABLE && options->word_size < 12 && 
994
 
       options->mb_template_length == 0) {
995
 
      Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
996
 
                         "Word size must be 12 or greater with megablast"
997
 
                         " lookup table");
998
 
      return (Int2) code;
999
 
   }
1000
 
 
1001
970
   if (program_number == eBlastTypeBlastn && options->mb_template_length > 0) {
1002
971
      if (!s_DiscWordOptionsValidate(options->word_size,
1003
972
              options->mb_template_length, options->mb_template_type)) {
1004
 
         Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
 
973
         Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
1005
974
                            "Invalid discontiguous template parameters");
1006
 
         return (Int2) code;
 
975
         return (Int2) 2;
1007
976
      } else if (options->lut_type != MB_LOOKUP_TABLE) {
1008
 
         Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
 
977
         Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
1009
978
            "Invalid lookup table type for discontiguous Mega BLAST");
1010
 
         return (Int2) code;
 
979
         return (Int2) 2;
1011
980
      } 
1012
981
   }
1013
982
        return 0;
1032
1001
 
1033
1002
   (*options)->hitlist_size = BLAST_HITLIST_SIZE;
1034
1003
   (*options)->expect_value = BLAST_EXPECT_VALUE;
 
1004
   (*options)->program_number = program_number;
1035
1005
 
1036
1006
   return 0;
1037
1007
 
1040
1010
Int2
1041
1011
BLAST_FillHitSavingOptions(BlastHitSavingOptions* options, 
1042
1012
                           double evalue, Int4 hitlist_size,
1043
 
                           Boolean is_gapped, Int4 culling_limit)
 
1013
                           Boolean is_gapped, Int4 culling_limit,
 
1014
                           Int4 min_diag_separation)
1044
1015
{
1045
1016
   if (!options)
1046
1017
      return 1;
1049
1020
      options->hitlist_size = hitlist_size;
1050
1021
   if (evalue)
1051
1022
      options->expect_value = evalue;
 
1023
   if (min_diag_separation)
 
1024
      options->min_diag_separation = min_diag_separation;
1052
1025
   if(!is_gapped)
1053
1026
     options->hsp_num_max = kUngappedHSPNumMax;
1054
1027
   options->culling_limit = culling_limit;
1066
1039
 
1067
1040
        if (options->hitlist_size < 1)
1068
1041
        {
1069
 
                Int4 code=1;
1070
 
                Int4 subcode=1;
1071
 
                Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
 
1042
                Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
1072
1043
                         "No hits are being saved");
1073
 
                return (Int2) code;
 
1044
                return (Int2) 2;
1074
1045
        }
1075
1046
 
1076
1047
        if (options->expect_value <= 0.0 && options->cutoff_score <= 0)
1077
1048
        {
1078
 
                Int4 code=2;
1079
 
                Int4 subcode=1;
1080
 
                Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
 
1049
                Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
1081
1050
         "expect value or cutoff score must be greater than zero");
1082
 
                return (Int2) code;
 
1051
                return (Int2) 2;
1083
1052
        }       
1084
1053
 
1085
1054
   if (options->longest_intron != 0 && 
1086
1055
       program_number != eBlastTypeTblastn && 
1087
1056
       program_number != eBlastTypeBlastx) {
1088
 
                Int4 code=2;
1089
 
                Int4 subcode=1;
1090
 
                Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
 
1057
                Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
1091
1058
         "Uneven gap linking of HSPs is allowed for blastx and tblastn only");
1092
 
                return (Int2) code;
 
1059
                return (Int2) 2;
1093
1060
   }
1094
1061
 
1095
1062
        if (options->culling_limit < 0)
1096
1063
        {
1097
 
                Int4 code=2;
1098
 
                Int4 subcode=1;
1099
 
                Blast_MessageWrite(blast_msg, eBlastSevError, code, subcode, 
 
1064
                Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
1100
1065
                    "culling limit must be greater than or equal to zero");
1101
 
                return (Int2) code;
 
1066
                return (Int2) 2;
1102
1067
        }       
1103
1068
 
1104
1069
        return 0;
1136
1101
    }
1137
1102
 
1138
1103
    if (psi_options->pseudo_count <= 0) {
1139
 
        Blast_MessageWrite(blast_msg, eBlastSevError, 0, 0,
 
1104
        Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
1140
1105
                           "Pseudo count must be greater than 0");
1141
1106
        return retval;
1142
1107
    }
1143
1108
 
1144
1109
    if (psi_options->inclusion_ethresh <= 0.0) {
1145
 
        Blast_MessageWrite(blast_msg, eBlastSevError, 0, 0,
 
1110
        Blast_MessageWrite(blast_msg, eBlastSevError, kBlastMessageNoContext,
1146
1111
                           "Inclusion threshold must be greater than 0");
1147
1112
        return retval;
1148
1113
    }
1232
1197
 
1233
1198
}
1234
1199
 
 
1200
/**  Checks that the extension and scoring options are consistent with each other
 
1201
 * @param program_number identifies the program [in]
 
1202
 * @param ext_options the extension options [in]
 
1203
 * @param score_options the scoring options [in]
 
1204
 * @param blast_msg returns a message on errors. [in|out]
 
1205
 * @return zero on success, an error code otherwise. 
 
1206
 */
 
1207
static Int2 s_BlastExtensionScoringOptionsValidate(EBlastProgramType program_number,
 
1208
                           const BlastExtensionOptions* ext_options,
 
1209
                           const BlastScoringOptions* score_options, 
 
1210
                           Blast_Message* *blast_msg)
 
1211
{
 
1212
    if (ext_options == NULL || score_options == NULL)
 
1213
        return -1;
 
1214
 
 
1215
    if (program_number == eBlastTypeBlastn)
 
1216
    {
 
1217
        if (score_options->gap_open == 0 && score_options->gap_extend == 0)
 
1218
        {
 
1219
            if (ext_options->ePrelimGapExt != eGreedyWithTracebackExt && 
 
1220
                ext_options->ePrelimGapExt != eGreedyExt && 
 
1221
                ext_options->eTbackExt != eGreedyTbck)
 
1222
            {
 
1223
                        Blast_MessageWrite(blast_msg, eBlastSevWarning, kBlastMessageNoContext,
 
1224
                            "Greedy extension must be used if gap existence and extension options are zero");
 
1225
                        return (Int2) 2;
 
1226
            }
 
1227
        }
 
1228
    }
 
1229
 
 
1230
    return 0;
 
1231
}
 
1232
                   
 
1233
 
1235
1234
Int2 BLAST_ValidateOptions(EBlastProgramType program_number,
1236
1235
                           const BlastExtensionOptions* ext_options,
1237
1236
                           const BlastScoringOptions* score_options, 
1257
1256
   if ((status = BlastHitSavingOptionsValidate(program_number, hit_options,
1258
1257
                                               blast_msg)) != 0)
1259
1258
       return status;
 
1259
   if ((status = s_BlastExtensionScoringOptionsValidate(program_number, ext_options,
 
1260
                                               score_options, blast_msg)) != 0)
 
1261
       return status;
 
1262
 
 
1263
   
1260
1264
 
1261
1265
   return status;
1262
1266
}
1265
1269
 * ===========================================================================
1266
1270
 *
1267
1271
 * $Log: blast_options.c,v $
 
1272
 * Revision 1.183  2006/04/25 16:06:53  camacho
 
1273
 * tblastx scoring options must be set to false
 
1274
 *
 
1275
 * Revision 1.182  2006/04/20 19:28:30  madden
 
1276
 * Prototype change for Blast_MessageWrite
 
1277
 *
 
1278
 * Revision 1.181  2006/03/02 13:28:34  madden
 
1279
 * use BlastHspNumMax function, refactor how hsp_num_max is calculated
 
1280
 *
 
1281
 * Revision 1.180  2006/02/09 18:47:07  camacho
 
1282
 * Correct error reporting when there are errors in validation of filtering
 
1283
 * options.
 
1284
 *
 
1285
 * Revision 1.179  2006/01/23 16:29:51  papadopo
 
1286
 * allow the number of diagonals used in containment tests to be specified when initializing HitSavingOptions
 
1287
 *
 
1288
 * Revision 1.178  2005/12/22 14:07:48  papadopo
 
1289
 * remove variable wordsize, and change signature to BlastFillLookupTableOptions
 
1290
 *
 
1291
 * Revision 1.177  2005/12/19 16:11:12  papadopo
 
1292
 * no minimum value for megablast word size need be enforced; the engine will switch to a standard lookup table if the specified word size is too small
 
1293
 *
 
1294
 * Revision 1.176  2005/12/12 13:38:27  madden
 
1295
 * Add call to s_BlastExtensionScoringOptionsValidate to BLAST_ValidateOptions to check that scoring and extension options are consistent
 
1296
 *
1268
1297
 * Revision 1.175  2005/11/16 14:27:03  madden
1269
1298
 * Fix spelling in CRN
1270
1299
 *