gain-algorithm.h

/**************************************************************************
 * Copyright (c) 2001-2011 T. M. Murali                                   *
 * Copyright (c) 2011 Phillip Whisenhunt                                  *
 * Copyright (c) 2011 David Badger                                        *
 * Copyright (c) 2010 Jacqueline Addesa                                   *
 *                                                                        *
 * 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: define classes of algorithms for assigning functions.


#ifndef _GAIN_ALGORITHM_H
#define _GAIN_ALGORITHM_H

#include "boost/lexical_cast.hpp"

#include "gain.h"
#include "gain-state.h"
#include "gain-traverse.h"
#include "bfs.h"
#include "GO.h"
#include "mcode.h"
#include "reporter.h"


#ifdef HAVE_LIBGSL
#include <gsl/gsl_linalg.h>
#include <gsl/gsl_matrix.h>
#include <gsl/gsl_permutation.h>
#include <gsl/gsl_vector.h>
#endif //HAVE_LIBGSL

// ultra abstract class to resolve issues in main()
// arising from pointers to original abstract class, which is now
// templated

class MyReallyAbstractGainAlgo
{
public:
  virtual void initialiseAlgorithm()
    {}

  virtual string getName() = 0;

  virtual void pipeline(const BioFunction &function) = 0;

  virtual void printStatistics(ostream &statsStream)
    {}

  // virtual void tieUpLooseEnds() = 0;

};

//class MyAbstractGainAlgo
template< typename StateType > class MyAbstractGainAlgo : public MyReallyAbstractGainAlgo
{
protected:
  MyAnnotations &_annotations;
  // useful to store this to avoid recomputing FLNs. each algorithm
  // must decide when to store the function.
  BioFunction _currentFunction;
//  static string _name;
  // this one is a pointer since i may get it or not in the constructor.
  GeneOntology *_go;
  MyGainGraph & _graph;
  MyGainParams & _params;

  Reporter & _reporter;


  // for each possible initial state type, store the list of nodes in that initial state type.
  map< StateType, MyNodeIdList > _nodesByInitialStateType;

  map< StateType, MyNodeIdList > _nodesByRealStateType;

  // for each node, store information on its state (including partial
  // or complete history of modification of node state by the
  // algorithm.
  map< MyNodeId, MyGainStateInfo< MyGainState< StateType > > > _states;

  map< MyNodeId, StateType > _realStateTypes;
  map< MyNodeId, StateType > _initialStateTypes;

  // set of nodes in the cut.
  MyNodeIdSet _cutNodes;

protected:
//  virtual static void _setName() = 0;



public:
  MyAbstractGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
      : _annotations(a), _graph(g), _params(p), _reporter(r), _go(go),
        _nodesByInitialStateType(), _nodesByRealStateType(), _states(), _realStateTypes(), _initialStateTypes()

    {
      //_reporter.setExperimentName(p.getExperimentName());
    }

  virtual ~MyAbstractGainAlgo()
    {}

  virtual void computeCrossValidationResults(const BioFunction &function,
                                             const MyNodeIdList &cvNodes) = 0;

  virtual void computeCut(MyNodeIdList &nodesToAnnotate,
                          MyNodeIdSet &cutNodes)
    {}

  /*virtual void computePredictionConfidences(const BioFunction &function,
                                            MyNodeIdList &nodesToAnnotate,
                                            MyNodeIdList &predictedNodes) = 0;
*/
  virtual void computePredictions(const BioFunction &function,
                                  const MyNodeIdList &nodesToAnnotate,
                                  MyNodeIdList &predictedNodes) = 0;


  // not const MyNode& because of problems with MyNode::ConstIncidentEdgeIterator
  virtual MyGainState< StateType > computeState(MyNode &node) = 0;

  virtual void constructCrossValidationLists(vector<MyNodeIdList> &cvLists) = 0;

  // this method is not const since it may involve collapsing node states.
  virtual bool hasConverged(const MyNodeIdList &nodesToAnnotate)  = 0;

  virtual void crossValidate(const BioFunction &function);

  virtual void maskNodeStates(const MyNodeIdList &nodes) = 0;

  //virtual void unmaskNodeStates(const MyNodeIdList &nodes) = 0;


  virtual void evaluatePredictions(MyAnnotations &newAnnotations);



//  static
  virtual string getName() = 0;


  virtual void initialiseNodeStates(const BioFunction &function,
                                    MyNodeIdList &nodesToAnnotate) = 0;

  virtual void pipeline(const BioFunction &function);


  virtual void predict(const BioFunction &function);

  virtual void run(const MyNodeIdList &nodesToAnnotate) = 0;

  virtual void setCrossValidationList(MyNodeIdList &nodesToAnnotate,
                                      const MyNodeIdList &cvList);

//  virtual void visualise(BioFunction &currentFunction, MyNodeIdList &nodesToAnnotate);
  virtual void visualiseCrossValidation(const BioFunction &currentFunction);

  virtual void visualiseCut(const BioFunction &currentFunction,
                            MyNodeIdList &predictedNodes);
  virtual void visualisePredictions(const BioFunction &currentFunction,
                                    MyNodeIdList &nodesToAnnotate);

  virtual void initialiseEdgeWeights(const BioFunction &function)
    {
#ifdef DEBUG
//                _graph._checkNodeTotalEdgeWeight();
#endif
      if (_params.weightEdgeTypesCutoff)
        initialiseEdgeWeightsCutoff(function);
      else if (_params.weightEdgeTypesDepth)
        initialiseEdgeWeightsDepth(function);
      // murali, sep 12, 2007.
#ifdef DEBUG
//                _graph._checkNodeTotalEdgeWeight();
#endif
    }
  virtual void initialiseEdgeWeightsCutoff(const BioFunction &function) {};
  virtual void initialiseEdgeWeightsDepth(const BioFunction &function) {};

  virtual void removeUnpredictableNodes(const MyNodeIdSet &unpredictableNodes, MyNodeIdList &oldNodes)
    {
      MyNodeIdList newNodes;
      for (MyNodeIdList::iterator nitr = oldNodes.begin(); nitr != oldNodes.end(); nitr++)
        if (unpredictableNodes.end() == unpredictableNodes.find(*nitr))
          newNodes.push_back(*nitr);
      oldNodes = newNodes;
    }
};


// template< typename StateType >
// void MyAbstractGainAlgo< StateType >::comparePredictions(MyReallyAbstractGainAlgo &other)
// {
//   comparePredictions(dynamic_cast< MyAbstractGainAlgo >(other));
// }

