network-lego.h

/**************************************************************************
 * Copyright (c) 2005-2011 T. M. Murali                                   *
 * Copyright (c) 2009-2011 Christopher L. Poirel                          *
 * Copyright (c) 2011 Christopher D. Lasher                               *
 * Copyright (c) 2010 Jacqueline Addesa                                   *
 * Copyright (c) 2003-2005 Deept Kumar                                    *
 *                                                                        *
 * 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/>.      *
 *                                                                        *
 **************************************************************************/

#ifndef _NETWORK_LEGO_H
#define _NETWORK_LEGO_H

#include "active-networks.h"
#include "apriori.h"
#include "dag.h"

class NetworkLego : public ActiveNetwork
{
private:
  // the set of leaves associated with this lego.
  set< NetworkLego > _leaves;

  // for inmf, the set of conditions the NL contributes to. the map
  // associates each condition with a weight.
  map< string, MyNT > _conditionsContributeTo;

public:
};

enum NLOperator { NL_INTERSECTION, NL_DIFFERENCE };

class SDAGNode : DAGNode< NetworkLego >
{
private:
  NLOperator _operator;
public:
};

class SDAG : public DAG< SDAGNode >
{
private:

public:

  void addLeaf(const NetworkLego &lego);

  void addLeaves(const vector< NetworkLego > &leaves);

  void compute();

};


class SetOfNetworkLegos: public SetOfActiveNetworks
{
private:

  // the main algo used to compute the itemsets.
  AprioriWithComplement _aprioriAlgo;


  // the leaves of the lattice.
  SetOfActiveNetworks _leaves;

  // the legos themselves, including the leaves.
  SetOfActiveNetworks _legos;

  // the statistically significant legos.
  SetOfActiveNetworks _significantLegos;

  // the leaves of the  statistically significant legos.
  SetOfActiveNetworks _significantLegosLeaves;

  // the roots of the statistically significant legos.
  SetOfActiveNetworks _significantLegosRoots;

  // the lattice that holds the legos together.
  ItemsetLattice _lattice;

  // the closure of the lattice that holds the legos together.
  ItemsetLattice _closedLattice;

  // the lattice that contains only statistically significant itemsets.
  ItemsetLattice _significantLattice;
  // the closure of the lattice that holds the significant legos together.
  ItemsetLattice _closedSignificantLattice;

  // a binary matrix representing the leaves.
  vector< vector < unsigned int > > _binaryMatrix;
  // the set of rows corresponding to the complements.
  set< unsigned int > _complementRows;
  // the row names _binaryMatrix.
  map< unsigned int, string > _binaryMatrixRowNames;
  // the column names in _binaryMatrix.
  map< unsigned int, string > _binaryMatrixColumnNames;

  // for inmf, the set of conditions the NL contributes to, stored as a graph.
  MyGraph _mapFromNetworkLegosToActiveNetworks;


public:
  SetOfNetworkLegos()
    {}
  SetOfNetworkLegos(SetOfActiveNetworks &anetSet)
      : _leaves(anetSet)
    {}

  virtual ~SetOfNetworkLegos()
    {}

  virtual void compute(ostream &logStream, unsigned int minNumberConditions = 1,
                       unsigned int minNumberInteractions = 1);

  void computeMaximallySignificantItemsets(
    const vector< Itemset > &allSignificantItemsets,
    vector< Itemset > &maximallySignificantItemsets,
    vector< Itemset > &significantLatticeRoots,
    vector< Itemset > &significantLatticeLeaves);

  virtual void compareNetworkLegosToActiveNetworks();
  
  virtual void computeTrivialLegos(ostream &logStream);


  virtual void computeRecoverability(ostream &logStream);

  virtual void computeSignificantLegos(ostream &logStream, unsigned int numRandomTrials = 100000,
                                       MyNT pvalueThreshold = 0.01);

  virtual void computeStability(ostream &logStream);

  virtual void getSignificantLegos(SetOfActiveNetworks &legos)
    {
      legos = _significantLegos;
    }


#ifdef CTEMPLATE

  virtual void layout();
#endif


  // various methods to print stuff.

  void printBinaryMatrix(ostream &ostr, bool transposed = false) const;

  void printClosedLattice(ostream &ostr) const
    {
      _closedSignificantLattice.print(ostr);
    }

  void printLattice(ostream &ostr) const
    {
      _significantLattice.print(ostr);
    }

  virtual void readMappingFromNetworkLegosToActiveNetworks(string nlsToRNsFile);
};



#endif // _NETWORK_LEGO_H