params.h

/**************************************************************************
 * Copyright (c) 2002-2011 T. M. Murali                                   *
 *                                                                        *
 * This file is part of Biorithm.                                         *
 *                                                                        *
 * Biorithm is free software: you can redistribute it and/or modify       *
 * it under the terms of the GNU General Public License as published by   *
 * the Free Software Foundation, either version 3 of the License, or      *
 * (at your option) any later version.                                    *
 *                                                                        *
 * Biorithm is distributed in the hope that it will be useful,            *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 * GNU General Public License for more details.                           *
 *                                                                        *
 * You should have received a copy of the GNU General Public License      *
 * along with Biorithm.  If not, see <http://www.gnu.org/licenses/>.      *
 *                                                                        *
 **************************************************************************/

// Purpose: functions to deal with parameters that govern the clustering algorithm.

#ifndef _PARAMS_H
#define _PARAMS_H

#include <math.h>
#include <fstream>
#include <map>
#include <set>

#include "format.h"
#include "global.h"

//#include "cluster_gp.h"

// file created by gengetopt. need to include it for MyClusterParams::set(gengetopt_args_info& cl) 
//#include "cmdline.h"

// forward declaration to avoid including cmdline.h; when i compile kmeans, there is no corresponding cmdline.h for it.
class gengetopt_args_info;

enum MyDataType {aff, cog, mic};
enum MyVerbosityLevel {verbosityZero, verbosityOne, verbosityTwo, verbosityThree, verbosityFour};
const MyVerbosityLevel MY_VERBOSITY_LEVEL_TABLE[] =
{verbosityZero, verbosityOne, verbosityTwo, verbosityThree, verbosityFour};

const int MAX_VERBOSITY_LEVEL = 4;


const int MAX_LINE_LENGTH = 1024;
const int DEFAULT_NUM_SEEDS = -1;
const int DEFAULT_SIZE_DISC = -1;
const int DEFAULT_NUM_DISCS = -1;
const int DEFAULT_MAX_COUNT = -1;

// forward declarations.
class MyCluster;
class MyPointSet;
//struct MyAffyFileFormat;

// various paramaters needed when computing a cluster. it is easier to
// have a struct like this than to pass around a bunch of single
// values.
struct MyClusterParams
{
  friend class MyCluster;
  
  
public:
  MyClusterParams();
  
  // -a, --minimumSupport
  MyNT getMinimumSupport() const
    {
      return(minimumSupport);
    }
  // -A, --anneal
  bool getAnneal() const
    {
      return(anneal);
    }
  
  // --apriori
  bool getApriori() const
  {
    return(runAprioriAlgo);
  }

  // -b, --beta
  MyNT getBeta() const
    {
      return(beta);
    }
  // -c, --class
  string getClassFileName() const
    {
      return(classFile);
    }
  
  string getCommandLine() const
    {
      return(commandLine);
    }
  
  void setCommandLine(int argc, char **argv)
    {
      for (int i = 0; i < argc; i++)
        {
          commandLine += argv[i];
          commandLine += " ";
        }
    }

  // -C, --config
  string getConfigFileName() const
    {
      return(configFile);
    }
  void readConfigFile();

  // --correlation
  bool getComputeCorrelations() const
    {
      return(computeCorrelations);
    }
  MyNT getCorrelationThreshold() const
    {
      return(correlationThreshold);
    }
  
  
  // -d, --datatype
  MyDataType getDataType() const
    {
      return(dataType);
    }
  char getDelimiter() const
    {
      return(delimiter);
    }

  // have to define this function in params.C since MyAffyFileFormat
  // is incomplete here.
  MyAffyFileFormat getFileFormat(unsigned int which) const
    {
      return(fileFormats[which]);
    }



  

  // -f, --flip
  bool getFlip() const
    {
      return(flipPointsAndCoords);
    }

  // --gaussian
  bool getUseGaussian() const
    {
      return(useGaussian);
    }
  

  // -g, --greedy
  bool getGreedy() const
    {
      return(findClustersGreedily);
    }
  
  // -G, --generate
  bool getGenerateData() const
    {
      return(generateData);
    }
  
  // --genes
  string getGenesFileName() const
    {
      return(genesFile);
    }

  // --gene-id-column
  string getGeneIdColumn(unsigned int whichPointSet) const
    {
      return(geneIdColumns[whichPointSet]);
    }

  
  // --gene-name-column
  string getGeneNameColumn(unsigned int whichPointSet) const
    {
      return(geneNameColumns[whichPointSet]);
    }

  
  // -i, --input
  string getInputFileName(int index = 0) const
    {
      return(inputFiles[index]);
         //      return(inputFile);
    }