// template< typename StateType >
// void MyAbstractGainAlgo< StateType >::comparePredictions(MyAbstractGainAlgo &other)
// {
//   typename map< MyNodeId, MyGainStateInfo< MyGainState< StateType > > >::iterator
//     sitr, oitr;
//   _params.logStream << "Comparing predictions for algorithms "
//                     << getName() << " and " << other.getName()
//                     << " for function " << _currentFunction << endl;
//   // compare initial and final states.
//   for (sitr = _states.begin(); sitr != _states.end(); sitr++)
//     {
//       oitr = other._states.find(sitr->first);
//       if (other._states.end() == oitr)
//         _params.logStream << other.getName() << " does not have a state for node " << sitr->first << endl;
//       if (sitr->second.getRealState() != oitr->second.getRealState())
//         _params.logStream << " Node " << sitr->first << "has getReal state "
//                           << sitr->second.getRealState()
//                           << " for " << getName() << " but "
//                           << oitr->second.getRealState()
//                           << " for " << other.getName() << endl;
//       if (sitr->second.getInitialState() != oitr->second.getInitialState())
//         _params.logStream << " Node " << sitr->first << "has getInitial state "
//                           << sitr->second.getInitialState()
//                           << " for " << getName() << " but "
//                           << oitr->second.getInitialState()
//                           << " for " << other.getName() << endl;
//       if (sitr->second.getCurrentState() != oitr->second.getCurrentState())
//         _params.logStream << " Node " << sitr->first << "has getCurrent state "
//                           << sitr->second.getCurrentState()
//                           << " for " << getName() << " but "
//                           << oitr->second.getCurrentState()
//                           << " for " << other.getName() << endl;
//     }
// }


template< typename StateType >
void MyAbstractGainAlgo< StateType >::crossValidate(const BioFunction &function)
{
        // BUG: even if this is done inside the loop it still has to be done here or --only-cv breaks
  MyNodeIdList hypotheticalNodes;
  initialiseNodeStates(function, hypotheticalNodes);

  // each algorithm needs to decide how to build its cross validation
  // lists. for example, MyOneVersusNoneGainAlgo does not have any
  // proteins in state NOT_ANNOTATED_STATE.
  // each MyNodeIdList is a list of nodes i should erase. for loocv,
  // each MyNodeIdList will contain a single node.
  vector< MyNodeIdList > cvLists;
  constructCrossValidationLists(cvLists);

  vector< MyNodeIdList >::iterator itr;
  for (itr = cvLists.begin(); itr != cvLists.end(); itr++)
    {
      // Need to reinit each time until unmasking works.
      // When it does, just set nodesToAnnotate = hypotheticalNodes.
      // Then masking and setCVList will take care of business without needing to reinit.
      MyNodeIdList nodesToAnnotate, dummyNodesToAnnotate;
      initialiseNodeStates(function, nodesToAnnotate);

      // "forget" the existing annotations of the nodes in *itr and add them to nodesToAnnotate.
      maskNodeStates(*itr);

      MyNodeIdSet unpredictableNodes;
      MyGainGraph reducedGraph;
      if (!_params.getDoNotReduce())
        {
          _graph.reduce2(_params.logStream, _initialStateTypes, _params, reducedGraph, unpredictableNodes);
#ifdef DEBUG
          _params.logStream << "\n\t" << getName() << ": after reducing the FLN for cross validation, found " << unpredictableNodes.size() << " unpredictable nodes" << flush;
#endif // DEBUG
          // remove unpredictableNodes from nodesToAnnotate AND the current cvList INDIVIDUALLY.
          // computeCrossValidationResults needs the modified cvList so that we don't evaulate unpredictable nodes.
          removeUnpredictableNodes(unpredictableNodes, nodesToAnnotate);
          removeUnpredictableNodes(unpredictableNodes, *itr);
        }

      setCrossValidationList(nodesToAnnotate, *itr);

      initialiseEdgeWeights(function);

      // run.
      run(nodesToAnnotate);
      computeCrossValidationResults(function, *itr);

      //visualiseCVTemp(function, *itr);

      // now "remember" the existing annotations of the nodes in *itr.
      //unmaskNodeStates(*itr);
    }
}


template< typename StateType >
void MyAbstractGainAlgo< StateType >::evaluatePredictions(MyAnnotations &newAnnotations)
{
  _reporter.evaluatePredictions(getName(), _annotations, newAnnotations, *_go);
}

template< typename StateType >
void MyAbstractGainAlgo< StateType >::pipeline(const BioFunction &function)
{
  // predict. visualise, if necessary, inside predict.
  if (!_params.onlyCrossVal)
    {
      predict(function);
      _reporter.printPredictions(_params.predictionsStream, _params.getNumPredictionsToPrintPerFunction());
    }

  // cross validate visualise, if necessary, inside crossValidate.
  if (!_params.onlyPredictions)
    {
      crossValidate(function);
      // tmm, 2008-03-25. no need to print these results, since we are
      // invoking Reporter::printCurveDataFromCV() in gain.C
//      _reporter.printCVResults(_params.cvStream);
      //_reporter.printDetailedCVResults(_params.detailedCVStream);
    }

// //   // compute probabilities of predictions based solely on distribution
// //   // of scores for nodes in states 0 and nodes in other states.
// //   computePredictionProbabilities(function);

  // randomise and/or statistical significance

  // report.
  /*if (!_params.onlyCrossVal)
    // send function so that i print info only for this function.
    //_reporter.printPredictions(_params.predictionsStream, &function);
    //_reporter.flushPredictions(_params.predictionsStream);
  if (!_params.onlyPredictions)
  {
    // send function so that i print info only for this function.
    //_reporter.printCVResults(_params.cvStream, &function);
    //_reporter.flushCVResults(_params.cvStream);
    //_reporter.flushDetailedCVResults(_params.detailedCVStream);
  }*/
}

template< typename StateType >
void MyAbstractGainAlgo< StateType >::predict(const BioFunction &function)
{
   MyNodeIdList nodesToAnnotate;
   initialiseNodeStates(function, nodesToAnnotate);

   MyNodeIdSet unpredictableNodes;
   MyGainGraph reducedGraph;
   if (!_params.getDoNotReduce())
     {
       _graph.reduce2(_params.logStream, _initialStateTypes, _params, reducedGraph, unpredictableNodes);
#ifdef DEBUG
       _params.logStream << "\n\t" << getName() << ": after reducing the FLN for prediction, found " << unpredictableNodes.size() << " unpredictable nodes and " << flush;
#endif // DEBUG
       // remove unpredictableNodes from nodesToAnnotate.
       removeUnpredictableNodes(unpredictableNodes, nodesToAnnotate);
       _params.logStream << nodesToAnnotate.size() << " predictable nodes." << endl;
     }

   initialiseEdgeWeights(function);

   run(nodesToAnnotate);
   MyNodeIdList predictedNodes;
   // also stores predictions.
   computePredictions(function, nodesToAnnotate, predictedNodes);
//   computePredictionConfidences(function, nodesToAnnotate, predictedNodes);

   if (_params.visualisePredictions)
    visualisePredictions(function, nodesToAnnotate);
   if (_params.visualiseCut)
     visualiseCut(function, predictedNodes);
}

