| AbstractSingleReconciliation | This is an abstract class for reconciliation algorithms |
| ActiveNetwork | Stores a single ActiveNetwork. The class is a subclass of MyGraph. The class stores the experimental conditions associated with an ActiveNetwork, the set of biological functions enriched in the nodes of the ActiveNetwork |
| anid_index | |
| Apriori | A class that implements the Apriori algorithm for computing itemsets in binary matrix. This class computes closed itemsets. It also computes the lattice connecting the closed itemsets. ! |
| AprioriWithComplement | A class that implements the Apriori algorithm with "complements". The user passes a binary matrix to the constructor. For each row in the matrix, the constructor adds the complement of the row to the matrix. The computeItemsets() method computes itemsets in this augmented matrix with one constraint: every computed itemset will contain at least one original (non-complemented) row. Since most matrices are sparse (they contain very few ones), the complement rows contain a very large number of ones. There could be a very large number of itemsets containing only complement rows. This constraint prevents the algorithm from computing these itemsets. ! |
| PosLattice::assoc | |
| assoc | |
| GenericLattice::assoc | |
| BinaryMatrix | This class wraps an ifstream and handles reading data from a truth matrix |
| BioFunction | A simple class representing a biological function, storing the name of the function (e.g., "response to stress" and its category (e.g., "biological_process"). The goal of this class is to represent all descriptors used to group biological molecules together |
| MyAnnotations::BioFunctionsConstIterator | A class that iterates over all functions of a particular type. It contains the methods hasNext() and next() to sustain the advance. This iterator cannot be used to modify the instance of MyAnnotations on which it is invoked |
| MyAnnotations::BioFunctionsIterator | A class that iterates over all functions of a particular type. It contains the methods hasNext() and next() to sustain the advance. This iterator can be used to modify the instance of MyAnnotations on which it is invoked |
| MyAnnotations::BioFunctionsIteratorMultiIndex | This class implements an iterator over all functions stored in an instance of MyAnnotations. The iterator automatically ranges over all function categories and within each category over all functions belonging to that category |
| BSEvaluator | This class evaluates a set of rowsets based on balance and support metrics |
| ChisqFilter | This class is the chisq filter that filters out truth tables based on important truth tables |
| cmdline_parser_params | The additional parameters to pass to parser functions |
| combineAND | |
| combineOR | |
| compareComplexes | |
| compareEntropies | |
| TreeDecomposition::compareFillInRatioValues | |
| TreeDecomposition::compareFillInValues | |
| compareIntsLexicographically | |
| compareMaximumSpanningTree | |
| compareMinimumSpanningTree | |
| compareMyCoords | |
| compareMyIntervals | |
| compareMyPQNodes | |
| compareMyPQNodesDense | |
| compareRankedCoords | |
| ItemSetTree< t >::ConstIterator | |
| DAG< NodeType > | |
| DAGNode< NodeInfo > | An object that represents a node in a Directed Acyclic Graph (DAG). NodeInfo is a class that can store extra information for each node |
| database | |
| DetailedCVResult | A struct storing detailed information on the cross-validation result for a single gene-function pair. ! |
| distance_Euclidean | |
| distance_squared_Euclidean | |
| DualMiner | This class takes an input stream of a matrix data file and analyzes the the independence of the columns It uses the lattice class to only count the "all positive" bitpatterns |
| DummyClass | |
| EdgeGroupHyp | This is the same as GroupHypAlgorithm, but it operates on edges instead of nodes |
| MyNode::EdgeObjectIterator< Object, ObjectPtr > | |
| MyGraph::EdgeObjectIterator< Object, ObjectPtr > | |
| Graphwhiz::EdgeType | |
| Enrichment< S, T > | Enrichment Class |
| EnrichmentPostprocess | Has methods for processing previously computed enrichment results |
| EnrichmentRecord< S, T > | |
| eqis | |
| eqstr | |
| evaluation_summaries_algorithm_index | |
| Evaluator | This class takes an input stream of a matrix data file and analyzes the the independence of the columns |
| exponentNegativeTransform | Given an argument x, return exp(-x) |
| Filter | This class is an abstract class for a filter that looks at existing truth tables and decides if they are important |
| FilterPool | This class is a pool of filters that widdle down existing truth tables to important truth tables |
| FuncAssociate | This class implements the FuncAssociate enrichment method: http://bioinformatics.oxfordjournals.org/cgi/content/abstract/19/18/2502 |
| FuncEquivFilter | This class is the partition distance filter that finds similar truth tables |
| FunctionalAnnotation | A struct that stores a (gene, function, evidence code) triple. If a gene-function pair has multiple evidence codes, the pair should have distinct instances of this struct in the multi_index that will store different instances of this struct |
| FunctionalEnrichmentAlgorithm | This is an abstract algorithm for functional enrichment |
| FunctionalEnrichmentAlgorithmDispatcher | Has methods for dispatching functional enrichment algorithms |
| Graphwhiz::FunctionType | |
| Graphwhiz::Geewhiz | |
| GeewhizManager | |
| GeneMANIA | This class implements the GeneMANIA algorithm |
| GeneOntology | |
| GenericLattice | This class holds a table of item sets. It is important to maintain a hash hash table and a vector at the same time to manage fast lookups and keep everything in order |
| GenericOptions | A generic class for parsing command-line parameters. This class defines common command line options and stores them based on the values in the arguments to the set() method |
| gengetopt_args_info | Where the command line options are stored |
| GenGOAlgorithm | This class implements the GenGO functional enrichment algorithm from the following paper: http://www.ncbi.nlm.nih.gov/pubmed/18676451 |
| GnuplotDataFile | A simple struct to store information on a data file to plot and which portions of the file to plot |
| GnuplotFileGenerator | A class to store information on which data to plot and how to generate the plot. The class also contains methods to generate a file containing gnuplot commands and to invoke gnuplot on such a file |
| GOEvidenceCodes | |
| GOFunction | |
| greedySetCover | |
| GroupHypAlgorithm | This class implements an enrichment method similar to the GenGO method (see http://www.ncbi.nlm.nih.gov/pubmed/18676451). However, instead of maximizing the log-likelihood function discussed in the GenGO paper, GroupHypAlgorithm minimizes the hypergeometric p-value for a given set of functions. Initially, all functions are inactive. We try all possible one-function changes (i.e., remove or add a single function) to the current set of active functions. By treating the collection of active functions as a single function, we can see if the addition or removal of any function causes the group p-value to decrease. If so, we add or remove that function and repeat |
| hash< T > | |
| hash< const ItemSet * > | |
| hash< const Itemset * > | |
| hash< const ItemSet > | |
| hash< const unsigned int * > | |
| __gnu_cxx::hash< double > | |
| __gnu_cxx::hash< MyString > | |
| __gnu_cxx::hash< string > | |
| hassoc | |
| HeatKernel | This class implements the HeatKernel algorithm |
| HPosMiner | This class takes an input stream of a matrix data file and analyzes the the independence of the columns |
| HypergeometricAlgorithm | This class implements the set-based hypergeometric algorithm for computing functional enrichment |
| HypergeometricAlgorithm::hypergeometricEnrichmentResult | This structure stores various enrichment results calculated during functional enrichment. Any p-values that are computed will be stored in this structure along with their associated function |
| ImprovedBounder | The improved KK |
| inverseNormalPvalueTransform | |
| Itemset | This class holds a set of items (column numbers) |
| itemset | |
| ItemSet | This class holds a set of items (column numbers) |
| ItemsetLevel< t > | This class holds all the itemsets at a given level It can keep the items ordered or assume they are being added in order |
| ItemSetMap< t > | This class holds a table of item sets. It is important to maintain a hash hash table and a vector at the same time to manage fast lookups and keep everything in order |
| ItemsetRange | |
| ItemSetTree< t > | This class holds a set of items (column numbers) |
| ItemSetTree< t >::Iterator | |
| KKBounder | The standard KK bounder |
| Lattice | This class holds a table of item sets. It is important to maintain a hash hash table and a vector at the same time to manage fast lookups and keep everything in order |
| LatticeFilter | This class computes a graph that represents a specific subset of the lattice containing all TTs. Each maximal TT has a node in the graph. In addition, for every pair X and Y of such TTs, let Z be the TT formed by the intersection of the columns in X and Y. If Z is not empty, the graph contains an edge from Z to X and from Z to Y |
| LatticeMiner | This class analyzes truth matrices one level at a time in order |
| LevelwiseMiner | This class analyzes truth matrices one level at a time in order |
| LevItemSetMap< t > | This class holds a table of item sets. It is important to maintain a hash hash table and a vector at the same time to manage fast lookups and keep everything in order |
| LogHelper | A class to quickly compute factorial logs and estimate factorial logs using Stirling's approximation |
| ltis< T > | |
| ltis< const ItemSet * > | |
| ltis< const Itemset * > | |
| ltis< const ItemSet > | |
| ltstr | |
| MafiaMiner | This class takes an input stream of a matrix data file and analyzes the the independence of the columns |
| MCODE | |
| Miner | This class takes an input stream of a matrix data file and analyzes the the independence of the columns |
| Monitorable | The abstract monitorable class |
| motif | |
| motifDataset | |
| MTRand | |
| my_Time | |
| MyAbstractAnnealState | A class that abstracts the functionality of a state in simulated annealing |
| MyAbstractGainAlgo< StateType > | |
| MyAbstractGraphModification | An abstract class to keep track of updates to a graph. The design is to encapsulate each type of update in its own sub-class. An example of an update is the addition or deletion of a single node or edge. The key member function is reverse(), which allows the update to be reversed on its argument. ! |
| MyAffyFileFormat | |
| MyAffyGene | |
| MyAnnotations | |
| MyBCModifiedDijkstraVisitor | |
| MyBFS< Graph, BFSVisitor > | |
| MyBox | |
| MyCluster | |
| MyClusterLess | |
| MyClusterMore | |
| MyClusterParams | |
| MyClusterSet | |
| Graphwhiz::MyColor | |
| MyComponentsBFSVisitor | |
| MyComponentsDFSVisitor | |
| MyContext | |
| MyDefaultBFSVisitor | |
| MyDefaultDFSVisitor | |
| MyDefaultDijkstraVisitor | |
| MyDensestSubgraphAnnealState | A subgraph of MyAbstractAnnealState that computes the most heavy subgraph of a graph. The heavy subgraph need not be connected |
| MyDensestSubgraphConnectedBruteForceAnnealState | A class that ensures that the dense subgraph computed is connected. It computes the connected components of every random neighbour and repeatedly invokes computeRandomNeighbour() until the neighbour is connected. ! |
| MyDFS< Graph, DFSVisitor > | |
| MyDijkstra< Graph, DijkstraVisitor > | |
| MyDimensionInterval | |
| MyEdge | |
| MyEdgeBetweenessDijkstra< Graph, DijkstraVisitor > | |
| MyEdgeBetweenessDijkstraVisitor | |
| SetOfEdgeTypeWeights< GroupType >::MyEdgeTypeWeight | |
| MyEndsBFSVisitor | |
| MyEvalGainParams | |
| MyGainDAGDistanceType | A struct that represents the distance between two functions in a DAG. The struct does not store any information about the two functions themselves. However, the struct represents the length of a path from one function to another by traversing some distance up the DAG from the first function to a least common ancestor and then traversing some distance down the DAG to the second function. ! |
| MyGainGraph | |
| MyGainMinCutInfo | |
| MyGainOrf | |
| MyGainParams | |
| MyGainReduce2DFSVisitor | |
| MyGainState< StateType > | |
| MyGainStateInfo< StateType > | |
| MyGenericParams | An abstract base class for programme command-line option parameters |
| MyGraph | A class that stores an undirected graph |
| MyGraphEdgeDeletion | A class that stores the edge deleted from a graph. ! |
| MyGraphEdgeInsertion | A class that stores the edge inserted into a graph. ! |
| MyGraphInfo | |
| MyGraphNodeDeletion | A class that stores the node deleted (and all the edges incident on it) from a graph. ! |
| MyGraphNodeInsertion | A class that stores the node inserted into a graph. ! |
| SetOfGroupedNodes< GroupType >::MyGroupedNode | |
| MyHistogram | A simple class to create and manipulate histograms |
| MyInfo | |
| MyInterval | |
| MyIterator< T > | |
| MyKeyClusterParams | |
| MyKMeansAlgo< MyKMeansPointType > | |
| MyKMeansClusterType< MyPointType > | |
| MyKMeansInfo | |
| MyMainDijkstraVisitor | |
| MyModifiedDijkstra< Graph, DijkstraVisitor > | |
| MyNode | |
| TreeDecomposition::MyNodeFillInRatioPQNode | |
| MyGraph::MyNodeIterator | |
| MyOneVersusAllAbstractSVMGainAlgo | |
| MyOneVersusAllGainAlgo | An algorithm where one label/function competes against an army of all the other labels/functions |
| MyOneVersusAllGainAlgoPropagationBFSVisitor | |
| MyOneVersusAllGeneManiaGainAlgo | This class is a subclass of MyOneVersusAllGainAlgo class which implements the GeneMANIA algorithm (Mostafavi, et al, 2008). This algorithm is a ---------- algorithm where the discriminant values of the negative and positive examples are allowed to change throught the running of the algorithm |
| MyOneVersusAllHierarchicalHopfieldGainAlgo | |
| MyOneVersusAllHopfieldGainAlgo | |
| MyOneVersusAllLibSVMGainAlgo | |
| MyOneVersusAllLocalGainAlgo | |
| MyOneVersusAllMincutGainAlgo | |
| MyOneVersusAllSemiHierarchicalHopfieldGainAlgo | |
| MyOneVersusAllSinkSourceGainAlgo | |
| MyOneVersusAllSVMLightGainAlgo | |
| MyOneVersusAllSVMLightTransductiveGainAlgo | |
| MyOneVersusAllToNoneGainAlgo | This class adapts MyOneVersusAllGainAlgo to work in the "one-versus-none" domain |
| MyOneVersusNoneFunctionalFlowGainAlgo | |
| MyOneVersusNoneGainAlgo | |
| MyOneVersusNoneGeneManiaGainAlgo | This class is a subclass of MyOneVersusAllGainAlgo class which implements the GeneMANIA algorithm (Mostafavi, et al, 2008). This algorithm is a ---------- algorithm where the discriminant values of the negative and positive examples are allowed to change throught the running of the algorithm. This version does NOT allow negative examples and the hypothetical bias value is computed as k = n+/n where n+ is the number of positive examples and n is the total number of nodes |
| MyOneVersusNoneHeavisideGainAlgo | This algorithm is subclass of MyOneVersusNoneGainAlgo. This algorithm computes node states that are either HYPOTHETICAL_STATE or ANNOTATED_STATE. It computes the weighted average of the states of the neighbours of a node, subtracts a (user-defined) threshold and applies the Heaviside function to the result. The Heaviside function is 0 for negative arguments and 1 for positive arguments |
| MyOneVersusNoneLocalGainAlgo | A subclass of MyOneVersusNoneGainAlgo that implements a guilt-by-association algorithm that does not use negative examples. See |
| MyOneVersusNoneShortestPathGainAlgo | A subclass of MyOneVersusNoneGainAlgo. This algorithm computes node states as the weighted average of the states of the neighbours of a node. In effect, it solves a linear system whose variables are the node states |
| MyOneVersusNoneSinkSourceGainAlgo | A subclass of MyOneVersusAllSinkSourceGainAlgo that implements a version of the SinkSource algorithm without negative examples |
| MyPoint | |
| MyPointInfo | |
| MyPointSet | Stores a set of points and information about the point's dimensions. This class is typically useful for storing one gene expression dataset |
| MyRand< MyNT > | |
| MyReallyAbstractGainAlgo | A super-duper rilly, rilly abstract class for function prediction algorithms in GAIN. This class only contains basic methods that all algorithms need |
| MySetOfPointSets | |
| MySetOfPointSetsIterator | |
| MySignificantInterval | |
| MySimulatedAnnealer< AnnealState > | A generic class for performing simulated annealing. It is templated by two classes: AnnealState stores information on a "state", e.g., a heavy path or a heavy subgraph, and AnnealMethod a class that takes a state and computes its neighbours |
| MyString | |
| MySubsetChange | |
| MyUniqueRandom< MyNT > | |
| MyWidthRange | |
| negativeLogTransform | Given an argument x, return -log(x) |
| NetMan | "manager" that controls the behaviour of the active-networks software by reading and storing command-line options and dispatching appropriate actions |
| NetworkLego | |
| NetworkLegoInActiveNetwork | A struct that stores a (network lego, active network, weight) triple. This triple indicates that the network lego contributes to the active network with the corresponding weight |
| nlid_anid_index | |
| nlid_index | |
| ItemSetTree< t >::node | |
| NodeElement | |
| Graphwhiz::NodeInfo | A struct that stores information about a particular node with a specific and unique name |
| MyGraph::NodeObjectIterator< Object, ObjectPtr > | |
| Graphwhiz::NodeType | A class that stores information about a particular node type. A node type contains information on how to draw all nodes belonging to that type. ! |
| oneMinusExponentNegativeTransform | Given an argument x, return 1 - exp(-x) |
| oneMinusTransform | Given an argument x, return (1 - x) |
| pa_nodeid_index | |
| pa_zscore_index | |
| PAGEAlgorithm | This class implements the Parametric Analysis of Gene Set Enrichment (PAGE) algorithm by Kim and Volsky, BMC Bioinformatics 2005: http://www.biomedcentral.com/1471-2105/6/144 |
| PageRank | This class implements the PageRank algorithm |
| passoc | |
| PatternBounder | This class bounds pattern candidates |
| PDistFilter | This class is the partition distance filter that finds similar truth tables |
| Point_d< NT > | |
| PosLattice | This class holds a table of item sets. It is important to maintain a hash hash table and a vector at the same time to manage fast lookups and keep everything in order |
| PosMiner | This class takes an input stream of a matrix data file and analyzes the the independence of the columns |
| PPNodeStats | |
| Prediction | |
| PredictionDetails | |
| PredictionEvaluation | A struct to store information on the evaluation of a prediction. ! |
| PredictionEvaluationSummary | A struct to store the summary of prediction evaluations for an algorithm. ! |
| PrioritizeNodes | |
| ProbeInfo | |
| rand_aggregate | |
| rand_gather | |
| RandomFunctionNetworkBasedEnrichmentAlgorithm | Calculates enrichment based on network connectivity using various randomization techniques by randomly selecting sets X, where the size of X is the number of nodes annotated with function f. This is repeated for each function |
| RandomUniverseNetworkBasedEnrichmentAlgorithm | Calculates enrichment based on network connectivity using various randomization techniques by randomizing the structure of the underlying universal graph |
| RankedCoord | |
| readfile | |
| Reporter | |
| Rotor | This class holds all the itemsets at a given level It can keep the items ordered or assume they are being added in order |
| sampleSorter | |
| SDAG | |
| SDAGNode | |
| SetCoverEnrichment | This class implements an enrichment algorithm based on set cover |
| SetOfActiveNetworks | Stores a set of ActiveNetworks, all of which share some property |
| SetOfEdgeTypeWeights< GroupType > | |
| SetOfGroupedNodes< GroupType > | |
| SetOfNetworkLegos | |
| SGraphFilter | This class is the partition distance filter that finds similar truth tables |
| SinkSource | This class implements the SinkSource algorithm |
| sort_hyp_enrich_results_less | |
| sort_pair_greater | |
| sort_pair_second_greater | |
| SPMiner | This class takes an input stream of a matrix data file and analyzes the the independence of the columns |
| StandardMiner | This class takes an input stream of a matrix data file and analyzes the the independence of the columns It uses the lattice class to only count the "all positive" bitpatterns |
| TopKMiner | This class takes an input stream of a matrix data file and analyzes the the independence of the columns It uses the lattice class to only count the "all positive" bitpatterns |
| toRightMyIntervals | |
| TreeDecomposition | A class that stores a tree decomposition |
| TreeMiner | This class takes an input stream of a matrix data file and analyzes the the independence of the columns |
| Treewidth | |
| TreeDecomposition::TreeWidthNodeSelector | An abstract base class that supports generic node selectors for those tree width algorithms that compute upper bounds by computing perfect elimination schemes. ! |
| TreeDecomposition::TreeWidthNodeSelectorMinDegree | A tree width selector that prefer nodes with the smallest degree. ! |
| TreeDecomposition::TreeWidthNodeSelectorMinFillIn | A tree width selector that prefer nodes with the smallest fill in, i. e., the number of neighbour-pairs that are not adjacent. ! |
| TreeDecomposition::TreeWidthNodeSelectorMinFillInRatio | A tree width selector that prefer nodes with the smallest fill in ratio, i. e., the number of neighbour-pairs that are not adjacent divided by the total number of neighbour pairs. ! |
| TruthMatrix | This class wraps an ifstream and handles reading data from a truth matrix |
| Vanilla | This class implements the Vanilla algorithm |
1.7.6.1
