itemset.h

/**************************************************************************
 * Copyright (c) 2004-2011 T. M. Murali                                   *
 * Copyright (c) 2004 Greg Grothaus                                       *
 *                                                                        *
 * 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/>.      *
 *                                                                        *
 **************************************************************************/

#include<iostream>
#include<sstream>
#include<set>
#include<string>
#include<vector>

using namespace std;

#ifndef ITEMSET
#define ITEMSET

typedef string ItemsetId;

class Itemset
{
  friend class Apriori;
  friend class AprioriWithComplement;

private:

  ItemsetId _id;
  //stores the indices of columns and rows
  //so we dont have to work with strings
  vector<unsigned int> columns;
//   vector<unsigned int> rows;

  // i need this variable when i don't store columns explicitly.
  unsigned int _numColumns;
  
  // the set of rows and columns in the itemset
  set< unsigned int > _columnSet;
  set< unsigned int > _rowSet;

  // HACKHACKHACK! ideally, i should subclass Itemset to store complemented rows but the 2007 RECOMB deadline is just 5 days away!
  set< unsigned int > _complementedRowSet;
  
  
  //this stores the publically available column and row
  //strings after processing
  vector<string> columnStrings;
  vector<string> rowStrings;

  // the pvalue of the #columns amongst all itemsets with the same #rows.
  float _columnPValue;
  // the pvalue of the #rows amongst all itemsets with the same #columns.
  float _rowPValue;
  // the pvalue of the size of the itemset.
  float _sizePValue;

  
  void transpose();

  static unsigned int _currentId;
  static ItemsetId _makeId(unsigned int index)
    {
      stringstream sstr;
      sstr << "itemset_";
      sstr << index;
      return(sstr.str());
    }
  
  static ItemsetId _getNewId() 
    {
      _currentId++;
      return(_makeId(_currentId));
    }

  void _computeColumnSet()
    {
      copy(columns.begin(), columns.end(), inserter(_columnSet, _columnSet.begin()));
    }
  
//   void _computeRowSet()
//     {
//       copy(rows.begin(), rows.end(), inserter(_rowSet, _rowSet.begin()));
//     }
  
  
public:
  Itemset()
      : _id(), columns(), //rows(),
        _numColumns(0),
        _columnSet(), _rowSet(), _complementedRowSet(),
        columnStrings(), rowStrings(),
        _columnPValue(1), _rowPValue(1), _sizePValue(1)
    {}
  
  Itemset(const Itemset &rhs)
    {
      _id = rhs._id;
      columns = rhs.columns;
//       rows = rhs.rows;
      _numColumns = rhs._numColumns;
      _columnSet = rhs._columnSet;
      _rowSet = rhs._rowSet;
      _complementedRowSet = rhs._complementedRowSet;
      columnStrings = rhs.columnStrings;
      rowStrings = rhs.rowStrings;
      _columnPValue = rhs._columnPValue;
      _rowPValue = rhs._rowPValue;
      _sizePValue = rhs._sizePValue;
      
    }

  void addRow(unsigned int index)
    {
      _rowSet.insert(index);
    }
  
  
  void setId(ItemsetId id)
    {
      _id = id;
    }
  ItemsetId getId() const
    {
      return(_id);
    }
  
  unsigned int size() const;

  const Itemset & operator=(const Itemset &rhs)
    {
      if (this != &rhs)
        {
          _id = rhs._id;
          columns = rhs.columns;
//           rows = rhs.rows;
          _numColumns = rhs._numColumns;
          _columnSet = rhs._columnSet;
          _rowSet = rhs._rowSet;
          _complementedRowSet = rhs._complementedRowSet;
          columnStrings = rhs.columnStrings;
          rowStrings = rhs.rowStrings;
          _columnPValue = rhs._columnPValue;
          _rowPValue = rhs._rowPValue;
          _sizePValue = rhs._sizePValue;
        }
      return(*this);
    }
  

  bool operator<(const Itemset &a) const;
  bool operator<(const Itemset *a) const;
  
  bool operator==(const Itemset &a) const;
  bool operator==(const Itemset *a) const;

  
  void clearColumns()
    {
      _numColumns = columns.size();
      columns.clear();
//      _columnsCleared = true;
    }
  
  bool containsColumn(unsigned int index) const
    {
      return(_columnSet.end() != _columnSet.find(index));
    }
  
  bool containsRow(unsigned int index) const
    {
      return(_rowSet.end() != _rowSet.find(index));
    }
  
  bool containsRows(const Itemset &other) const;
  
  bool containsRows(const set< unsigned int > &otherRows) const;
  

  vector<string> getColumns() const { return columnStrings; }

  unsigned int getNumColumns() const 
    {
      return(_numColumns);
      return(columns.size());
    }
  
  unsigned int getNumRows() const 
    {
      return(_rowSet.size());
//       return(rows.size());
    }
  
  unsigned int getNumComplementedRows() const 
    {
      return(_complementedRowSet.size());
    }
  
  vector<string> getRows() const { return rowStrings; }

  void printColumns(ostream &ostr) const;

  void printRows(ostream &ostr) const;

  void print(ostream &ostr, unsigned int itemsetnum) const;     

  void printGraph(ostream &ostr, unsigned int itemsetNum) const;
  
  void setColumnPvalue(float pval)
    {
      _columnPValue = pval;
    }
  float getColumnPvalue() const
    {
      return(_columnPValue);
    }
  
  void setRowPvalue(float pval)
    {
      _rowPValue = pval;
    }
  float getRowPvalue() const
    {
      return(_rowPValue);
    }
  
  void setSizePvalue(float pval)
    {
      _sizePValue = pval;
    }
  float getSizePvalue() const
    {
      return(_sizePValue);
    }
  

  
};

#endif