template< typename StateType >
void MyAbstractGainAlgo< StateType >::setCrossValidationList(
  MyNodeIdList &nodesToAnnotate, const MyNodeIdList &cvList)
{
  // add the nodes in cvList to nodesToAnnotate.
  nodesToAnnotate.insert(nodesToAnnotate.end(), cvList.begin(), cvList.end());
}

// template< typename StateType >
// void MyAbstractGainAlgo< StateType >::visualise(BioFunction &currentFunction,
//                                    MyNodeIdList &nodesToAnnotate)
// {
//   if (!_params.onlyCrossVal)
//     visualisePredictions(currentFunction, nodesToAnnotate);
// }

template< typename StateType >
void MyAbstractGainAlgo< StateType >::visualiseCrossValidation(
  const BioFunction &currentFunction)
{
  cerr << "MyAbstractGainAlgo< StateType >::visualiseCrossValidation not implemented."
       << endl;
}

template< typename StateType >
void MyAbstractGainAlgo< StateType >::visualiseCut(
  const BioFunction &currentFunction, MyNodeIdList &nodesToAnnotate)
{
  cerr << "MyAbstractGainAlgo< StateType >::visualiseCut not implemented."
       << endl;
}

template< typename StateType >
void MyAbstractGainAlgo< StateType >::visualisePredictions(
  const BioFunction &currentFunction, MyNodeIdList &nodesToAnnotate)
{
  cerr << "MyAbstractGainAlgo< StateType >::visualisePredictions not implemented."
       << endl;
}


//class MyOneVersusAllGainAlgo : public MyAbstractGainAlgo
class MyOneVersusAllGainAlgo : public MyAbstractGainAlgo< MyGainTriStateType >
{
protected:
  // can i allow approximate convergence? this algorithm will but not
  // MyOneVersusAllHopfieldGainAlgo will.
  bool _allowApproximateConvergence;
  map< BioFunction, MyNT > _finalEnergies;
  map< BioFunction, MyNT > _initialEnergies;

  // for each possible initial state, store the list of nodes in that initial state.
//  map< MyGainTriStateType, MyNodeIdList > _nodesByInitialStateType;

  map< BioFunction, unsigned int > _numIterations;
  map< BioFunction, unsigned int > _numOperations;


  unsigned int _numTruePathViolatingAnnotations;
  unsigned int _numTruePathViolatingPredictions;

  // map from function ids to genes for annotations that violate the true path rule.
  map< string, set < string > > _truePathViolatingAnnotations;
  // map from function ids to genes for predictions that violate the true path rule.
  map< string, set < string > > _truePathViolatingPredictions;


public:
  MyOneVersusAllGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r,
                         GeneOntology *go = NULL)
      : MyAbstractGainAlgo< MyGainTriStateType >(g, a, p, r, go),
        _allowApproximateConvergence(true),
        _finalEnergies(), _initialEnergies(),
        _numIterations(),
        _numTruePathViolatingAnnotations(0), _numTruePathViolatingPredictions(0),
        _truePathViolatingAnnotations(), _truePathViolatingPredictions()
    {}
  virtual ~MyOneVersusAllGainAlgo()
    {}


  virtual void computeCrossValidationResults(const BioFunction &function,
                                             const MyNodeIdList &cvNodes);

  virtual void computeCut(MyNodeIdList &nodesToAnnotate,
                          MyNodeIdSet &cutNodes);

  virtual MyNT computeEnergy(const MyNodeIdList &nodesToAnnotate);


  virtual void computePredictionConfidences(const BioFunction &function,
                                            MyNodeIdList &nodesToAnnotate,
                                            MyNodeIdList &predictedNodes);

  virtual void computePredictions(const BioFunction &function,
                                  const MyNodeIdList &nodesToAnnotate,
                                  MyNodeIdList &predictedNodes);
//   template< typename StateType >
//   MyGainState< StateType > computeState(MyNode &node);
  virtual MyGainTriState computeState(MyNode &node);

  virtual void constructCrossValidationLists(vector<MyNodeIdList> &cvLists);

  virtual bool hasConverged(const MyNodeIdList &nodesToAnnotate);

  virtual void maskNodeStates(const MyNodeIdList &nodes);
  //virtual void unmaskNodeStates(const MyNodeIdList &nodes);

//  static
  virtual string getName()
    {
      return("OneVersusAllLinearSystem");
    }

  virtual void initialiseNodeStates(const BioFunction &function,
                                    MyNodeIdList &nodesToAnnotate);

  virtual void run(const MyNodeIdList &nodesToAnnotate);


//  virtual void visualise(BioFunction &currentFunction, MyNodeIdList &nodesToAnnotate);
  virtual void visualisePredictions(const BioFunction &currentFunction,
                                    MyNodeIdList &nodesToAnnotate);
  virtual void visualiseCut(const BioFunction &currentFunction,
                            MyNodeIdList &predictedNodes);

  // these two methods cannot be const since they involve calls to
  // MyGainState::collapse().
//   virtual void printNodesSpring(MyGraph &propagationGraph,
//                                 string file, string currentNode);
//   virtual void printEdgesSpring(MyGraph &propagationGraph, string file);

  virtual void printStatistics(ostream &statsStream);

        virtual void initialiseEdgeWeightsCutoff(const BioFunction &function);
        virtual void initialiseEdgeWeightsDepth(const BioFunction &function);

};




class MyOneVersusNoneGainAlgo : public MyOneVersusAllGainAlgo
{
protected:

public:
  MyOneVersusNoneGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
      : MyOneVersusAllGainAlgo(g, a, p, r, go)
    {}

  virtual ~MyOneVersusNoneGainAlgo()
    {}

  virtual void initialiseNodeStates(const BioFunction &function,
                            MyNodeIdList &nodesToAnnotate);

  virtual void setCrossValidationList(MyNodeIdList &nodesToAnnotate, const MyNodeIdList &cvList);

//  static
  virtual string getName()
    {
      return("OneVersusNoneLinearSystem");
    }
};



