validparameter.cpp

   1 /*
   2  *  validparameter.cpp
   3  *  Dotur
   4  *
   5  *  Created by Sarah Westcott on 1/5/09.
   6  *  Copyright 2009 Schloss Lab UMASS Amherst. All rights reserved.
   7  *
   8  */
   9
  10 #include "validparameter.h"
  11
  12 /***********************************************************************/
  13
  14 ValidParameters::ValidParameters() {
  15         try {
  16                 initParameterRanges();
  17         }
  18         catch(exception& e) {
  19                 errorOut(e, "ValidParameters", "ValidParameters");
  20                 exit(1);
  21         }
  22 }
  23
  24 /***********************************************************************/
  25
  26 ValidParameters::~ValidParameters() {}
  27
  28 /***********************************************************************/
  29 bool ValidParameters::isValidParameter(string parameter, vector<string> cParams, string value) {
  30         try {
  31                 bool valid = false;
  32                 //vector<string> cParams = commandParameters[command];
  33                 int numParams = cParams.size();
  34                 for(int i = 0; i < numParams; i++) {
  35                         if(cParams.at(i).compare(parameter) == 0) {
  36                                 valid = true;
  37                                 i = numParams;
  38                         }
  39                 }
  40                 if(!valid) {
  41                         mothurOut(parameter + " is not a valid parameter."); mothurOutEndLine();
  42                         mothurOut("The valid parameters are: ");
  43                         for(int i = 0; i < numParams-1; i++)
  44                                 mothurOut(cParams.at(i) + ", ");
  45                         mothurOut("and " + cParams.at(numParams-1) + ".\n");
  46                         return false;
  47                 }
  48
  49                 if(parameterRanges.count(parameter) != 1)
  50                         return true;
  51
  52                 int pVal;
  53                 double piSentinel = 3.14159;
  54                 vector<string> range = parameterRanges[parameter];
  55
  56                 vector<string> values;
  57                 splitAtDash(value, values);
  58
  59                 for(int i = 0; i < values.size(); i++) {
  60                         value = values.at(i);
  61                         valid = convertTest(value, pVal);
  62
  63                         if(!valid)
  64                                 return false;
  65
  66
  67
  68                         /********************************************************************************************************
  69                                    Special Cases
  70                         *********************************************************************************************************/
  71
  72                         if(parameter.compare("precision") == 0) {
  73                                 double logNum = log10((double)pVal);
  74                                 double diff = (double)((int)logNum - logNum);
  75                                 if(diff != 0) {
  76                                         mothurOut("The precision parameter can only take powers of 10 as a value (e.g. 10,1000,1000, etc.)\n");
  77                                         return false;
  78                                 }
  79                         }
  80
  81                         /************************************************************************************************************/
  82
  83
  84
  85                         double a,b,c,d,e;
  86
  87                         if(range.at(1).compare("NA") == 0)
  88                                 a = piSentinel;
  89                         else
  90                                 a = atoi(range.at(1).c_str());
  91
  92                         if(range.at(3).compare("NA") == 0)
  93                                 b = piSentinel;
  94                         else
  95                                 b = atoi(range.at(3).c_str());
  96
  97                         if(range.at(4).compare("between") == 0)
  98                                 c = 0;
  99                         else if(range.at(4).compare("only") == 0)
 100                                 c = 1;
 101                         else {
 102                                 mothurOut("The range can only be 'between' or 'only' the bounding numbers.\n");
 103                                 return false;
 104                         }
 105
 106                         if(range.at(0).compare(">") == 0)
 107                                 d = 0;
 108                         else if(range.at(0).compare(">=") == 0 || range[3].compare("=>") == 0)
 109                                 d = 1;
 110                         else {
 111                                 mothurOut("The parameter value can only be '>', '>=', or '=>' the lower bounding number.\n");
 112                                 return false;
 113                         }
 114
 115                         if(range.at(2).compare("<") == 0)
 116                                 e = 0;
 117                         else if(range.at(2).compare("<=") == 0 || range[4].compare("=<") == 0)
 118                                 e = 1;
 119                         else {
 120                                 mothurOut("The parameter value can only be '<', '<=', or '=<' the upper bounding number.\n");
 121                                 return false;
 122                         }
 123
 124                         bool a0 = pVal > a;
 125                         bool a1 = pVal >= a;
 126                         bool b0 = pVal < b;
 127                         bool b1 = pVal <= b;
 128
 129                         if(c != 1) {
 130                                 if(a != piSentinel && b == piSentinel) {
 131                                         if(d == 0)
 132                                                 valid = a0;
 133                                         else
 134                                                 valid = a1;
 135                                 }
 136                                 else if(a == piSentinel && b != piSentinel) {
 137                                         if(e == 0)
 138                                                 valid = b0;
 139                                         else
 140                                                 valid = b1;
 141                                 }
 142                                 else {
 143                                         if(d == 0 && e == 0)
 144                                                 valid = (a0 && b0);
 145                                         else if(d == 0 && e == 1)
 146                                                 valid = (a0 && b1);
 147                                         else if(d == 1 && e == 0)
 148                                                 valid = (a1 && b0);
 149                                         else
 150                                                 valid = (a1 && b1);
 151                                 }
 152                         }
 153                         else {
 154                                 if(a != piSentinel && b == piSentinel)
 155                                         valid = (pVal == a);
 156                                 else if(a == piSentinel && b != piSentinel)
 157                                         valid = (pVal == b);
 158                                 else
 159                                         valid = (pVal == a || pVal == b);
 160                         }
 161
 162
 163                         if(!valid) {
 164                                 mothurOut("The '" + parameter + "' parameter needs to be ");
 165                                 if(c == 1)
 166                                         mothurOut("either '" + toString(a) + "' or '" + toString(b) + "'.\n");
 167                                 else {
 168                                         if(a != piSentinel) {
 169                                                 mothurOut(">");
 170                                                 if(d != 0)
 171                                                         mothurOut("=");
 172                                                 mothurOut(" '" + toString(a) + "'");
 173                                         }
 174                                         if(b == piSentinel)
 175                                                 mothurOut( "'.\n");
 176                                         else if(a != piSentinel)
 177                                                 mothurOut(" and ");
 178                                         if(b != piSentinel) {
 179                                                 mothurOut("<");
 180                                                 if(e != 0)
 181                                                         mothurOut("=");
 182                                                 mothurOut(" '" + toString(b) + "'.\n");
 183                                         }
 184                                 }
 185                                 return false;
 186                         }
 187                 }
 188                 return true;
 189         }
 190         catch(exception& e) {
 191                 errorOut(e, "ValidParameters", "isValidParameters");
 192                 exit(1);
 193         }
 194 }
 195 /*******************************************************/
 196
 197 /******************************************************/
 198
 199 string ValidParameters::validFile(map<string, string> container, string parameter, bool isFile) {
 200         try {
 201                 int ableToOpen;
 202                 ifstream in;
 203                 map<string, string>::iterator it;
 204
 205                 it = container.find(parameter);
 206                 if(it != container.end()){ //no parameter given
 207
 208                         if(isFile == true) {
 209
 210                                 ableToOpen = openInputFile(it->second, in);
 211
 212                                 if (ableToOpen == 1) { return "not open"; }
 213                                 in.close();
 214                         }
 215                 }else { return "not found"; }
 216
 217                 return it->second;
 218
 219         }
 220         catch(exception& e) {
 221                 errorOut(e, "ValidParameters", "validFile");
 222                 exit(1);
 223         }
 224 }
 225
 226 /***********************************************************************/
 227
 228 /***********************************************************************/
 229 void ValidParameters::initParameterRanges() {
 230         try {
 231                 int rangeSize = 5;
 232
 233                 /**************************************************************************************************************
 234                         {">=" or "=>" or ">" if the value should be greater than or equal to or just greater than the lower bound,
 235                     A number representing the lower bound ("NA" if there is no lower bound),
 236                    "<=" or "=<" or "<" if the value shoud be less than or equal to or just less than the upper bound,
 237                     A number representing the upper bound ("NA" if there is no lower bound),
 238                    "between" if between lower and upper bounds or "only" if exactly one of the bounds};
 239
 240                    # = parameter
 241                    # (>, >=) lower bound, # (<, <=) upperbound, # should be (between, only) lower and upper bounds.
 242                    ***********************************************************************************************************/
 243
 244                 string precisionArray[] = {">=","10", "<","NA", "between"};
 245                 parameterRanges["precision"] = addParameters(precisionArray, rangeSize);
 246
 247                 string itersArray[] = {">=","10", "<","NA", "between"};
 248                 parameterRanges["iters"] = addParameters(itersArray, rangeSize);
 249
 250                 string freqArray[] = {">=","1", "<","NA", "between"};
 251                 parameterRanges["freq"] = addParameters(freqArray, rangeSize);
 252
 253                 //string lineArray[] = {">=","1", "<","NA", "between"};
 254                 //parameterRanges["line"] = addParameters(lineArray, rangeSize);
 255
 256                 string abundArray[] = {">=","5", "<","NA", "between"};
 257                 parameterRanges["abund"] = addParameters(abundArray, rangeSize);
 258
 259                 string softArray[] = {">=","0", "<=","100", "between"};
 260                 parameterRanges["soft"] = addParameters(softArray, rangeSize);
 261
 262                 string sizeArray[] = {">=","1", "<","NA", "between"};
 263                 parameterRanges["size"] = addParameters(sizeArray, rangeSize);
 264         }
 265         catch(exception& e) {
 266                 errorOut(e, "ValidParameters", "initParameterRanges");
 267                 exit(1);
 268         }
 269 }
 270
 271 /***********************************************************************/
 272
 273 /***********************************************************************/
 274 vector<string> ValidParameters::addParameters(string parameters[], int size) {
 275         try {
 276                 vector<string> pVector (parameters, parameters+size);
 277                 return pVector;
 278         }
 279         catch(exception& e) {
 280                 errorOut(e, "ValidParameters", "addParameters");
 281                 exit(1);
 282         }
 283 }
 284