  // -I, --itemsets
  bool getComputeItemsets(unsigned int which = 0) const
  {
    //    return(computeItemsets[which]);
    return((0 != computeItemsets[which]));
  
  }
  
  int getNumLimitSets() const
    {
         return(limitFiles.size());
    }
  
  // -l, --limit
  string getLimitFileName(unsigned int which = 0) const
  {
    return(limitFiles[which]);
  }

  
  // --lb
  MyNT getLowerBoundForFiltering() const
    {
      return(lowerBound);
    }
  bool getLowerBoundGiven() const
    {
      return(lowerBoundGiven);
    }
  
  
  // --log
  bool getUseLogarithm() const
    {
      return(useLogarithm);
    }
  

  // -m, --memory
  bool getSaveMemory() const
    {
      return(saveMemory);
    }

  // --mc
  int getMaxCount() const
    {
      return(maxCount);
      
    }
  void setMaxCount(int m)
    {
      maxCount = m;
    }

  // --max-down-regulated
  MyNT getMaximumDownRegulated() const
  {
    return(maxDownRegulatedValue);
  }
  bool maximumDownRegulatedGiven() const
    {
      return(maxDownRegulatedGiven);
    }
  
  // --min-up-regulated
  MyNT getMinimumUpRegulated() const
  {
    return(minUpRegulatedValue);
  }
  bool minimumUpRegulatedGiven() const
    {
      return(minUpRegulatedGiven);
    }
  
  
  // --min
  bool getMinimiseClusterSize() const
    {
      return(minimiseClusterSize);
    }
  
  // --mq
  MyNT getMinimumHomogeneity() const
    {
      return(minimumClusterHomogeneity);
    }
  void setMinimumHomogeneity(MyNT q)
    {
      minimumClusterHomogeneity = q;
    }
  
  
  int getNumNames() const
    {
      return(numNames);
    }

  // -n, --number
  int getNumPointsToRead() const
    {
      return(numPointsToRead);
    }
  
  // --nb
  int getNumBestClusters() const
    {
      return(numBestClusters);
    }

  // --nc
  int getNumClustersToCompute() const
    {
      return(numClusters);
    }

  // --nd
  int getNumDiscs(unsigned int index  = 0) const
    {
      return(numDiscs[index]);
    }
  
  unsigned int getNumPointSets() const
    {
         unsigned int retval;
         // some weird bug make numPointSets zero.
         retval = numPointSets;
         retval = inputFiles.size();
         cout << "\tMyClusterParams::getNumPointSets(): Returning " 
                 << retval << endl;
         // some weird bug make this number zero.
         //      return(numPointSets);
         return(retval);
    }
  
  // --ns
  int getNumSeeds(unsigned int index = 0) const
    {
      return(numSeeds[index]);
    }

  // -o, --output
  string getOutputFileName() const
    {
      return(outputFile);
    }

  // --oi 
  string getOutputInternalValuesFileName() const
    {
      return(outputInternalValuesFile);
    }
  
  
  // -p, --partition
  // badly named function.
  bool getPartition() const
    {
      return(partitionPoints);
    }

  // --pc
  int getMaxPointCount() const
    {
      return(maxPointCount);
    }
  
  // --pv
  MyNT getMaxPValue() const
    {
      return(maxPValue);
    }
  
  // -r, --repeat
  string getRepeatFileName() const
    {
      return(repeatFile);
    }

  // --rf
  string getWidthRangeFileName() const
    {
      return(widthRangeFile);
    }

  // --row-name-column
  string getRowNameColumn() const
    {
      return(rowNameColumn);
    }
  
  
  // -s, --siginificant
  bool getUseSignificantIntervals(unsigned int which = 0) const
    {
      return(useSignificantIntervals[which]);
    }
  void setUseSignificantIntervals(unsigned int which = 0, bool val = true)
  {
      useSignificantIntervals[which] = val;
    }
  

  // -S, --statistics.
  bool getComputeStatistics() const
    {
      return(computeStatistics);
    }
  


  // not really related to --sd option but still putting these
  // functions according to the minimumSupportbetical order of command-line
  // options.
  int getSizeDisc(unsigned int index = 0) const
    {
      return(sizeDiscs[index]);
         //      return(sizeDisc);
    }

  void setSizeDisc(int sd, unsigned int index = 0)
    {
         sizeDiscs[index] = sd;
         //      sizeDisc = sd;
    }
  