#if 0

class MyOneVersusNoneGainAlgo : public MyAbstractGainAlgo< MyGainBiStateType >
{
protected:

public:
  MyOneVersusNoneGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r)
      : MyAbstractGainAlgo< MyGainBiStateType >(g, a, p, r)
    {}

  virtual ~MyOneVersusNoneGainAlgo()
    {}

  virtual void computeCrossValidationResults(const BioFunction &function,
                                             const MyNodeIdList &cvNodes);

  virtual void computePredictionConfidences(const BioFunction &function,
                                            MyNodeIdList &nodesToAnnotate,
                                            MyNodeIdList &predictedNodes);

  virtual void computePredictions(const BioFunction &function,
                                  const MyNodeIdList &nodesToAnnotate,
                                  MyNodeIdList &predictedNodes);
//   template< typename StateType >
//   MyGainState< StateType > computeState(MyNode &node);
  virtual MyGainBiState computeState(MyNode &node);

  virtual void constructCrossValidationLists(vector<MyNodeIdList> &cvLists);

  virtual bool hasConverged(const MyNodeIdList &nodesToAnnotate);

  virtual void maskNodeStates(const MyNodeIdList &nodes);
  //virtual void unmaskNodeStates(const MyNodeIdList &nodes);

//  static
  virtual string getName()
    {
      return("OneVersusNoneLinearSystem");
    }

  virtual void initialiseNodeStates(const BioFunction &function,
                                    MyNodeIdList &nodesToAnnotate);

  virtual void run(const MyNodeIdList &nodesToAnnotate);

};


class MyOneVersusNoneFunctionalFlowGainAlgo : public MyOneVersusNoneGainAlgo
{
protected:
  // a map from a node to the size of the reservoir at that node. the
  // _states variable will take care of the total inflow into the
  // node.
  map< MyNodeId, MyNT > _currentNodeReservoirs, _previousNodeReservoirs;
  // a map from a node to the total flow into the node. this variable
  // is just a helper (for debugging, to make sure that _states stores
  // the right info).
  map< MyNodeId, MyNT > _totalInflow;

public:
  MyOneVersusNoneFunctionalFlowGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r)
      : MyOneVersusNoneGainAlgo(g, a, p, r), _currentNodeReservoirs(), _previousNodeReservoirs(), _totalInflow()
    {}

  virtual ~MyOneVersusNoneFunctionalFlowGainAlgo()
    {}

  virtual void computePredictions(const BioFunction &function,
                                  const MyNodeIdList &nodesToAnnotate,
                                  MyNodeIdList &predictedNodes);
  virtual MyGainBiState computeState(MyNode &node);


//  static
  virtual string getName()
    {
      return("OneVersusNoneFunctionalFlow");
    }

  virtual void run(const MyNodeIdList &nodesToAnnotate);
};
#endif


#if(0)
class MyOneVersusNoneHeavisideGainAlgo : public MyOneVersusNoneGainAlgo
{
private:
    // this map stores the computed node thresholds. this map also keeps
  // track of which nodes i have already processed, so that i can
  // avoid processing them again. (a node may have multiple entries in
  // the pq, since it can get inserted whenever one of its neighbours
  // changes to a 1.)
  map< MyNodeId, MyNT > _nodeThresholds;

public:
  MyOneVersusNoneHeavisideGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r)
      : MyOneVersusNoneGainAlgo(g, a, p, r)
    {}

  virtual ~MyOneVersusNoneHeavisideGainAlgo()
    {}

  virtual void computePredictions(const BioFunction &function,
                                  const MyNodeIdList &nodesToAnnotate,
                                  MyNodeIdList &predictedNodes);

  virtual MyGainBiState computeState(MyNode &node);

//  static
  virtual string getName()
    {
      return("OneVersusNoneHeaviside");
    }


  virtual void run(const MyNodeIdList &nodesToAnnotate);
};
#endif

#if(0)
class MyOneVersusNoneShortestPathGainAlgo : public MyOneVersusNoneGainAlgo
{
private:
    // this map stores the computed node thresholds. this map also keeps
  // track of which nodes i have already processed, so that i can
  // avoid processing them again. (a node may have multiple entries in
  // the pq, since it can get inserted whenever one of its neighbours
  // changes to a 1.)
  map< MyNodeId, MyNT > _nodeThresholds;

  // the graph where the edge weight in the length of the shortest
  // path in _graph. this graph only needs to have edges between nodes
  // in state HYPOTHETICAL_STATE and nodes in state ANNOTATED_STATE.
  MyGraph _shortestPathGraph;
  // a subgraph of _shortestPathGraph that only connects nodes in +1
  // state. this graph is useful for cross validation.
  MyGraph _shortestPathGraphPositives;


public:
  MyOneVersusNoneShortestPathGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r)
      : MyOneVersusNoneGainAlgo(g, a, p, r), _nodeThresholds(), _shortestPathGraph(),
        _shortestPathGraphPositives()
    {}

  virtual ~MyOneVersusNoneShortestPathGainAlgo()
    {}

//   virtual void computePredictions(const BioFunction &function,
//                                   const MyNodeIdList &nodesToAnnotate,
//                                   MyNodeIdList &predictedNodes);
//   template< typename StateType >
//   MyGainState< StateType > computeState(const MyNode &node);

//  virtual bool hasConverged(const MyNodeIdList &nodesToAnnotate);

//  static
  virtual
  string getName()
    {
      return("OneVersusNoneShortestPath");
    }

  virtual void computePredictions(const BioFunction &function,  const MyNodeIdList &nodesToAnnotate,
                                  MyNodeIdList &predictedNodes);

//   template< typename StateType >
//   MyGainState< StateType > computeState(MyNode &node);
  MyGainBiState computeState(MyNode &node);

  virtual void initialiseNodeStates(const BioFunction &function,
                                    MyNodeIdList &nodesToAnnotate);

  virtual void run(const MyNodeIdList &nodesToAnnotate);

  virtual void setCrossValidationList(MyNodeIdList &nodesToAnnotate,
                                      const MyNodeIdList &cvList);
};

#endif



class MyOneVersusAllLocalGainAlgo : public MyOneVersusAllGainAlgo
{
protected:

public:
  MyOneVersusAllLocalGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r,
                              GeneOntology *go = NULL)
      : MyOneVersusAllGainAlgo(g, a, p, r, go)
    {
      // there is no sense of convergence here.
      _allowApproximateConvergence = true;
    }

  virtual ~MyOneVersusAllLocalGainAlgo()
    {}

  MyGainTriState computeState(MyNode &node);

