interval.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: to define 1D intervals of various types

#ifndef _INTERVAL_H
#define _INTERVAL_H

#include <map>
#include <vector>

#include "global.h"
#include "binomial.h"
#include "gaussian.h"



// returns true if coord is in [low, high].
inline bool contains(MyNT low, MyNT high, MyNT coord)
{
  return((coord >= low) && (coord <= high));
}


// forward declaration.
class MyClusterParams;
class MyPointSet;

// a struct that stores information about significant intervals.
struct MyInterval
{
public:
  MyInterval()
      : start(), end(), width(), count(), pval()
    {}
  
  MyInterval(MyNT s, MyNT e)
      : start(s), end(e), width(e - s), count(), pval()
    {}
  
  MyInterval(MyNT s, MyNT e, MyNT w)
      : start(s), end(e), width(w), count(), pval()
    {}
  
  // constructor from a map. cannot use const map< > here since i use
  // map< >::operator[]. alternative is to use const and the find()
  // function at the risk of a seg fault.
  MyInterval(map< string, MyNT, ltstr >& init)
//       : start(init["START"]), end(init["END"]), width(init["WIDTH"]),
//         count(init["COUNT"]), pval(init["PVAL"])
      : start(init["start"]), end(init["end"]), width(init["width"]),
        count(init["count"]), pval(init["pval"])
    {}

  virtual ~MyInterval()
    {}
  // check if two intervals are identical. enough to check start and end.
  virtual bool operator==(const MyInterval& interval) const
    {
      // if both intervals are pointing to the same instance, they are equal. 
      if (&interval == this)
        return(true);
      if (start != interval.start)
        return(false);
      if (end != interval.end)
        return(false);
      return(true);
    }

  // check if two intervals are not identical. 
  virtual bool operator!=(const MyInterval& interval) const
    {
      return(!(*this == interval));
    }
  
  // gets and sets
  MyNT getStart() const
    {
      return(start);
    }
  void setStart(MyNT s)
    {
      start = s;
      setWidth();
    }

  MyNT getEnd() const
    {
      return(end);
    }
  void setEnd(MyNT e)
    {
      end = e;
      setWidth();
    }
  // more of an internal function to be called by setStart() and setEnd(). 
  void setWidth()
    {
      width = end - start;
    }
  
  
  virtual void print(ostream& ostr) const
    {
      ostr << "Interval is pval = " << pval << ", start = " << start
           << ", end = " << end << ", width = " << width << ", count = " << count
           << endl;
    }

  // check if *this contains in.
  virtual bool contains(const MyInterval& in) const
    {
      return(contains(in.getStart(), in.getEnd()));
    }
  
  // check if [start, end] contains p.
  virtual bool contains(MyNT p) const
    {
      return((start <= p) && (p <= end));
    }
  
  // checks if [start, end] contains [s, e]. needed for MyInterval::softContains().
  virtual bool contains(MyNT s, MyNT e) const
    {
      return((start <= s) && (e <= end));
    }

  // checks if [s, e] equals [start, end].
  virtual bool equals(MyNT s, MyNT e) const
    {
      return((start == s) && (e == end));
    }

  // checks what fraction of [s, e] is within [start, end]
  virtual MyNT softContains(MyNT s, MyNT e) const;
  
  
  MyNT start;
  MyNT end;
  MyNT width;
  MyNT count;
  double pval;
};

// an interval with its dimension
struct MyDimensionInterval : public MyInterval
{
  MyDimensionInterval()
      : MyInterval(), dimension()
    {}
  
  MyDimensionInterval(MyNT s, MyNT e, int d)
      : MyInterval(s, e), dimension(d)
    {}
  
  MyDimensionInterval(MyNT s, MyNT e, MyNT w, int d)
      : MyInterval(s, e, w), dimension(d)
    {}

  virtual ~MyDimensionInterval()
    {}

  // check if two intervals are identical. enough to check start and end.
  virtual bool operator==(const MyDimensionInterval& interval) const
    {
      // if both intervals are pointing to the same instance, they are equal. 
      if (&interval == this)
        return(true);
      if (dimension != interval.dimension)
        return(false);
      // call the parent class's operator.
      return((*this).MyInterval::operator==(interval));
    }
  
  unsigned int getDimension() const
    {
      return(dimension);
    }

  void setDimension(unsigned int d)
    {
      dimension = d;
    }

  bool isSignificant(const MyPointSet &points, const MyClusterParams &params);
  // compute the pvalue of this interval based on the assumption that
  // the points in this interval were generated by a uniform
  // distribution. not const because the function sets the count and
  // pval fields.
  double computePValueUniform(const MyPointSet &points);
  // compute the pvalue of this interval based on the assumption that
  // the points in this interval were generated by a gaussian
  // distribution. not const because the function sets the count and
  // pval fields.
  double computePValueGaussian(const MyPointSet &points);
  
  void _locate(vector< MyNT > &coords, int& middle, int& left, int& right);// ,
//                MyNT *mean = NULL, MyNT *sigma = NULL);


  // the dimension this interval corresponds to. 
  unsigned int dimension;
};


// an interval with a p-value.
struct MySignificantInterval : public MyInterval
{};



// a struct that stores information about a range of widths/intervals
// with a given starting point.
struct MyWidthRange
{
public:
  MyWidthRange()
      : start(), min_width(), max_width()
    {}
  
  MyWidthRange(MyNT s, MyNT min, MyNT max)
      : start(s), min_width(min), max_width(max)
    {}
  
  // constructor from a map. cannot use const map< > here since i use
  // map< >::operator[]. alternative is to use const and the find()
  // function at the risk of a seg fault.
  MyWidthRange(map< string, MyNT, ltstr >& init)
      : start(init["start"]), min_width(init["min-width"]),
        max_width(init["max-width"])
    {}

  virtual ~MyWidthRange()
    {}

  // check if two intervals are identical. enough to check start and end.
  virtual bool operator==(const MyWidthRange& interval) const
    {
      // if both intervals are pointing to the same instance, they are equal. 
      if (&interval == this)
        return(true);
      if (start != interval.start)
        return(false);
      if (min_width != interval.min_width)
        return(false);
      if (max_width != interval.max_width)
        return(false);
      return(true);
    }

  // check if two intervals are not identical. 
  virtual bool operator!=(const MyWidthRange& interval) const
    {
      return(!(*this == interval));
    }
  
  // gets and sets
  MyNT getStart() const
    {
      return(start);
    }
  void setStart(MyNT s)
    {
      start = s;
    }

  void setMinWidth(MyNT width)
    {
      min_width = width;
    }
  
  
  void setMaxWidth(MyNT width)
    {
      max_width = width;
    }
  
  
  virtual void print(ostream& ostr) const
    {
      ostr << "Interval is start = " << start
           << ", min-width = " << min_width << ", max-width = " << max_width
           << endl;
    }

  // check if *this contains in.
  virtual bool contains(const MyInterval& in) const
    {
      return(contains(in.getStart(), in.getEnd()));
    }
  
  // check if this range of intervals contains p.
  virtual bool contains(MyNT p) const
    {
      return((start + min_width <= p) && (p <= start + max_width));
    }
  
  // checks if this range of intervals contains [s, e].
  virtual bool contains(MyNT s, MyNT e) const
    {
      return((start == s) && contains(e));
    }

//   // checks if [s, e] equals [start, end].
//   virtual bool equals(MyNT s, MyNT e) const
//     {
//       return((start == s) && (e == end));
//     }
  
  MyNT start;
  MyNT min_width;
  MyNT max_width;
};



#endif // _INTERVAL_H