  // --st
  MyNT getSimilarityThreshold() const
    {
      return(clusterSimilarityThreshold);
    }
  
  // --shamir
  bool getShamir() const
    {
      return(runShamirAlgo);
    }
  
  void set(gengetopt_args_info &cl, unsigned int whichPointSet = 0,
                 // if this arg is true, then i have already called set()
                 // before so i need not expect all the variables i expect
                 // the first time.
                 bool update = false);


  // --uniform
  bool getUseUniform() const
    {
      return(useUniform);
    }
  
  // --ub
  MyNT getUpperBoundForFiltering() const
    {
      return(upperBound);
    }
  bool getUpperBoundGiven() const
    {
      return(upperBoundGiven);
    }

  // -v, --verbose
  MyVerbosityLevel getVerbosity() const
    {
      return(verbose);
    }

  // -w, --width
  MyNT getWidth() const
    {
      return(width);
    }

  // --wf
  string getWidthFileName() const
    {
      return(widthFile);
    }
  

  void print(ostream& ostr) const;

  // set those params that depend on the number of points.
  void set(int numPoints, int numDimensions, unsigned int index = 0)
    {
      setNumSeeds(numPoints, numDimensions, index);
      // set sizeDisc before setting numDiscs.
      setSizeDisc(numPoints, numDimensions, index);
      setNumDiscs(numPoints, numDimensions, index);
      // set maxCount. this way, i don't have to remember to set the
      // max count in the command line when i want it to be the number
      // of points.  
      if (DEFAULT_MAX_COUNT == maxCount)
        maxCount = numPoints;
      
    }


private:
  void setDataType(const string& type)
    {
      if (("a" == type) || ("aff" == type) || ("affy" == type) || ("affymetrix" == type))
        {
          dataType = aff;
          delimiter = '\t';
          numNames = 2;
        }
      else if (("c" == type) || ("cog" == type))
        {
          dataType = cog;
          delimiter = ' ';
        }
      else if (("m" == type) || ("mic" == type) || ("microarray" == type))
        {
          dataType = mic;
          delimiter = ' ';
          numNames = 1;
        }
      else
        cerr << "ERROR! Unknown data type " << type << ". Exiting.\n";
    }
  
  void setNumSeeds(unsigned int numPoints, 
                            unsigned int numDimensions, unsigned int index = 0)
    {
      // i can generate at most numPoints seeds.
      if (numSeeds[index] > numPoints)
        numSeeds[index] = numPoints;
    }
  
  void setSizeDisc(unsigned int numPoints, unsigned int numDimensions, 
                            unsigned int index = 0)
    {
      if (DEFAULT_SIZE_DISC == sizeDiscs[index])
        // sizeDisc has not been changed on the command line.
        //
        // $\log (d/(1 probDisc)) /\log (1/(2 \beta))$
        sizeDiscs[index] = static_cast<int>(10*log(numDimensions/(1 - probDisc))/log(1/(2*beta)));
      if (sizeDiscs[index] > numPoints)
        // the number of points in the discriminant should not be
        // greater than the number of points! but setting it equal to
        // #points seems wrong since i will never find a cluster. i am
        // hacking the problem away by setting sizeDisc to half the
        // number of points.
        sizeDiscs[index] = numPoints/2;
    }
  
  void setNumDiscs(unsigned int numPoints, unsigned int numDimensions, 
                            unsigned int index)
    {
      if (DEFAULT_NUM_DISCS == numDiscs[index])
        // numDiscs has not been changed on the command line.
        //
        // $\log (1 - probCluster) / \log (1 - \minimumSupport^{sizeDisc})$. the
        // formula is the same as that for numSeeds, except that \minimumSupport
        // is replaced by \minimumSupport^{sizeDisc}.
        numDiscs[index] = static_cast<int>(log(1 - probCluster)/log(1 - pow((double)minimumSupport, sizeDiscs[index]/10.0)));
    }

  void processRepeatFile(ifstream& rstr, int& localArgc, char **&localArgv);
  
private:

  // data members

  // -a, --minimumSupport
  MyNT minimumSupport;
  // -A, --anneal
  bool anneal;

  // --apriori
  bool runAprioriAlgo;

  // -b, --beta
  MyNT beta;

  // -c, --class
  string classFile;
  
  string commandLine;

  // -C, --config
  string configFile;
  map< string, string > configInfo;
  
  // --correlations
  bool computeCorrelations;
  MyNT correlationThreshold;
  

  // -d, --datatype
  MyDataType dataType;

  // delimiter that separates fields.
  char delimiter;

  // file formats for each file to read.
  vector< MyAffyFileFormat > fileFormats;
  