//  static
  virtual string getName()
    {
      return("OneVersusAllLocal");
    }

  // i need to implement this method just so that i can call the
  // computeState method for this class and not for the parent class.
  virtual void run(const MyNodeIdList &nodesToAnnotate);

};


class MyOneVersusAllHopfieldGainAlgo : public MyOneVersusAllGainAlgo
{
protected:

public:
  MyOneVersusAllHopfieldGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r,
                                 GeneOntology *go = NULL)
      : MyOneVersusAllGainAlgo(g, a, p, r, go)
    {
      _allowApproximateConvergence = false;
    }

  virtual ~MyOneVersusAllHopfieldGainAlgo()
    {}

//   virtual void computeCrossValidationResults(const BioFunction &function,
//                                              const MyNodeIdList &cvNodes);

//   virtual void computePredictionProbabilities(const BioFunction &function);

//   virtual void computePredictions(const BioFunction &function,
//                                   const MyNodeIdList &nodesToAnnotate,
//                                   MyNodeIdList &predictedNodes);
//  template< typename StateType >
//  MyGainState< StateType > computeState(MyNode &node);
  MyGainTriState computeState(MyNode &node);

//  virtual bool hasConverged(const MyNodeIdList &nodesToAnnotate);

//  virtual void maskNodeStates(const MyNodeIdList &nodes);
//  virtual void unmaskNodeStates(const MyNodeIdList &nodes);

//  static
  virtual string getName()
    {
      return("OneVersusAllHopfield");
    }

  // i need to implement this method just so that i can call the
  // computeState method for this class and not for the parent class.
  virtual void run(const MyNodeIdList &nodesToAnnotate);

};


typedef struct
{} MyGainMinCutInfo;


class MyOneVersusAllMincutGainAlgo : public MyOneVersusAllGainAlgo
{
protected:
  // set states of nodesToAnnotate based on sinkSideNodes.
  void _setStates(const MyNodeIdList &nodesToAnnotate, const set< MyNodeId > &sinkSideNodes);

public:

  virtual ~MyOneVersusAllMincutGainAlgo()
    {}

//  static
  virtual string getName()
    {
      return("OneVersusAllMincut");
    }

  // i need to implement this method just so that i can call the
  // computeState method for this class and not for the parent class.
  virtual void run(const MyNodeIdList &nodesToAnnotate);

};


class MyOneVersusAllSemiHierarchicalHopfieldGainAlgo : public  MyOneVersusAllHopfieldGainAlgo
{
protected:
  // history of results.
//  map< BioFunction, map< MyNodeId, MyGainTriStateInfo > > _allStateWeights;
  map< BioFunction, map< MyNodeId, MyGainTriStateType > > _allInitialStates;
  map< BioFunction, map< MyNodeId, MyGainTriStateType > > _allFinalStates;
  // permutation of nodes.
  vector< MyNodeId > _globalNodePermutation;
  // mapping from node id to position in the permutation.
  map< MyNodeId, unsigned int > _globalNodePermutationMap;


  // for each function, count the number of its children that the
  // algorithm has processed. _storeResults() uses this variable to
  // reclaim memory
  map< GOFunction *, unsigned int > _numProcessedChildren;

  // counts of numbers stored in the next two maps.
  unsigned int _numStatesFixedAtStart;
  // map from function ids to genes storing those function-gene pairs
  // for which i am able to fix the state while initialising node
  // states.
  map< string, set < string > > _statesFixedAtStart;

public:
  MyOneVersusAllSemiHierarchicalHopfieldGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r,
                                                 GeneOntology *go)
      : MyOneVersusAllHopfieldGainAlgo(g, a, p, r, go),
//        _allStateWeights(),
        _allFinalStates(), _allInitialStates(),
        _globalNodePermutation(), _globalNodePermutationMap(),
        _numProcessedChildren(), _numStatesFixedAtStart(0),
        _statesFixedAtStart()
    {}

  virtual ~MyOneVersusAllSemiHierarchicalHopfieldGainAlgo()
    {}

//   virtual void computeCrossValidationResults(const BioFunction &function,
//                                              const MyNodeIdList &cvNodes);

//   virtual void computePredictionProbabilities(const BioFunction &function);

  // the only reason for implementing this method in this class is to
  // have some place to store the results for the current function in
  // _allStateWeights.
  virtual void computePredictions(const BioFunction &function,
                                  const MyNodeIdList &nodesToAnnotate,
                                  MyNodeIdList &predictedNodes);

  virtual void initialiseNodeStates(const BioFunction &function,
                                    MyNodeIdList &nodesToAnnotate);

//  static
  virtual string getName()
    {
      return("OneVersusAllSemiHierarchicalHopfield");
    }
  virtual void initialiseAlgorithm()
    {
      MyGraph::NodeIterator nitr = _graph.nodes();
      // i have the graph. create a random permutation of the nodes.
      while (nitr.hasNext())
        _globalNodePermutation.push_back(nitr.next().getId());
      random_shuffle(_globalNodePermutation.begin(), _globalNodePermutation.end());
      unsigned int index = 0;
      // compute map from node id to index in the permutation.
      for (vector< MyNodeId >::iterator gnpItr = _globalNodePermutation.begin();
           gnpItr != _globalNodePermutation.end(); gnpItr++)
        _globalNodePermutationMap[*gnpItr] = index++;
    }

  virtual void printStatistics(ostream &statsStream);

//   virtual void run(const MyNodeIdList &nodesToAnnotate);

protected:
    
  // store the current value of _states as results
  void _storeResults(const BioFunction &function);
};


class MyOneVersusAllHierarchicalHopfieldGainAlgo : public  MyOneVersusAllSemiHierarchicalHopfieldGainAlgo
{
protected:

public:
  MyOneVersusAllHierarchicalHopfieldGainAlgo(MyGainGraph &g, MyAnnotations &a,
                                             MyGainParams &p, Reporter &r, GeneOntology *go)
      : MyOneVersusAllSemiHierarchicalHopfieldGainAlgo(g, a, p, r, go)
    {
    }

  virtual ~MyOneVersusAllHierarchicalHopfieldGainAlgo()
    {}

//   virtual void computeCrossValidationResults(const BioFunction &function,
//                                              const MyNodeIdList &cvNodes);

//   virtual void computePredictionProbabilities(const BioFunction &function);

//   virtual void computePredictions(const BioFunction &function,
//                                   const MyNodeIdList &nodesToAnnotate,
//                                   MyNodeIdList &predictedNodes);

//   virtual void initialiseNodeStates(const BioFunction &function,
//                                     MyNodeIdList &nodesToAnnotate);

//  static
  virtual string getName()
    {
      return("OneVersusAllHierarchicalHopfield");
    }


//   virtual void run(const MyNodeIdList &nodesToAnnotate);

};


typedef map< MyNodeId, unsigned int> MyFeatureNumberMap;
typedef map< unsigned int, MyNodeId > MyFeatureNameMap;
typedef map< MyNodeId, double > MyVectorWeightMap;
typedef map< unsigned int, double > MySeparatorCoefficientMap;
typedef enum {SUPERVISED, SEMI_SUPERVISED} MyLearnMode;

class MyOneVersusAllAbstractSVMGainAlgo : public MyOneVersusAllGainAlgo
{
        protected:
                string trainBinaryFilename;
                string trainArgs;
                string trainInputFilename;
                string modelFilename;
                string testBinaryFilename;
                string testArgs;
                string testInputFilename;
                string testOutputFilename;

                MyFeatureNumberMap _featureNameToNumber;
                MyFeatureNameMap _featureNumberToName;
                MyVectorWeightMap _vectorWeights;
                MySeparatorCoefficientMap _separatorCoefficients;
                double _threshold;
                MyLearnMode _learnMode;
                bool _onboardPrediction;

                virtual void _train (const MyNodeIdList &nodesToAnnotate);
                virtual void _predict (const MyNodeIdList &nodesToAnnotate);

                virtual void _createTrainInputFile (const MyNodeIdList &nodesToAnnotate);

                virtual void _createTestInputFile (const MyNodeIdList &nodesToAnnotate);

                virtual void _readTestOutputFile (const MyNodeIdList &nodesToAnnotate);

                virtual void _createSVMOutputLine(ostream &ostr, MyGainTriStateType state, MyNode &node, bool includeHypothetical);

                virtual void _addComment (ostream &ostr, MyNode &node) = 0;

                virtual void _readModelFile () = 0;

                virtual double _calculateSVMResult (MyNode &node);

                virtual void _clearMaps();

        public:
                MyOneVersusAllAbstractSVMGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL);

                virtual void run(const MyNodeIdList &nodesToAnnotate);

                virtual void visualiseCut(const BioFunction &currentFunction, MyNodeIdList &predictedNodes);

                virtual void visualiseCVTemp(const BioFunction &currentFunction, MyNodeIdList &nodesToAnnotate);

                virtual void setCrossValidationList(MyNodeIdList &nodesToAnnotate, const MyNodeIdList &cvList);

        private:

};





class MyOneVersusAllLibSVMGainAlgo : public MyOneVersusAllAbstractSVMGainAlgo
{
        protected:
                virtual void _addComment (ostream &ostr, MyNode &node) {}

                virtual void _readModelFile () {_onboardPrediction = 0;}

        public:
                MyOneVersusAllLibSVMGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
                : MyOneVersusAllAbstractSVMGainAlgo(g, a, p, r, go)
                {
                        trainBinaryFilename = _params.getLibSVMDirectory() + "svm-train";
                        if ("" == (trainArgs =  _params.getLibSVMTrainOptions())) trainArgs = "-t 0 -c 674";
                        trainInputFilename = _params.getOutputDirectory() + "LIBSVM_TRAIN";
                        modelFilename = _params.getOutputDirectory() + "LIBSVM_MODEL";
                        testBinaryFilename = _params.getLibSVMDirectory() + "svm-predict";
                        testArgs = _params.getLibSVMTestOptions();
                        testInputFilename = _params.getOutputDirectory() + "LIBSVM_TEST";
                        testOutputFilename = _params.getOutputDirectory() + "LIBSVM_OUT";
                }

                virtual string getName()
                {
                        return("OneVersusAllLibSVM");
                }

        private:
};


class MyOneVersusAllSVMLightGainAlgo : public MyOneVersusAllAbstractSVMGainAlgo
{
        protected:
                virtual void _addComment (ostream &ostr, MyNode &node)
                {
                        ostr << "# " << node.getId();
                }

                virtual void _readModelFile ();

        public:
                MyOneVersusAllSVMLightGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
                : MyOneVersusAllAbstractSVMGainAlgo(g, a, p, r, go)
                {
                        trainBinaryFilename = _params.getSVMLightDirectory() + "svm_learn";
                        if ("" == (trainArgs = _params.getSVMLightTrainOptions())) trainArgs = "";//"-b 0 -c 1.5";
                        trainInputFilename = _params.getOutputDirectory() + "SVMLIGHT_TRAIN";
                        modelFilename = _params.getOutputDirectory() + "SVMLIGHT_MODEL";
                        testBinaryFilename = _params.getSVMLightDirectory() + "svm_classify";
                        testArgs = _params.getSVMLightTestOptions();
                        testInputFilename = _params.getOutputDirectory() + "SVMLIGHT_TEST";
                        testOutputFilename = _params.getOutputDirectory() + "SVMLIGHT_OUT";
                }

                virtual string getName()
                {
                        return("OneVersusAllSVMLight");
                }

        private:

};

class MyOneVersusAllSVMLightTransductiveGainAlgo : public MyOneVersusAllSVMLightGainAlgo
{
        protected:
        public:
                MyOneVersusAllSVMLightTransductiveGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
                : MyOneVersusAllSVMLightGainAlgo(g, a, p, r, go)
                {
                        _learnMode = SEMI_SUPERVISED;
                        trainArgs = _params.getSVMLightTrainOptions();
                }

                virtual string getName()
                {
                        return("OneVersusAllSVMLightTransductive");
                }

        private:

};

class MyOneVersusAllSinkSourceGainAlgo : public MyOneVersusAllGainAlgo
{
protected:
  const MyNT _ANN_RES, _HYP_RES, _NOT_RES;
  // map from node id to evidence code to weight, used to compute the
  // weight of the evidence codes that say that a node has a
  // particular function. I use this variable in MyOneVersusAllSinkSourceGainAlgo::initialiseNodeStates().
  //
  // tmm: 2010-02-16. I don't this need this any more, since I am just
  // getting the final weight directly from MyAnnotations. However,
  // there is no one unclear use of this variable in
  // MyOneVersusAllSinkSourceGainAlgo::run(), which I need to
  // understand before I can abolish this variable forever.
  map< string, map< string, MyNT > > _helperWeights;

  // edge weight for artificial sink
  MyNT _lambda;
  // edge weight for artificial source
  MyNT _mu;