  // -f, --flip
  bool flipPointsAndCoords;

  // --gaussian
  bool useGaussian;
  
  // -g, --greedy
  bool findClustersGreedily;
  
  // -G, --generate
  bool generateData;
  
  // --genes
  string genesFile;

  // --gene-id-column
  //  string geneIdColumn;
  vector< string > geneIdColumns;

  // --gene-name-column
  //  string geneNameColumn;
  vector< string > geneNameColumns;
  
  // -i, --input
  // file to read input from.
  string inputFile;
  vector< string > inputFiles;

  // -I, --itemset
  //  bool computeItemsets;
  //   vector< bool > computeItemsets;
   vector< unsigned int > computeItemsets;

  // --ignore-column-name
  // names of columns to ignore.
  //
  // set does not compile for some reason!!! "set is used as a type
  // but not defined as a type." what is going on? 
  // set< string, ltstr > ignoredColumns;
  map< string, bool > ignoredColumns;

  // --ignore-row-name
  // names of rows to ignore.
  //  set< string, ltstr > ignoredRows;
  map< string, bool > ignoredRows;


  // -l, --limit
  vector< string > limitFiles;
  
  // --lb
  MyNT lowerBound;
  bool lowerBoundGiven;
  
  // --log
  bool useLogarithm;
  
  // -m, --memory
  bool saveMemory;

  // --mc
  int maxCount;

  // --min
  bool minimiseClusterSize;
  
  // --max-down-regulated
  MyNT maxDownRegulatedValue;
  bool maxDownRegulatedGiven;
  
  // --min-up-regulated
  MyNT minUpRegulatedValue;
  bool minUpRegulatedGiven;
  
  // --mq
  MyNT minimumClusterHomogeneity;
  
  // number of names in the input file for each gene.
  int numNames;

  // -n, --number
  int numPointsToRead;

  // --nb. return the numBestClusters computed clusters. the idea is
  // not just to return one cluster per round but to store the
  // numBestClusters over all rounds.
  int numBestClusters;
  
  // --nc
  int numClusters;
  // --nd
  //  int numDiscs;
  vector< unsigned int > numDiscs;

  // this parameter is not set by any command-line parameter. i will
  // use the number of -i and --sd options to set it.
  unsigned int numPointSets;

  // --ns
  //  int numSeeds;
  vector< unsigned int > numSeeds;

  // -o, --output
  string outputFile;

  // --oi
  // if true, output internal values of the experiment, usually for a subsequent run.
  bool outputInternalValues;
  string outputInternalValuesFile;
  
  // -p, --partition
  bool partitionPoints;

  // --pc, the maximum number of clusters that a point can appear in.
  // usually used with the -p option so that i don't partition points
  // between clusters. when i don't use the -p option, i set this
  // variable to be 1. the default value is -1, which means a point
  // can appear in as many clusters as it wants.
  int maxPointCount;
  
  // -pc
  // probability that a random sample is in the cluster.
  MyNT probCluster;
  // --pd
  // probability that a random sample of size sizeDisc is a discriminant.
  MyNT probDisc;
  // --ps
  // probability that a random point is a good seed (in the cluster).
  MyNT probSeed;
  
  // --pv
  MyNT maxPValue;
  
  // -r, --repeat
  // if true, repeat a previous experiment from parameters stored in given file.
  bool repeatExperiment;
  string repeatFile;

  // --rf
  // the name of the file containing widths corresponding to significant intervals. 
  string widthRangeFile;

  // --row-name-column
  string rowNameColumn;
  

  // -s, --siginificant. if
  // useSignificantIntervals is 0, then i don't have to compare
  // cluster with siginificant intervals at all. if
  // useSignificantIntervals is 1, then i require that the cluster's
  // bounded intervals be completely inside significant intervals.
  //  bool useSignificantIntervals;
  vector< unsigned int > useSignificantIntervals;
  
  // -S, --statistics
  bool computeStatistics;
  
  
  // --sd
  //  int sizeDisc;
  vector< unsigned int > sizeDiscs;

  // --shamir.
  bool runShamirAlgo;
  
  // --st. threshold beyond which two clusters are similar. used with
  // the --nb option.
  MyNT clusterSimilarityThreshold;

  // --ub
  MyNT upperBound;
  bool upperBoundGiven;
  
  
  // --uniform
  bool useUniform;
  
  // -v, --verbose
  MyVerbosityLevel verbose;
  
  // -w, --width
  MyNT width;
  // --wf
  string widthFile;
  
};


#endif // _PARAMS_H