  virtual void _applyArtificialSink(const MyNode &node, MyNT &num, MyNT &den)
  {
          // apply artificial sink to any node initially in not-annotated state
          bool isNotAnnotated(NOT_ANNOTATED_STATE == _initialStateTypes[node.getId()]);
          num += MyNT(isNotAnnotated)*_lambda*_NOT_RES;
          den += MyNT(isNotAnnotated)*_lambda;
  }

  virtual void _applyArtificialSource(const MyNode &node, MyNT &num, MyNT &den)
  {
          // apply artificial source to any node initially in annotated state
          bool isAnnotated(ANNOTATED_STATE == _initialStateTypes[node.getId()]);
          num += MyNT(isAnnotated)*_mu*_ANN_RES;
          den += MyNT(isAnnotated)*_mu;
  }

public:
  MyOneVersusAllSinkSourceGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
      : MyOneVersusAllGainAlgo(g, a, p, r, go), _ANN_RES(1), _HYP_RES(0), _NOT_RES(0), _helperWeights(), _lambda(0), _mu(0)
    {}

  virtual ~MyOneVersusAllSinkSourceGainAlgo()
    {}

  virtual void maskNodeStates(const MyNodeIdList &nodes);

  virtual void initialiseNodeStates(const BioFunction &function,
                                    MyNodeIdList &nodesToAnnotate);


  virtual void computePredictions(const BioFunction &function,
                                  const MyNodeIdList &nodesToAnnotate,
                                  MyNodeIdList &predictedNodes);

  virtual void computeCrossValidationResults(const BioFunction &function,
                                             const MyNodeIdList &cvNodes);

  virtual MyGainTriState computeState(MyNode &node);

  virtual bool hasConverged(const MyNodeIdList& nodes);

//  static
  virtual string getName()
    {
      return("OneVersusAllSinkSource");
    }

  virtual void run(const MyNodeIdList &nodesToAnnotate);

};

#ifdef HAVE_LIBGSL
class MyOneVersusAllSinkSourceDirectGainAlgo : public MyOneVersusAllSinkSourceGainAlgo
{
protected:
        gsl_matrix *A;
        gsl_permutation *P;
        gsl_vector *x;
        int *signum;
        map< MyNodeId, size_t > nodeIndices;
public:
  MyOneVersusAllSinkSourceDirectGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
      : MyOneVersusAllSinkSourceGainAlgo(g, a, p, r, go), A(), P(), x(), signum(new(int)), nodeIndices()
    {}

  virtual ~MyOneVersusAllSinkSourceDirectGainAlgo()
    {
                        delete(signum);
    }

//  static
  virtual string getName()
    {
      return("OneVersusAllSinkSourceDirect");
    }

  virtual void run(const MyNodeIdList &nodesToAnnotate);
};
#endif //HAVE_LIBGSL




class MyOneVersusNoneSinkSourceGainAlgo : public MyOneVersusAllSinkSourceGainAlgo
{
protected:

  virtual void _applyArtificialSink(const MyNode &node, MyNT &num, MyNT &den)
  {
          // apply artificial sink to any node initially in hypothetical state
          bool isHypothetical(HYPOTHETICAL_STATE == _initialStateTypes[node.getId()]);
          num += MyNT(isHypothetical)*_lambda*_NOT_RES;
          den += MyNT(isHypothetical)*_lambda;
  }

public:
  MyOneVersusNoneSinkSourceGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
      : MyOneVersusAllSinkSourceGainAlgo(g, a, p, r, go)
    {
      _lambda = p.getOneVersusNoneSinkSourceArtificialEdgeWeight();
    }

  virtual ~MyOneVersusNoneSinkSourceGainAlgo()
    {}


  virtual string getName()
    {
      return("OneVersusNoneSinkSource");
    }

  virtual void initialiseNodeStates(const BioFunction &function,
                                    MyNodeIdList &nodesToAnnotate);

  virtual void setCrossValidationList(
    MyNodeIdList &nodesToAnnotate, const MyNodeIdList &cvList);

};


class MyOneVersusNoneFunctionalFlowGainAlgo : public MyOneVersusNoneGainAlgo
{
protected:
  // a map from a node to the size of the reservoir at that node. the
  // _states variable will take care of the total inflow into the
  // node.
  map< MyNodeId, MyNT > _currentNodeReservoirs, _previousNodeReservoirs;
  // a map from a node to the total flow into the node. this variable
  // is just a helper (for debugging, to make sure that _states stores
  // the right info).
  map< MyNodeId, MyNT > _totalInflow;

public:
  MyOneVersusNoneFunctionalFlowGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
      : MyOneVersusNoneGainAlgo(g, a, p, r, go), _currentNodeReservoirs(), _previousNodeReservoirs()
    {}

  virtual ~MyOneVersusNoneFunctionalFlowGainAlgo()
    {}

  virtual void computePredictions(const BioFunction &function,
                                  const MyNodeIdList &nodesToAnnotate,
                                  MyNodeIdList &predictedNodes);

  virtual MyGainTriState computeState(MyNode &node);


//  static
  virtual string getName()
    {
      return(string("OneVersusAllFunctionalFlow") + "-nr-" + boost::lexical_cast< string >(_params.getNumRounds()));
    }

  virtual void run(const MyNodeIdList &nodesToAnnotate);
};

#if(0)
class MyOneVersusAllHeavisideGainAlgo : public MyOneVersusAllToNoneGainAlgo
{
private:
    // this map stores the computed node thresholds. this map also keeps
  // track of which nodes i have already processed, so that i can
  // avoid processing them again. (a node may have multiple entries in
  // the pq, since it can get inserted whenever one of its neighbours
  // changes to a 1.)
  map< MyNodeId, MyNT > _nodeThresholds;

public:
  MyOneVersusAllHeavisideGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
      : MyOneVersusAllToNoneGainAlgo(g, a, p, r, go)
    {}

  virtual ~MyOneVersusAllHeavisideGainAlgo()
    {}

  virtual void computePredictions(const BioFunction &function,
                                  const MyNodeIdList &nodesToAnnotate,
                                  MyNodeIdList &predictedNodes);
//   template< typename StateType >
//   MyGainState< StateType > computeState(MyNode &node);
  virtual MyGainTriState computeState(MyNode &node);

//  virtual bool hasConverged(const MyNodeIdList &nodesToAnnotate);

//  static
  virtual string getName()
    {
      return("OneVersusAllHeaviside");
    }

  virtual void run(const MyNodeIdList &nodesToAnnotate);
};
#endif

class MyOneVersusNoneLocalGainAlgo : public MyOneVersusNoneGainAlgo
{
protected:

public:
  MyOneVersusNoneLocalGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
      : MyOneVersusNoneGainAlgo(g, a, p, r, go)
    {}

  virtual ~MyOneVersusNoneLocalGainAlgo()
    {}

  virtual MyGainTriState computeState(MyNode &node);


//  static
  virtual string getName()
    {
      return("OneVersusNoneLocal");
    }
  virtual void run(const MyNodeIdList &nodesToAnnotate);
};


class MyOneVersusAllGeneManiaGainAlgo : public MyOneVersusAllGainAlgo
{
 protected:
  const MyNT _ANN_RES, _NOT_RES;
  //when 1, geneMania algorithm will run exactly like SinkSource
  //to ensure the same output is obtained
  //when 0, geneMania will run as outlined in the paper
  const unsigned int sinkSourceTest;
 public:
  MyOneVersusAllGeneManiaGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
      : MyOneVersusAllGainAlgo(g, a, p, r, go), _ANN_RES(1), _NOT_RES(-1), sinkSourceTest(0)
    {}

  //bias for unknown nodes, (pos - neg)/total, called k in (Mostafavi, et al, 2008)
  MyNT hypotheticalNodeBiasValue;

  virtual ~MyOneVersusAllGeneManiaGainAlgo()
    {}

  virtual void maskNodeStates(const MyNodeIdList &nodes);

  virtual void initialiseNodeStates(const BioFunction &function,
                                    MyNodeIdList &nodesToAnnotate);


  virtual void computePredictions(const BioFunction &function,
                                  const MyNodeIdList &nodesToAnnotate,
                                  MyNodeIdList &predictedNodes);

  virtual void computeCrossValidationResults(const BioFunction &function,
                                             const MyNodeIdList &cvNodes);

  virtual MyGainTriState computeState(MyNode &node);

  virtual MyGainTriState computeStateImplicit(MyNode &node);

  virtual bool hasConverged(const MyNodeIdList& nodes);


  virtual void setCrossValidationList(MyNodeIdList &nodesToAnnotate, const MyNodeIdList &cvList);

  virtual void redoBias();


//  static
  virtual string getName()
    {
      return("OneVersusAllGeneMania");
    }

  virtual void run(const MyNodeIdList &nodesToAnnotate);

};

#if(0)
class MyOneVersusNoneGeneManiaGainAlgo : public MyOneVersusAllGeneManiaGainAlgo
{
protected:
  const MyNT _ANN_RES, _NOT_RES;
  //when 1, geneMania algorithm will run exactly like SinkSource
  //to ensure the same output is obtained
  //when 0, geneMania will run as outlined in the paper
  const unsigned int sinkSourceTest;
  MyNT artificialEdgeWeight;


public:
  MyOneVersusNoneGeneManiaGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
      : MyOneVersusAllGeneManiaGainAlgo(g, a, p, r, go), _ANN_RES(1), _NOT_RES(0), sinkSourceTest(0)
    {
        artificialEdgeWeight = p.getOneVersusNoneSinkSourceArtificialEdgeWeight();
    }


  virtual string getName()
    {
      return("OneVersusNoneGeneMania");
    }

  virtual void initialiseNodeStates(const BioFunction &function,
                                    MyNodeIdList &nodesToAnnotate);

  virtual void maskNodeStates(const MyNodeIdList &nodes);

  virtual MyGainTriState computeState(MyNode &node);

  virtual void computeCrossValidationResults(const BioFunction &function,
                                                            const MyNodeIdList &cvNodes);

};
#endif

#if 0
class MyOneVersusNoneAnnotationCountGainAlgo : public MyOneVersusNoneGainAlgo
{
protected:

public:
        MyOneVersusNoneAnnotationCountGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
      : MyOneVersusNoneGainAlgo(g, a, p, r, go)
    {}

  virtual ~MyOneVersusNoneAnnotationCountGainAlgo()
    {}

  virtual MyGainTriState computeState(MyNode &node)
  {
          MyNT score(0);
          int count(0);
          set< string > functions;
          _annotations.getAnnotationsForGene("", node.getId(), functions);
          for (set< string >::iterator fitr = functions.begin(); fitr != functions.end(); fitr++)
          {
                  if (_go->getFunctionById(*fitr)->getMinimumDepth() < 1)
                          continue;
                  unsigned int in(_annotations.numAnnotatedGenes(_annotations.getFunctionType(*fitr), *fitr));
                  unsigned int total(_graph.numNodes());
                  score += 1.0/(in);//*(total - in));
                  count++;
          }
          return(MyGainTriState(ANNOTATED_STATE, count));
  }

  virtual bool hasConverged(const MyNodeIdList &nodesToAnnotate)
  {
          return(true);
  }

  virtual string getName()
    {
      return("MyOneVersusNoneAnnotationCountGainAlgo");
    }
};


class MyOneVersusNoneNodeDegreeGainAlgo : public MyOneVersusNoneGainAlgo
{
protected:

public:
        MyOneVersusNoneNodeDegreeGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
      : MyOneVersusNoneGainAlgo(g, a, p, r, go)
    {}

  virtual ~MyOneVersusNoneNodeDegreeGainAlgo()
    {}

  virtual MyGainTriState computeState(MyNode &node)
  {
          return(MyGainTriState(ANNOTATED_STATE, node.getWeightedDegree()));
  }

  virtual bool hasConverged(const MyNodeIdList &nodesToAnnotate)
  {
          return(true);
  }

  virtual string getName()
    {
      return("MyOneVersusNoneNodeDegreeGainAlgo");
    }
};

class MyOneVersusNoneRandomScoreGainAlgo : public MyOneVersusNoneGainAlgo
{
protected:

public:
        MyOneVersusNoneRandomScoreGainAlgo(MyGainGraph &g, MyAnnotations &a, MyGainParams &p, Reporter &r, GeneOntology *go = NULL)
      : MyOneVersusNoneGainAlgo(g, a, p, r, go)
    {}

  virtual ~MyOneVersusNoneRandomScoreGainAlgo()
    {}

  virtual MyGainTriState computeState(MyNode &node)
  {
          return(MyGainTriState(ANNOTATED_STATE, 1.0*rand()/RAND_MAX));
  }

  virtual bool hasConverged(const MyNodeIdList &nodesToAnnotate)
  {
          return(true);
  }

  virtual string getName()
    {
      return("MyOneVersusNoneRandomScoreGainAlgo");
    }
};
#endif

#endif //_GAIN_ALGORITHM_H