All Classes and Interfaces
Class
Description
Abstract class for annotations.
This is a base class for bootstrap algorithms.
Abstract NB component.
Base class for variable specifications for DataSet.
Adds Javabean property change events so that it can be used in a MVC type architecture.
A confusion matrix for adjacencies--i.e.
The adjacency precision.
The adjacency precision.
The adjacency true positive rate.
The adjacency precision.
The adjacency recall.
The adjacency precision.
The adjacency precision.
The adjacency true positive rate.
An AD tree is a data structure used to store the data for a given dataset in a way that makes it easy to calculate
cell counts for a multidimensional contingency table for a given set of variables.
An implementation of a static AD tree based on Moore and Lee 1998 (mostly)
A test of the AD tree implementation.
Interface that algorithm must implement.
Sep 5, 2017 10:47:30 AM
Annotations for algorithms.
Algorithm descriptions.
Aug 30, 2017 3:14:40 PM
A list of algorithm to be compared.
Author : Jeremy Espino MD Created 6/30/17 10:36 AM
A class for heuristically removing almost cycles from a PAG to avoid unfaithfulness in an estimated PAG.
Calculates the F1 statistic for adjacencies.
Ancestor precision.
Ancestor recall.
The bidirected true positives.
The bidirected true positives.
Implements the Anderson-Darling test for normality, with P values calculated as in R's ad.test method (in package
nortest).
Represents a class that encapsulates a class along with its associated annotation.
Sep 6, 2017 11:11:38 AM
Calculates updated marginals for a Bayes net by simulating data and calculating likelihood ratios.
A confusion matrix for arrows--i.e.
The arrow precision.
The arrow precision.
The adjacency true positive rate.
The arrow precision.
The arrow precision.
The arrow recall.
The arrow recall.
The arrow precision.
The arrow precision.
The adjacency precision.
The adjacency precision.
Initializes a history array by setting the value of each variable to basal if it is unregulated (has no parents other
than itself one time step back) and to a random value chosen from a N(basal, initStDev) distribution otherwise.
Basic functionality that all graph-derived classes should provide.
Stores a time series in the "update" (rather than, say, the "repeated")
form--that is, for a given set of factors (the word "factor" is being used here to avoid ambiguity), only lags behind
the getModel time step are recorded temporally, with causal edges extending from lagged factors with lags >= 1 to
factors in the getModel time step (lag = 0) only.
Implements a space-efficient Lower Triangular Matrix of elements of type
shortBasic functionality of a Matrix
Wrapper for Basis Function BIC Score (Basis-BIC).
Calculates the basis function BIC score for a given dataset.
The
BayesBifParser class provides a set of static methods for parsing Bayesian Network Interchange Format
(BIF) files.Renders Bayes nets and related models in XML.
Feb 22, 2014 3:26:17 PM
Feb 22, 2014 3:35:38 PM
Interface implemented by Bayes instantiated models.
Takes an xml element representing a bayes im and converts it to a BayesIM
Calculates cell probabilities from conditional BayesIm probabilities on the fly without constructing the entire
table.
Bayes net simulation.
Implements a discrete Bayes parametric model--that is, a DAG together with a map from the nodes in the graph to a set
of discrete variables, specifying the number of categories for each variable and the name of each category for each
variable.
Calculates some scores for Bayes nets as a whole.
The LikelihoodRet class represents the result of a likelihood ratio test.
Interface for a discrete Bayes updating algorithm.
Parses Bayes elements back to objects.
Renders Bayes nets and related models in XML.
This is a thread-safe version of BCInference.
An enum for the type of operation.
Feb 26, 2014 8:07:20 PM
Enum for the type of constraint.
Provides a method for computing the score of a model, called the BDe
metric (Bayesian Dirchlet likelihood equivalence), given a dataset (assumes no missing values) and a Bayes
parameterized network (assumes no latent variables).> 0
Calculates the BDe score (Bayes Dirichlet Equivalent) score for analyzing discrete multinomial data.
Wrapper for Fisher Z test.
Calculates the BDeu score, which the BDe (Bayes Dirichlet Equivalent) score with uniform priors.
Wrapper for Fisher Z test.
Extracts the backward step of GES for use GES but also in other algorithms.
An arrow in the search.
Implements a version of the BES (Best Equivalent Search) algorithm
that takes a permutation as input and yields a permtuation as output, where the related DAG or CPDAG models are
implied by the ordering or variables in these permutations.
Implements a Beta distribution for purposes of drawing random numbers.
Adjusts GFCI to use a permutation algorithm (such as BOSS-Tuck) to do the initial steps of finding adjacencies and
unshielded colliders.
Uses BOSS in place of FGES for the initial step in the GFCI algorithm.
Difference between the true and estimated BIC scores.
Difference between the true and estiamted BIC scores.
Estimated BIC score.
True BIC score.
A confusion matrix for bidireced edges--i.e.
The bidirected true positives.
The bidirected false negatives.
The BidirectedLatentPrecision class implements the Statistic interface and represents a statistic that calculates
the percentage of bidirected edges in an estimated graph for which a latent confounder exists in the true graph.
The bidirected edge precision.
The bidirected edge precision.
The bidirected true positives.
The bidirected true positives.
Implements an algorithm for revising regulatory models with expression data.
Implements a digraph to be used by the Biolingua algorithm.
Client of the Biolingua class, can be used to easily run the algorithm with different inputs.
Stores a boolean function from a set of boolean-valued parents to a single boolean-valued column.
Updates a gene given a history using the formula Gi.0 = max(Gi.1 - decayRate * -Gi.1 + booleanInfluenceRate *
F(Parents(Gi) in the graph \ Gi.1), lowerBound), as described in Edwards and Glass, (2000), "Combinatorial explosion
in model gene networks", American Institute of Physics.
This class contains as a member variable (cases) the time series data stored in an int array of microarray
measurements.
This class contains as a member variable (cases) the time series data stored in an int array of microarray
measurements.
Indicate algorithm can do bootstrapping.
Provides a static method for sampling with replacement from a dataset to create a new dataset with a sample size
supplied by the user.
BOSS (Best Order Score Search)
Implements Best Order Score Search (BOSS).
This class represents the LV-Lite algorithm, which is an implementation of the GFCI algorithm for learning causal
structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based steps
afterward.
BOSS-LiNGAM algorithm.
Implements an algorithm which first finds a CPDAG for the variables and then uses a non-Gaussian orientation method
to orient the undirected edges.
This class represents the LV-Lite algorithm, which is an implementation of the GFCI algorithm for learning causal
structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based steps
afterward.
Wraps a DataBox in such a way that mixed data sets can be stored.
Build Pure Clusters.
Implements the Build Pure Clusters (BPC) algorithm, which allows one to identify clusters of measured variables in a
dataset that are explained by a single latent.
Enumerates the algorithm types for BuildPureClusters, and Purify.
Enumerates the test types for BuildPureClusters, and Purify.
Implements a really simple idea for building pure clusters, just using the Purify algorithm.
An example script to simulate data and run a comparison analysis on it.
Stores a 2D array of byte data.
Makes a new data set in which cases in the given data set that have been assigned multiplicies other than n = 1 are
copied out n times.
CCD (Cyclic Causal Discovery)
Implemented the Cyclic Causal Discovery (CCD) algorithm by Thomas Richardson.
Wrapper for Daudin Conditional Independence test.
Represents a cell table that stores the values of the cells in a table of arbitrary dimension, for use, e.g.,
in the context of a contingency table--e.g.
Stores a cell count table of arbitrary dimension.
Stores a cell count table of arbitrary dimension.
Estimates probabilities from data by constructing the entire cell count table for the data.
Conservative FCI.
Adjusts FCI (see) to use conservative orientation as in CPC (see).
Identifies violations of knowledge for a given graph.
Wrapper for Fisher Z test.
Wraps a chi square distribution for purposes of drawing random samples.
Calculates chi-square or g-square for a conditional cross-tabulation table for independence question 0 _||_ 1 | 2, 3,
...max by summing up chi-square and degrees of freedom for each conditional table in turn, where rows or columns that
sum to less than a given threshold have been removed.
The type of cell table to use.
Simple class to store the parameters of the result returned by the G Square test.
The type of test to perform.
Generates (nonrecursively) all of the combinations of a choose b, where a, b are nonnegative integers and a >= b.
This class contains a method classify which uses an instantiated Bayes net (BayesIm) provided in the constructor.
Interface implemented by classes that do discrete classification.
Performs a Bayesian classification of a test set based on a given training set.
Tags an algorithm that generates clusters.
Represents a clustering algorithm to cluster some data.
Stores clusters of variables for MimBuild, Purify, etc.
Provides some methods to check significance of clusters for clustering algroithms.
Gives the options for checking significance of clusters--could check the significance using a regression model,
or could check to see if the cluster is a clique, or could not do the check.
Provides some general utilities for dealing with clustering input and output.
Generates (nonrecursively) all of the combinations of objects, where the number of objects in each dimension is
specified.
Iterates through all the posible combinations for a set of variables (each with a different number of possible
values).
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
Gives the comparison of a target graph to a reference graph that is implemented in the interface.
Script to do a comparison of a list of algorithms using a list of statistics and a list of parameters and their
values.
Does a comparison of algorithm results across algorithm type, sample sizes, etc.
An enum of comparison graphs types.
An enumeration of the columns in the comparison table.
Does a comparison of algorithm results across algorithm type, sample sizes, etc.
An enum of table columns.
Created by jdramsey on 3/24/16.
An enumeration of the algorithms that can be used for structure learning.
An enumeration of the data types that can be used for structure learning.
An enumeration of the independence test types that can be used for structure learning.
An enumeration of the result types that can be used for structure learning.
.
Runs algorithm on data set (simulation is OK), printing out error statistics.
CompositeIndependenceTest class.
Checks conditional independence of variable in a continuous data set using Daudin's method.
Wrapper for Fisher Z test.
Implements a conditional Gaussian likelihood.
Gives return value for a conditional Gaussian likelihood, returning a likelihood value and the degrees of freedom
for it.
Wrapper for Fisher Z test.
Implements a conditional Gaussian BIC score for FGS, which calculates a BIC score for mixed discrete/Gaussian data
using the conditional Gaussian likelihood function (see).
A simulation method based on the conditional Gaussian assumption.
The type of conditioning set to use for the Markov check.
Created by IntelliJ IDEA.
Represents a constant expression, that is an expression that always evaluates to the same value.
Looks up the value of a variable.
Specifies how a column (continuous or discrete) should be discretized.
Represents a real-valued variable.
This interface should be used for non-differentiable convex functions that are decomposable such that f(x) = g(x) +
h(x) where g(x) is a differentiable convex function (i.e.
Outputs 1 if the skeleton is correct, 0 if not..
Stores a correlation matrix together with variable names and sample size; intended as a representation of a data
set.
Stores a covariance matrix together with variable names and sample size, intended as a representation of a data set.
Interface for computing covariances.
Stores a covariance matrix together with variable names and sample size, intended as a representation of a data set.
Jan 25, 2016 2:13:26 PM
Stores a covariance matrix together with variable names and sample size, intended as a representation of a data set.
Some comemon methods for the various covariance implementations.
Computes covariances using the standard calculation.
Conservative PC (CPC).
Implements a convervative version of PC, in which the Markov condition is assumed but faithfulness is tested
locally.
CpdagParentDistancesFromTrue computes the distances between true edge strengths in a true DAG and the range of
estimated edge strengths in an output CPDAG.
The type of distance to calculate.
Calculates marginals of the form P(V=v') for an updated Bayes net for purposes of the CPT Invariant Updater.
Calculates updated probabilities for variables conditional on their parents as well as single-variable updated
marginals for a Bayes IM using an algorithm that restricts expensive updating summations only to conditional
probabilities of variables with respect to their parents that change from non-updated to updated values.
An interface representing a map of probabilities or counts for nodes in a Bayesian network.
Represents a conditional probability table (CPT) in a Bayes net.
Represents a conditional probability table (CPT) in a Bayes net.
Cstar class.
Implements the CStaR algorithm (Stekhoven et al., 2012), which finds a CPDAG of that data and then tries all
orientations of the undirected edges about a variable in the CPDAG to estimate a minimum bound on the effect for a
given edge.
An enumeration of the options available for determining the CPDAG used for the algorithm.
Represents a single record in the returned table for CSTaR.
An enumeration of the methods for selecting samples from the full dataset.
Provides a static method for finding the cutoff value for a symmetric probability distribution function about the
origin.
Returns a cyclic graph build up from small cyclic graph components.
Represents a directed acyclic graph--that is, a graph containing only directed edges, with no cycles.
Given a CPDAG, lists all the DAGs in that DPCAG.
Given a graph, lists all DAGs that result from directing the undirected edges in that graph every possible way.
Implements the DAGMA algorithm.
Implements the DAGMA algorithm.
Interface for a method that scores a DAG.
Estimates a SemIm given a CovarianceMatrix and a SemPm.
Determines sepsets, collider, and noncolliders by examining d-separation facts in a DAG.
Converts a DAG (Directed acyclic graph) into the PAG (partial ancestral graph) which it is in the equivalence class
of.
Stores a 2D array of data.
Dec 15, 2018 11:10:30 AM
Interface implemented by classes whose purpose is to generate modifications of data sets.
DataForCalibrationRfci class.
Created by ajsedgewick on 9/4/15.
Sundry graph utils that need to be located in the data package to avoid package cycles.
Interface implemented by classes, instantiations of which can serve as data models in Tetrad.
Stores a list of data models and keeps track of which one is selected.
A utility for resampling dataset.
Implements a rectangular data set, in the sense of being a dataset with a fixed number of columns and a fixed number
of rows, the length of each column being constant.
Estimates maximum likelihood probabilities directly from data on the fly.
Data table implementation.
Data table implementation.
Data tools.
DataTransforms class.
The type of the data set--continuous if all continuous variables, discrete if all discrete variables; otherwise,
mixed.
Fast data loader for continuous or discrete data.
Some static utility methods for dealing with data sets.
Provides static methods for saving data to files.
Implements the DCI (Distributed Causal Inference) algorithm for learning causal structure over a set of variable from
multiple datasets that each may only measure proper overlapping subsets of that sets, or datasets with some variables
in common and others not.
The DefaultSetEndpointStrategy class implements the SetEndpointStrategy interface and provides a default strategy for
setting the endpoint of an edge in a graph.
Logger configuration.
A default implementation of the event.
The bidirected true positives.
The bidirected true positives.
Wrapper for degenerate Gaussian BIC score
Wrapper for DG LRT.
=This implements the degenerate Gaussian BIC score for FGES.
Type-safe enum of delimiter types for parsing data.
Jun 20, 2017 12:09:05 PM
Implements a test for simultaneously zero sextads in the style of Bollen, K.
Implements a test for simultaneously zero tetrads in Bollen, K.
Uses expectation-maximization to sort a a data set with data sampled from two or more multivariate Gaussian
distributions into its component data sets.
Created by user on 2/27/18.
The adjacency precision.
The adjacency precision.
Simple implementation of a directed Graph edges are just represented by float values (a zero == no edge) stored in a
matrix.
Direct LiNGAM.
Implements the Direct-LiNGAM algorithm.
Stores Dirichlet pseudocounts for the distributions of each variable conditional on particular combinations of its
parent values and, together with Bayes Pm and Dag, provides methods to manipulate these tables.
Estimates probabilities directly from data on the fly using maximum likelihood method.
Estimates a DirichletBayesIm from a DirichletBayesIm (the prior) and a data set.
Wraps a chi square distribution for purposes of drawing random samples.
Wrapper for Discrete BIC test.
Calculates the discrete BIC score.
Calculates the discrete BIC score.
Wrapper for Fisher Z test.
Specifies how a column (continuous or discrete) should be discretized.
Gives an interface that can be used by various discrete scores.
Represents a discrete variable as a range of integer-valued categories 0, 1, ..., m - 1, where m is the number of
categories for the variable.
Type-safe enum of discrete variable types.
A continuous or discrete discretization spec (see).
Discretizes individual columns of discrete or continuous data.
A discretization specification for a continuous variable.
Represents a discriminating path in a graph.
Models the manner in which gene models are initialized differentially depending on the dishes that the cells are in.
Translates display names of lagged variables (e.g.
Interface for a dissilimarity metric.
Interface for a statistical distribution from which random values can be drawn.
Implements the DM search.
Stores a 2D array of double data.
EB.
Wrapper for linear, Gaussian Extended BIC score (Chen and Chen).
Implements the extended BIC (EBIC) score.
Represents an edge node1 *-# node2 where * and # are endpoints of type Endpoint--that is, Endpoint.TAIL,
Endpoint.ARROW, or Endpoint.CIRCLE.
A property of an edge.
Stores a graph a list of lists of edges adjacent to each node in the graph, with an additional list storing all of
the edges in the graph.
This factory class produces edges of the types commonly used for Tetrad-style graphs.
Apr 13, 2017 3:56:46 PM
An enumeration of the different types of edges.
Gives an interface for classes where the effective sample size can be set by the user.
Calculates the eigen decomposition of a real matrix.
Records the elapsed time of the algorithm in seconds.
Estimates parameters of the given Bayes net from the given data using maximum likelihood method.
Calculates some scores for Bayes nets as a whole.
Interface for an estimator.
Only the cumulativeProbability, density, setShift methods are implemented.
Returns a sample empirical distribution for a particular expression.
A enumeration of the endpoint types that are permitted in Tetrad-style graphs: null (-), arrow (->),
circle (-o), start (-*), and null (no endpoint).
A helper class to encapsulate logic for ensuring a Markov property for subsequent testing after an initial local
Markov graph has been found.
Represents an equation of the form Variable = Expression, where the Variable represents a column in some dataset.
Creates a random graph by the Erdos-Renyi method (probabiliy of edge fixed, # edges not).
Estimates the rank of a matrix.
An equation expression.
Stores information for a variable source about evidence we have for each variable as well as whether each variable
has been manipulated.
An example script to load in data sets and graphs from files and analyze them.
An example script to load in data sets and graphs from files and analyze them.
An example script to simulate data and run a comparison analysis on it.
An example script to simulate data and run a comparison analysis on it.
An example script to simulate data and run a comparison analysis on it.
An example script to simulate data and run a comparison analysis on it.
An example script to simulate time series data and run a comparison analysis on it.
An example script to simulate data and run a comparison analysis on it.
Created by ajsedgewick on 8/18/15.
An example script to save out data files and graphs from a simulation.
An example script to save out data files and graphs from a simulation.
An example script to save out data files and graphs from a simulation.
An example script to simulate data and run a comparison analysis on it.
Oct 17, 2017 11:40:50 AM
Tags a file as experimental so it's not listed in the configuration.
Runs algorithm on data set (simulation is OK), printing out error statistics.
Created by ajsedgewick on 9/10/15.
Wraps a chi square distribution for purposes of drawing random samples.
Represents a mathematical expression.
Represents a definition for some expression.
An enum of positions that an expression can occur in.
Thrown if the expression can't be parsed, for instance, if it has the wrong number of arguments.
Parses the tokens of an expression.
Manager for expressions, this includes all implementations of expression descriptors for the calculator.
Parses a string into a tree-like expression.
The type of restriction on parameters.
Represents the signature of the expression, for example sqrt(number).
Tags an an algorithm that loads up external graphs for inclusion in reports.
Returns a data set in variables for columns with missing values are augmented with an extra category that represents
the missing values, with missing values being reported as belong this category.
Calculates the F1 statistic for adjacencies.
Calculates the F1 statistic for adjacencies.
Calculates the F1 statistic for arrowheads.
Factor analysis.
Implements the classical Factor Analysis algorithm.
Implements the procedure Factored-Bayesian-SEM found on page 6 of "The
Bayesian Structural EM Algorithm" by Nir Friedman.> 0
The bidirected true positives.
The bidirected true positives.
Fast Adjacency Search (FAS)--i.e., the PC adjacency step, which is used in many algorithms.
Implements the Fast Adjacency Search (FAS), which is the adjacency search of the PC algorithm (see).
Adjusts FAS (see) for the deterministic case by refusing to removed edges based on conditional independence tests
that are judged to be deterministic.
Implements a modified version of the the "fast adjacency search" for use in the Distributed Causal Inference (DCI)
algorithm.
Implements the "fast adjacency search" used in several causal algorithm in this package.
FASK algorithm.
Implements the FASK (Fast Adjacency Skewness) algorithm, which makes decisions for adjacency and orientation using a
combination of conditional independence testing, judgments of nonlinear adjacency, and pairwise orientation due to
non-Gaussianity.
Enumerates the options left-right rules to use for FASK.
Wraps the IMaGES algorithm for continuous variables.
Wraps the IMaGES algorithm for continuous variables.
The FaskOrig class is an implementation of the FASK-Orig algorithm for causal discovery.
Implements the FASK (Fast Adjacency Skewness) algorithm, which makes decisions for adjacency and orientation using a
combination of conditional independence testing, judgments of nonlinear adjacency, and pairwise orientation due to
non-Gaussianity.
Enumerates the alternatives to use for finding the initial adjacencies for FASK.
Enumerates the options left-right rules to use for FASK.
FASK-PW (pairwise).
Wraps the MultiFask algorithm for continuous variables.
Runs IMaGES on a list of algorithms and then produces a graph over the
ImaGES adjacencies where each edge orientation is voted on by running FASK on each dataset in turn and voting on edge
orientation.
Wraps the IMaGES algorithm for continuous variables.
Runs Fast Adjacency Search (FAS) and then orients each edge using the robust
skew orientation algorithm.
Translates a version of the FastICA algorithm used in R from Fortran into Java for use in Tetrad.
A list containing the following components
Calculates the F1 statistic for adjacencies.
The Fast Causal Inference (FCI) algorithm.
Implements the Fast Causal Inference (FCI) algorithm due to Peter Spirtes, which addressed the case where latent
common causes cannot be assumed not to exist with respect to the data set being analyzed.
Runs FCI on multiple datasets using the IOD pooled dataset independence test.
FCI-Max algorithm.
Modifies FCI to do orientation of unshielded colliders (X*-*Y*-*Z with X and Z not adjacent) using the max-P rule
(see the PC-Max algorithm).
Performs the final orientation steps of the FCI algorithms, which is a useful tool to use in a variety of FCI-like
algorithms.
A simple implementation of Dijkstra's algorithm for finding the shortest path in a graph.
Represents a node in Dijkstra's algorithm.
Represents a graph for Dijkstra's algorithm.
FGES (the heuristic version).
Implements the Fast Greedy Equivalence Search (FGES) algorithm.
Requires that the parameter 'randomSelectionSize' be set to indicate how many datasets should be taken at a time
(randomly).
FGES-MB (the heuristic version).
Implements the Fast Greedy Equivalence Search (FGES) algorithm.
FGES (the heuristic version).
This Orients a given undirected graph such that the edges in the graph are a superset of the edges in the oriented
graph, using FGES method.
First inflection point.
Wrapper for Fisher Z test.
Wrapper for Fisher Z test.
Stores a 2D array of float data.
Find One Factor Clusters.
Implements the Find One Factor Clusters (FOFC) algorithm by Erich Kummerfeld, which uses reasoning about vanishing
tetrads of algorithms to infer clusters of the measured variables in a dataset that each be explained by a single
latent variable.
Gives the options to be used in FOFC to sort through the various possibilities for forming clusters to find the
best options.
Estimates whether the p-values under the null are Uniform usign the Markov Checker.
Estimates whether the p-values under the null are Uniform usign the Markov Checker.
FTFC.
Implements the Find Two Factor Clusters (FOFC) algorithm, which uses reasoning about vanishing tetrads of algorithms
to infer clusters of the measured variables in a dataset that each be explained by a single latent variable.
Gives the options to be used in FOFC to sort through the various possibilities for forming clusters to find the
best options.
Interface for a single-argument, double-valued function that can be passed to mathematical routines.
Wraps a chi square distribution for purposes of drawing random samples.
Data are normal distributed.
GaussianPower class.
Created by Erich on 7/3/2016.
Created by Erich on 7/14/2016.
Created by Erich on 8/6/2016.
Created by Erich on 8/6/2016.
Created by Erich on 7/6/2016.
Created by Erich on 8/11/2016.
Implements the basic machinery used by all history objects.
Implements a parametric gene model.
Data with variables of general distribution.
Implements the Anderson-Darling test against the given CDF, with P values calculated as in R's ad.test method (in
package nortest).
Estimates a Generalized SEM I'M given a Generalized SEM PM and a data set.
Context.
Represents a generalized SEM-instantiated model.
Parametric model for a Generalized SEM model.
The GeneralSemSimulation class represents a simulation using a generalized structural equation model (SEM).
This was used for a simulation to test the FTFC and FOFC algorithm and contains some carefully selected functions to
test nonlinearity and non-Gaussianity.
The Gfci class represents the Greedy Fast Causal Inference algorithm.
Implements a modification of FCI that started by running the FGES algorithm and then fixes that result to be correct
for latent variables models.
The GicScores class is an implementation of the ScoreWrapper interface that calculates the Generalized Information
Criterion (GIC) scores for a given data model.
Implements scores motivated by the Generalized Information Criterion (GIC) approach as given in Kim et al.
Gives the options for the rules to use for calculating the scores.
Represents a class for Generalized Information Criterion Score Tests.
GLASSO.
A translation from Tibshirani's 2008 Fortran implementation of glasso.
Return value of the algorithm.
Implements a graph capable of storing edges of type N1 *-# N2 where * and # are endpoints of type Endpoint.
Provides s a data structure created mainly for use in the ION search algorithm.
Return a 1 if the graph is exactly right, 0 otherwise.
Instantiations of this interface know how to randomize lag graphs in particular ways.
Contains methods which can be used to determine whether a directed graph is in the equivalence class determined by
the given PAG.
Implements a basic node in a graph--that is, a node that is not itself a variable.
Checks the graphoid axioms for a set of Independence Model statements.
Represents a graphoid independence fact--i.e., a fact in a general independence model (IM) X _||_Y | Z.
Instantiations of this interface know how to randomize update graphs in particular ways.
A utility for computing frequency probabilities.
Methods to load or save graphs.
Implements a pscudo-"score" that implmenets implements Chickering and Meek's (2002) locally consistent score
criterion.
Provides some graph utilities for search algorithm.
Gives the options for triple type for a conservative unshielded collider orientation, which may be "collider" or
"noncollider" or "ambiguous".
Stores a result for checking whether a graph is a legal MAG--(a) whether it is (a boolean), and (b) the reason
why it is not, if it is not (a String).
Stores a result for checking whether a graph is a legal PAG--(a) whether it is (a boolean), and (b) the reason
why it is not, if it is not (a String).
A utility class containing graph function from graph theory.
Transformations that transform one graph into another.
Jun 4, 2019 3:21:47 PM
Utility class for working with graphs.
Represents a comparison between two graphs.
The GraphType enum represents the types of graphs that can be used in the application.
Two-cycle errors.
GRaSP (Greedy Relaxations of Sparsest Permutation)
Implements the GRaSP algorithms, which uses a certain procedure to search in the space of permutations of variables
for ones that imply CPDAGs that are especially close to the CPDAG of the true model.
Adjusts GFCI to use a permutation algorithm (such as BOSS-Tuck) to do the initial steps of finding adjacencies and
unshielded colliders.
Uses GRaSP in place of FGES for the initial step in the GFCI algorithm.
Implements the GRASP algorithms, with various execution flags.
Implements the Grow-Shrink algorithm of Margaritis and Thrun, a simple yet correct and useful Markov blanket search.
GrowShrinkTree class.
Wrapper for Fisher Z test.
The purpose of this little converter is to convert "effect" files into "cause" (BasicLagGraph) files.
Stores a knowledge object.
Tags a gadget as having parameters
Tags a gadget as having parameters values.
Provides an interface for an algorithm can can get/set a value for penalty disoucnt.
Interface for Bff (Heuristic Best Significant Model Search) algorithm.
Heuristic Best Significant Model Search using a beam search.
A move.
Types of moves the algorithm can make.
The score.
Heuristic Best Significant Model Search using the GES algorithm.
A graph with a P value.
The score of a model.
Model for a conditional histogram for mixed continuous and discrete variables.
Hsim class.
Created by Erich on 3/28/2016.
Created by Erich on 3/28/2016.
Created by Erich on 7/15/2016.
Created by Erich on 3/27/2016.
Created by ekummerfeld on 1/26/2017.
Created by Erich on 4/29/2016.
Created by Erich on 3/28/2016.
Created by Erich on 4/29/2016.
generate data from random graph, generated from parameters.
Created by Erich on 3/28/2016.
Created by Erich on 4/29/2016.
Created by Erich on 3/28/2016.
Created by Erich on 3/28/2016.
Created by Erich on 4/22/2016.
Provides an implemetation of the Kuhn–Munkres assignment algorithm of
the year 1957.
Implements IAMB.
Created by IntelliJ IDEA.
IcaLingam class implements the Algorithm and ReturnsBootstrapGraphs interface.
Implements the ICA-LiNGAM algorithm.
IcaLingD is an implementation of the Algorithm interface that performs the ICA-LiNG-D algorithm for discovering
causal models for the linear non-Gaussian case where the underlying model might be cyclic.
Implements the ICA-LiNG-D algorithm as well as a some auxiliary methods for ICA-LiNG-D and ICA-LiNGAM.
Interface for covariance matrices.
Implements the IDA algorithm.
Gives a list of nodes (parents or children) and corresponding minimum effects for the IDA algorithm.
The IDA average squared distance.
This calculates total effects and absolute total effects for an MPDAG G for all pairs distinct (x, y) of variables,
where the total effect is obtained by regressing y on x ∪ S and reporting the regression coefficient.
IdaCheckAvgMaxSquaredDiffEstTrue calculates the average maximum squared difference between the estimated and true
values for a given data model and graphs.
Represents a statistic that calculates the average minimum squared difference between the estimated and true values
for a given data model and graphs.
IdaCheckAvgSquaredDifference is a class that implements the Statistic interface.
IdaMaximumSquaredDifference is a statistic that calculates the "IDA Average Maximum Squared Difference" between a
true graph and an estimated graph.
IdaMinimumSquaredDifference is a statistic that calculates the "IDA Average Minimum Squared Difference" between a
true graph and an estimated graph.
Identifiability, based on RowSummingExactUpdater
Gives an interface for fast adjacency searches (i.e., PC adjacency searches).
Instance-specific GFci given in Fattaneh Jabbari's dissertation (Pages 144-147)
Gives an interface for a search method that searches and returns a graph.
Tagging interface for instantiated models.
Wraps the IMaGES algorithm for continuous variables.
Wraps the IMaGES algorithm for continuous variables.
Implements a score to average results over multiple scores.
Gives an interface for Markov blanket searches.
The Implied Arrow Orientation Ratio Est statistic calculates the ratio of the number of implied arrows to the number of arrows in unshielded colliders in the estimated graph.
The Implied Arrow Orientation Ratio Est statistic calculates the ratio of the number of implied arrows to the number of arrows in unshielded colliders in the estimated graph.
The Implied Arrow Orientation Ratio Est statistic calculates the ratio of the number of implied arrows to the number of arrows in unshielded colliders in the estimated graph.
Implies Legal MAG
Stores a triple (x, y, z) of nodes.
Stores a list of independence facts.
Stores a single conditional independence result, e.g., whether X _||_ Y | Z1,...,Zn holds or does not, and the
p-value of the test.
Gives an interface that can be implemented by classes that do conditional independence testing.
May 14, 2019 11:25:02 AM
Interface that algorithm must implement.
Stores a "shapshot" of the indexedConnectivity of a lag graph, using
indices rather than Strings to refer to factors.
Stores a "shapshot" of the indexedLagGraph of a lag graph, using indices
rather than Strings to refer to factors.
Indexed matrix.
Holds an ordered pair (index, lag) to represent a causal parent of a factor, where the factor at the given index is
independently known.
Created by IntelliJ IDEA.
Checks the conditional independence X _||_ Y | S, where S is a set of discrete variable, and X and Y are discrete
variable not in S, by applying a conditional Chi Square test.
Checks conditional independence of variable in a continuous data set using a conditional correlation test for the
nonlinear nonGaussian with the additive error case.
Performs a test of conditional independence X _||_ Y | Z1...Zn where all searchVariables are either continuous or
discrete.
Checks conditional independence for continuous variables using Cramer's T-test formula (Cramer, Mathematical Methods
of Statistics (1951), page 413).
Implements a degenerate Gaussian score as a LRT.
Stores a return value for a likelihood--i.e., a likelihood value and the degrees of freedom for it.
Checks conditional independence of variable in a continuous data set using Fisher's Z test.
Calculates independence from pooled residuals using the Fisher Z method.
Calculates independence from multiple datasets from using the Fisher method of pooling independence results.
Calculates independence from pooled residuals.
Checks conditional independence of variable in a continuous data set using Fisher's Z test.
Checks the conditional independence X _||_ Y | S, where S is a set of discrete variable, and X and Y are discrete
variable not in S, by applying a conditional G Square test.
Checks the conditional independence X _||_ Y | S, where S is a set of continuous variable, and X and Y are discrete
variable not in S, using the Hilbert-Schmidth Independence Criterion (HSIC), a kernel based nonparametric test for
conditional independence.
Checks conditional independence against a list of conditional independence facts, manually entered.
Checks independence results by listing all tests with those variables, testing each one, and returning the resolution
of these test results.
Performs a test of conditional independence X _||_ Y | Z1...Zn where all searchVariables are either continuous or
discrete.
Performs a test of conditional independence X _||_ Y | Z1...Zn where all searchVariables are either continuous or
discrete.
A class that represents a pooled independence test for multiple data sets.
Performs a test of conditional independence X _||_ Y | Z1...Zn where all searchVariables are either continuous or
discrete.
Performs a test of conditional independence X _||_ Y | Z1...Zn where all searchVariables are either continuous or
discrete.
Performs a test of conditional independence X _||_ Y | Z1...Zn where all variables are either continuous or discrete.
Checks conditional independence of variable in a continuous data set using Fisher's Z test.
Uses BCInference by Cooper and Bui to calculate probabilistic conditional independence judgments.
Checks independence of X _||_ Y | Z for variables X and Y and list Z of variables by regressing X on {Y} U Z and
testing whether the coefficient for Y is zero.
Gives a method of interpreting a test as a score.
Checks independence facts for variables associated with a sepset by simply querying the sepset
Checks d-separations in a structural model using t-separations over indicators.
Initializes a history array.
Estimates probabilities directly from data on the fly using maximum likelihood method, with the exception that if
rows do not exist in the data satisfying a required condition because certain values are unattested, an attempt is
made to remove each relevant column in turn, record the estimated probability with column removed from the condition
(if it is defined), and then return the average over the estimated probabilities calculated this way.
Stores a 2D array of integer data.
Integrates under a function from one endpoint to another.
Implements the Inter-IAMB algorithm.
Returns edges whose entries in the precision matrix exceed a certain threshold.
Implements the ION (Integration of Overlapping Networks) algorithm for distributed causal inference.
Provides a static method which implements a correct version of Reiter's hitting set algorithm as described by
Greiner, Smith, and Wilkerson in "A Correction to the Algorithm in Reiter's Theory of Diagnosis" Artificial
Intellegence 41 (1989) (see for detailed specification).
Provides an interface for Purify algorithm.
Added by Fattaneh Calculates the Instance-Specific BDeu score.
A class representing the ISBicScore, which calculates BIC scores for a Bayesian network considering different
structural changes and their impacts using an information-sharing mechanism.
An interface for SemIM's; see implementations.
GesSearch is an implementation of the GES algorithm, as specified in Chickering (2002) "Optimal structure
identification with greedy search" Journal of Machine Learning Research.
Interface for a score suitable for FGES
This class contains methods which implement the algorithm described in the paper " " by Ideker, Thorsen and Karp.
A gene.
Stores some utility items for displaying JOptionPane messages.
Dec 9, 2016 5:43:47 PM
Junction Tree Algorithm.
Jan 21, 2020 11:03:09 AM
Wrapper for KCI test.
Gives an implementation of the Kernel Independence Test (KCI) by Kun Zhang, which is a general test of conditional
independence.
A record representing the result of an eigenvalue decomposition.
Represents the type of kernel to be used in a computation.
Gives an implemented that is implemented by classes that evaluate scalar valued kernels
Soces the Gaussian kernel for a given bandwidth.
Provides various kernel utilities.
Implements the "batch" version of the K Means clustering algorithm-- that is, in one sweep, assign each point to its
nearest center, and then in a second sweep, reset each center to the mean of the cluster for that center, repeating
until convergence.
Stores information about required and forbidden edges and common causes for use in algorithm.
Implements a knowledge edge X-->Y as a simple ordered pair of strings.
Represents a "Other Group" in Knowledge, which can be understood as: Group1 -> Group2 where there are edges
between all members of Group1 to Group2.
Implementation of the KnowledgeSatisfied class.
Interface implemented by classes that are capable of participating in the transfer of knowledge objects.
Kernelized PC algorithm.
wrapper class for passing factor+edge via a propertyChange event
Identifies a particular factor (by name) at a particular lag (integer).
Implements a graph allowing nodes in the getModel time lag to have parents taken from previous time lags.
Lag graph.
LagGraphParams class.
Stores a SEM model, pared down, for purposes of simulating data sets with large numbers of variables and sample
sizes.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
LayoutUtil class.
Lays out a graph by linearly summing repulsive force between all nodes and attractive force between adjacent
nodes.
Lays out a graph by placing springs between the nodes and letting the system settle (one node at a time).
A version of the Lee and Hastic simulation which is guaranteed ot generate a discrete data set.
Legal PAG
Determines whether nodes indexed as (n1, center, n2) form a legal pair of edges in a graph for purposes of some
algorithm that uses this information.
Linear Fisher Model.
Implements a linear update function, Gi.0 = L(Parents(G0.0)) + ei, where P
is a polynomial function and ei is a random noise term.
Data with Gaussian variables that have linear relationships.
Implements a particular simulation for experimental purposes.
A simulation method based on the mixed variable polynomial assumption.
An example script to simulate data and run a comparison analysis on it.
Load data sets and graphs from a directory.
Load data sets and graphs from a directory.
Load data sets and graphs from a directory.
Load data sets and graphs from a directory.
Load data sets and graphs from a directory.
A confusion matrix for local graph accuracy check --i.e.
The LocalGraphPrecision class implements the Statistic interface and represents the Local Graph Precision statistic.
LocalGraphRecall implements the Statistic interface and represents the local graph recall statistic.
Implements a number of methods which take a fixed graph as input and use linear, non-Gaussian methods to orient the
edges in the graph.
Give a list of options for rules for doing the non-Gaussian orientations.
Gives a list of options for non-Gaussian transformations that can be used for some scores.
Sundry methods for logging data.
Implements a logistic regression algorithm based on a Javascript implementation by John Pezzullo.
The result of a logistic regression.
Represents a lognormal distribution for purposes of sampling.
Sets up streams for logging via the Java logging API.
Contains utilities for logging search steps.
Stores a 2D array of long data.
This is merely a main program used to read a binarized measurement data set and to instantiate a BoolSearch and run
one or more search methods of that instance.
This is merely a main program used to read a binarized measurement data set and to instantiate a BoolSearch and run
one or more search methods of that instance.
Class that makes some very simple tests on the classes LtMatrix, Graph, and Biolingua
LTestPredictorSearch class.
LTestQnet3 class.
LTestReveal class.
This is merely a main program used to read a binarized measurement data set and to instantiate a RevealSearch and run
one or more search methods of that instance.
This is merely a main program used to read a binarized measurement data set and to instantiate a RevealSearch and run
one or more search methods of that instance.
LTestSsys1 class.
Implements a space-efficient Lower Triangular Matrix of elements of type
shortImplements a space-efficient Lower Triangular Matrix of elements of type
floatLV-Dumb is a class that implements the IGraphSearch interface.
This class represents the LV-Lite algorithm, which is an implementation of the GFCI algorithm for learning causal
structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based steps
afterward.
The LV-Lite algorithm (Latent Variable "Lite") algorithm implements a search algorithm for learning the structure of
a graphical model from observational data with latent variables.
The ExtraEdgeRemovalStyle enum specifies the styles for removing extra edges.
Enumeration representing different start options.
Gives a BIC score for a linear, Gaussian MAG (Mixed Ancestral Graph).
Takes a MAG in a PAG using Zhang's method and then reports the MAG DG BIC score for it.
Wrapper for degenerate Gaussian BIC score
Gives a BIC score for a linear, Gaussian MAG (Mixed Ancestral Graph).
Takes a MAG in a PAG using Zhang's method and then reports the MAG DG BIC score for it.
Gives a BIC score for a linear, Gaussian MAG (Mixed Ancestral Graph).
Wrapper for Fisher Z test.
Takes a MAG in a PAG using Zhang's method and then reports the MAG SEM BIC score for it.
Interface for a Bayes updating algorithm that's capable of doing manipulation.
Stores information for a variable source about evidence we have for each variable as well as whether each variable
has been manipulated.
Constructs as a (manual) update graph.
Stores the parameters needed to generate a new lag graph, whether randomized or manually constructed.
Maps a parameter to the matrix element where its value is stored in the
model.
Checks whether a graph is Markov given a data set.
Stores the set of m-separation facts and the set of m-connection facts for a graph, for the global check.
A single record for the results of the Markov check.
Calculates the Anderson Darling P value for the Markov check of whether the p-values for the estimated graph are
distributed as U(0, 1).
Calculates the Anderson Darling P value for the Markov check of whether the p-values for the estimated graph are
distributed as U(0, 1).
Calculates the Anderson Darling P value for the Markov check of whether the p-values for the estimated graph are
distributed as U(0, 1).
Calculates the Anderson Darling P value for the Markov check of whether the p-values for the estimated graph are
distributed as U(0, 1).
Represents a markov check statistic that calculates the Binomial P value for whether the p-values for the estimated
graph are distributed as U(0, 1).
Represents a markov check statistic that calculates the Binomial P value for whether the p-values for the estimated
graph are distributed as U(0, 1).
Represents a markov check statistic that calculates the Kolmogorov-Smirnoff P value for whether the p-values for the
estimated graph are distributed as U(0, 1).
Represents a markov check statistic that calculates the Kolmogorov-Smirnoff P value for whether the p-values for the
estimated graph are distributed as U(0, 1).
Represents a markov check statistic that calculates the Kolmogorov-Smirnoff P value for whether the p-values for the
estimated graph are distributed as U(0, 1).
Represents a markov check statistic that calculates the Kolmogorov-Smirnoff P value for whether the p-values for the
estimated graph are distributed as U(0, 1).
Calculates the Matthew's correlation coefficient for adjacencies.
Calculates the Matthew's correlation coefficient for adjacencies.
Some extra mathematical functions not contained in org.apache.commons.math3.util.FastMath.
Implements a Matrix of elements of type
shortWraps the Apache math3 linear algebra library for most uses in Tetrad.
Implements a Matrix of elements of type
floatClass Matrix includes several public static functions performing matrix operations.
Checks whether a PAG is maximal.
MaximalMag statistic.
Performs a Max-P orientation of unshielded triples in a graph.
Provides some useful utilities for dealing with Markov blankets and Markov blanket DAGs.
Returns a data set in which missing values in each column are filled using the mean of that column.
Simulates measurement genetic data using an underlying GeneHistory object
to generate individual cell data.
Wraps MeasurementSimulator so that it may be used as a parameter object.
Implements Meek's complete orientation rule set for PC (Chris Meek (1995), "Causal inference and causal explanation
orienting.
Tags a session node as "memorable", so that it won't be forgotten when a model is destroyed.
MGM.
Implementation of Lee and Hastie's (2012) pseudolikelihood method for learning Mixed Gaussian-Categorical Graphical
Models Created by ajsedgewick on 7/15/15.
The parameters of the MGM model.
Reports elapsed time in wall time, user time, and CPU time in milliseconds.
An enum for the type of time.
Provides an implementation of Mimbuild, an algorithm that takes a clustering of variables, each of which is explained
by a single latent, then forms the implied covariance matrix over the latent variables, then runs a CPDAG search to
in the structure over the latent themselves.
Implements Mimbuild using the theory of treks and ranks.
Provides some utility methods for Purify, Build Clusters, and Mimbuild.
Some utilities for generating misclassification tables for graphs.
Data with variables that have linear relationship.
Stores a 2D array of double continuousData.
Created by ajsedgewick on 7/29/15.
Represents a Gaussian mixture model -- a dataset with data sampled from two or more multivariate Gaussian
distributions.
Wraps a chi square distribution for purposes of drawing random samples.
Estimates parameters of the given Bayes net from the given data using maximum likelihood method.
Estimates parameters of the given Bayes net from the given data using maximum likelihood method.
Stores a table of probabilities for a Bayes net and, together with BayesPm and Dag, provides methods to manipulate
this table.
An enumeration representing the different types of CptMap.
The InitializationMethod enum represents different methods of initializing a class object.
Stores a table of probabilities for a Bayes net and, together with BayesPm and Dag, provides methods to manipulate
this table.
Implements the MMHC algorithm.
Implements the Min-Max Markov Blanks (MMMB) algorithm as defined in Tsamardinos, Aliferis, and Statnikov, Time and
Sample Efficient Discovery of Markov Blankets and Direct Causal Relations (KDD 2003).
Calculates Mixed Variables Polynomial likelihood.
Wrapper for Fisher Z test.
Implements a mixed variable polynomial BIC score for fGES.
Creates a data set in which missing values in each column are filled using the mode of that column.
Provides static methods for generating variants of an input graph.
The ModelObserver interface is implemented by classes that want to observe changes in a model.
Wrapper for Fisher Z test.
Wrapper for M-separation test.
Checks independence facts for variables associated with the nodes in a given graph by checking m-separation facts on
the underlying nodes.
Implements an algorithm that takes multiple data sets as input.
Aug 7, 2018 10:21:59 AM
Stores a table of cells with int values of arbitrary dimension.
Implements the Anderson-Darling test against the given CDF, with P values calculated as in R's ad.test method (in
package nortest).
Wrapper for Fisher Z test.
Wrapper for MVP BIC Score.
An example script to load in data sets and graphs from files and analyze them.
Calculates Mixed Variables Polynomial likelihood.
Wrapper for Fisher Z test.
Implements a mixed variable polynomial BIC score.
Specifies the protocol used in Tetrad for variable names.
NbComponent interface.
NbFunction class.
NbFunctionAnd class.
NbFunctionOr class.
NbFunctionSum class.
NbFunctionSV class.
NbGene class.
NbGeneAnd class.
NbGeneOr class.
NetBuilderModel class.
NL SEM simulation.
No almost cyclic paths condition.
No cyclic paths condition.
Represents an object with a name, node type, and position that can serve as a node in a graph.
An unordered pair of nodes.
The adjacency precision.
The adjacency precision.
An enum of the node types in a graph (MEASURED, LATENT, ERROR).
Node variable type.
Number of NOT X~~>Y in true graph for which also NOT X~~>Y in estimated graph.
Number of NOT X~~>Y in true graph for which also NOT X~~>Y in estimated graph.
Indicates an algorithm is nonexecutable.
A normal distribution that allows its parameters to be set and allows random sampling.
Calculates the F1 statistic for adjacencies.
The bidirected true positives.
The bidirected true positives.
Returns row positions for placing rooks for an n x n matrix so the rooks
cannot attach each other, with a given boolean[][] specification of where rooks are allowed to be placed.
The adjacency precision.
Represents the NumberEdgesEst statistic, which calculates the number of arrows in the estimated graph.
Represents the NumberEdgesEst statistic, which calculates the number of arrows not in unshielded colliders in the estimated graph.
Represents the NumberEdgesEst statistic, which calculates the number of unshielded colliders in the estimated graph.
Represents the NumberEdgesEst statistic, which calculates the number of edges in the estimated graph.
Represents the NumberEdgesEst statistic, which calculates the number of edges in colliders in the estimated graph.
Represents the NumberEdgesEst statistic, which calculates the number of edges in unshielded colliders in the estimated graph.
The NumberEdgesTrue class is an implementation of the Statistic interface.
Provides an application-wide "memory" of the number format to be used.
Wraps a 2D array of Number objects in such a way that mixed data sets can be stored.
Prints the number of edges in the estimated graph.
Prints the number of edges in the true graph.
Represents the NumberEdgesEst statistic, which calculates the number of tails in the estimated graph.
Represents the NumberEdgesEst statistic, which calculates the number of unshielded colliders in the estimated graph.
The bidirected edge precision.
The adjacency precision.
The adjacency precision.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
Counts the number of X<->Y edges for which a latent confounder of X and Y exists.
The bidirected true positives.
The bidirected true positives.
Represents a statistic that calculates the number of correct visible ancestors in the true graph
that are also visible ancestors in the estimated graph.
The number of covering adjacencies in an estimated PAG compared to the true PAG.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
Number of X-->Y in est.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The number of adjacencies in the estimated graph but not in the true graph.
The number of genuine adjacencies in an estimated PAG compared to the true PAG.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
Number of X---Y in est.
Number of parameters for a discrete Bayes model of the data.
Number of Xo->Y in est.
The bidirected true positives.
Number of X---Y in est.
NumVisibleEdgeEst is a class that implements the Statistic interface.
Represents a statistic that calculates the number of correct visible ancestors in the true graph
that are also visible ancestors in the estimated graph.
A class that implements the Statistic interface to calculate the number of visible edges in the true PAG.
An ordered pair of objects.
A confusion matrix for orientations:
The orientation precision.
Represents an implementation of the Statistic interface that calculates the Orientation Recall.
Represents a graph that's output by a genetic search algorithm.
The PagAdjacencyPrecision class implements the Statistic interface and represents the adjacency precision compared to
the true PAG (Partially Ancestral Graph).
A class that implements the PagAdjacencyRecall statistic.
A cache for storing PAGs so that the only need to be calculated once per DAG.
Jan 29, 2023 3:45:09 PM
Jan 29, 2023 4:10:52 PM
An enum of the types of the various comparisons a parameter may have with respect to one another for SEM estimation.
A class for implementing constraints on the values of the freeParameters of of instances of the SemIm class.
Enum for representing different types of parameter constraints.
Describes a parameter.
Stores descriptions of the parameters for the simulation box.
Stores information about the identity of a SEM parameter--its name, its type (COEF, COVAR), and the node(s) it is
associated with.
Adds a column to the output table in which values for the given parameter are listed.
Implements an ordered pair of objects (a, b) suitable for storing in HashSets.
Stores a list of named parameters with their values.
A utility to create/modify parameters.
Tags a class that can return values for parameters.
May 7, 2019 2:53:27 PM
An enum of the free parameter types for SEM models (COEF, MEAN, VAR, COVAR).
Calculates partial correlation using the recursive method.
Frequency function of partial correlation r(12|34...k), assuming that the true partial correlation is equal to zero.
Paths class.
An algorithm to find all cliques in a graph.
Peter/Clark algorithm (PC).
Implements the Peter/Clark (PC) algorithm, which uses conditional independence testing as an oracle to first of all
remove extraneous edges from a complete graph, then to orient the unshielded colliders in the graph, and finally to
make any additional orientations that are capable of avoiding additional unshielded colliders in the graph.
Provides some common implementation pieces of various PC-like algorithms, with options for collider discovery type,
FAS type, and conflict rule.
Gives the options for the collider discovery algorithm to use--FAS with sepsets reasoning, FAS with conservative
reasoning, or FAS with Max P reasoning.
Gives the type of conflict to be used, priority (when there is a conflict, keep the orientation that has already
been made), bidirected (when there is a conflict, orient a bidirected edge), or overwrite (when there is a
conflict, use the new orientation).
Gives the type of FAS used, regular or stable.
The PC heuristic type, where this is taken from Causation, Prediction, and Search.
PC.
Modifies the PC algorithm to handle the deterministic case.
PC.
Searches for a CPDAG representing all the Markov blankets for a given target T consistent with the given independence
information.
The adjacency precision.
The adjacency precision.
Runs some basic performance tests of various algorithm.
Contains some tests for Dan Malinsky, that might be of interest to others.
Generates all of the permutations of [0,..., numObjects - 1], where numObjects is numObjects nonnegative integer.
Stores a matrix together with a row and column permutation.
Implements common elements of a permutation search.
Tagging interface for parametric models.
Implements an n-dimensional point.
Stores a (x, y) point without having to use awt classes.
Wraps a chi square distribution for purposes of drawing random samples.
Wrapper for the Poisson prior score (Bryan)
Implements Poisson prior score, a novel (unpubished) score that replaces the penalty term in BIC by the log of the
Poisson distribution.
Implements a polynomial as a sum of a list of terms whose variables are identified as integers in the set {0, 1, 2,
...}.
Implements a polynomial update function, Gi.0 = P(Parents(G0.0)) + ei,
where P is a polynomial function and ei is a random noise term.
Implements a term in a polymonial whose variables are mapped to indices in
in the set {0, 1, 2, ...}.
Wrapper for Fisher Z test.
Wrapper for Fisher Z test.
Finds possible d-connecting undirectedPaths for the IonSearch.
Implements the Possible-M-Sep search step of Spirtes, et al's (1993) FCI algorithm (pp 144-145).
Created by Erich on 8/21/2016.
Initializes a graph by adding the previous time step only of each variable.
Uses BCInference by Cooper and Bui to calculate probabilistic conditional independence judgments.
Dec 17, 2018 3:44:46 PM
Implements a number of important functions from probability and
statistics.> 0
Proportion of semi(X, Y) in estimated graph for which there is no semi(Y, X) in true graph.
Proportion of semi(X, Y) in true graph for which there is no semi(Y, Z) in estimated graph.
Represents propositions over the variables of a particular BayesIm describing an event of a fairly general
sort--namely, conjunctions of propositions that particular variables take on values from a particular disjunctive
list of categories.
Implementation of Nesterov's 83 method as described in Beck and Teboulle, 2009 aka Fast Iterative Shrinkage
Thresholding Algorithm
Implements the Purify algorithm, which is a implementation of the automated purification methods described on CPS and
the report "Learning Measurement Models" CMU-CALD-03-100.
Implements a score-based Purify method.
Implments a sextad-based Purify method.
Implements a tetrad-based purify method.
Estimates whether the p-values under the null are Uniform usign the Markov Checker.
Estimates whether the p-values under the null are Uniform using the Markov Checker.
The FCI orientation rules are almost entirely taken up with an examination of the FCI graph, but there are two rules
that require looking at the distribution.
The FciOrientDataExaminationStrategyTestBased class implements the FciOrientDataExaminationStrategy interface and
provides methods for checking unshielded colliders and determining orientations based on the Discriminating Path
Rule.
The FciOrientDataExaminationStrategyTestBased class implements the FciOrientDataExaminationStrategy interface and
provides methods for checking unshielded colliders and determining orientations based on the Discriminating Path
Rule.
Enum representing the different types of blocking strategies.
R1.
R2.
R3.
A modified implementation of Dijkstra's shortest path algorithm for the R5 and R9 rules from Zhang, J.
Represents a node in Dijkstra's algorithm.
Represents a graph for Dijkstra's algorithm.
The rule that is being implemented, R5 or R9.
A distribution from which noise values are drawn.
Creates a random graph by adding forward edges.
An interface to represent a random graph of some sort.
The RandomGraph class provides methods for generating random graphs.
Generates random DAGs uniformly with certain classes of DAGs using variants of Markov chain algorithm by
Malancon, Dutour, and Philippe.
Provides a static method for sampling without replacement from a dataset to create a new dataset with a sample size
supplied by the user.
Creates a random graph by adding forward edges.
Creates a random graph by adding forward edges.
Provides a common random number generator to be used throughout Tetrad, to avoid problems that happen when random
number generators are created more often than once per millisecond.
RBExperiments class.
ReadControl class.
ReadIdeker class.
Jan 27, 2016 4:46:07 PM
Jan 27, 2016 5:35:01 PM
Jan 27, 2016 5:37:40 PM
Feb 9, 2016 3:13:19 PM
Feb 9, 2016 3:14:08 PM
Feb 9, 2016 3:15:29 PM
Tokenizes the given input character sequence using the type of delimiter specified bythe given CPDAG.
Implements a multiple regression model, allowing data to be specified either as a tabular data set or as a covariance
matrix plus list of means.
Implements a regression model from correlations--that is, from a correlation matrix, a list of standard deviations,
and a list of means.
Implements a regression model from tabular continuous data.
Stores the various components of a regression result so they can be passed around together more easily.
Sundry utilities for regression.
Utility for reidentifying variables for multiple indicator structure searches.
Sep 12, 2018 4:07:46 PM
Provides some utilities for resolving inconsistencies that arise
between sepsets learned for overlapping datasets.
Gives the method to be used to resolve sepsets when they conflict.
Utilities for resolving inconsistencies that arise between sepsets learned for overlapping datasets.
A method for combining p values.
BOSS-DC (Best Order Score Search Divide and Conquer)
ReturnsBootstrapGraphs interface.
Provides the methods for computing mutual information between expression levels between genes and, for a given gene,
between points in time determined by a lag value.
Provides the methods for computing mutual information between expression levels between genes and, for a given gene,
between points in time determined by a lag value.
RevealOutputGraph class.
RevealOutputGraph class.
RevealOutputGraph class.
This class contains as a member variable (cases) the time series data stored in an int array of microarray
measurements.
This class contains as a member variable (cases) the time series data stored in an int array of microarray
measurements.
RFCI.
Implements the Really Fast Causal Inference (RFCI) algorithm, which aims to do a correct inference of inferrable
causal structure under the assumption that unmeasured common causes of variables in the data may exist.
Runs RFCI-BSC, which is RFCI with bootstrap sampling of PAGs.
Dec 17, 2018 3:28:15 PM
Implements ICF as specified in Drton and Richardson (2003), Iterative Conditional Fitting for Gaussian Ancestral
Graph Models, using hints from previous implementations by Drton in the ggm package in R and by Silva in the Purify
class.
The fit con graph result.
RICF result.
Calculates a ROC curve and AUC (area under curve) for a list of scored cases whose inclusion in category C is known.
Interface for tests that can have their rows set on the fly.
Performs updating operations on a BayesIm by summing over cells in the joint probability table for the BayesIm.
RSkew.
RSkewE.
An example script to save out data files and graphs from a simulation.
RunKemmeren class.
Implements a conservative version of PC, in which the Markov condition is assumed but faithfulness is tested
locally.
Implements a conservative version of PC, in which the Markov condition is assumed but faithfulness is tested
locally.
An example script to save out data files and graphs from a simulation.
An example script to save out data files and graphs from a simulation.
Returns a scale free graph.
Sep 1, 2017 10:51:13 AM
Interface for a score.
Sep 26, 2017 1:14:01 AM
May 14, 2019 11:23:54 AM
Stores a graph with a score for the graph.
Gives a way of interpreting a score as an independence test.
Interface for a class that represents a scoring of a SEM model.
Author : Jeremy Espino MD Created 1/12/18 2:05 PM
Interface that algorithm must implement.
Created by ajsedgewick on 9/4/15.
Wrapper for the Fges search algorithm.
Abstract class for search algorithm wrappers.
Abstract class for search algorithm wrappers.
Generates (nonrecursively) all of the selections from a items, where a is a nonnegative integer.
The SemBicDTest class implements the IndependenceWrapper interface and represents a test for independence based on
SEM BIC algorithm.
Wrapper for linear, Gaussian SEM BIC score.
Implements the linear, Gaussian BIC score, with a 'penalty discount' multiplier on the BIC penalty.
Represents a covariance matrix and regression coefficients.
Gives two options for calculating the BIC score, one describe by Chickering and the other due to Nandy et al.
SemBicScoreDeterministic is a class that implements the ScoreWrapper interface.
Implements the continuous BIC score for FGES.
Scores an entire DAG using the SemBicScore.
Estimates a SemIm given a CovarianceMatrix and a SemPm.
Implements the Gibbs sampler apporach to obtain samples of arbitrary size from the posterior distribution over the
freeParameters of a SEM given a continuous dataset and a SemPm.
Stores the freeParameters for an instance of a SemEstimatorGibbs.
Stores information for a SemIm about evidence we have for each variable as well as whether each variable has been
manipulated.
Represents the graphical structure of a structural equation model.
Calculates the F1 statistic for adjacencies.
The bidirected true positives.
A class implementing the Semidirected-Rec statistic.
Stores an instantiated structural equation model (SEM), with error covariance terms, possibly cyclic, suitable for
estimation and simulation.
Stores information for a BayesIm about evidence we have for each variable as well as whether each variable has been
manipulated.
Interface for algorithm that optimize the fitting function of a SemIm model by adjusting its freeParameters in search
of a global maximum.
Optimizes a DAG SEM with hidden variables using expectation-maximization.
Optimizes a SEM using Powell's method from the Apache library.
Optimizes a DAG SEM by regressing each varaible onto its parents using a linear regression.
Optimizes a SEM using RICF (see that class).
Optimizes a SEM by randomly selecting points in cubes of decreasing size about a given point.
Parametric model for Structural Equation Models.
Represents propositions over the variables of a particular BayesIm describing and event of a fairly general
sort--namely, conjunctions of propositions that particular variables take on values from a particular disjunctive
list of categories.
This class represents a Simulation using Structural Equation Modeling (SEM).
Includes methods for estimating the standard errors of the freeParameters of
an estimated SEM.
SEM the discretize.
Calculates updated structural equation models given evidence of the form X1=x1',...,The main task of such and
algorithm is to calculate P(X = x' | evidence), where evidence takes the form of a Proposition over the variables in
the Bayes net, possibly with additional information about which variables in the Bayes net have been manipulated.
This class takes an xml element representing a SEM im and converts it to a SemIM
This class converts a SemIm into xml.
This class provides methods for finding sepsets in a given graph.
Stores a map from pairs of nodes to separating sets--that is, for each unordered pair of nodes {node1, node2} in
a graph, stores a set of nodes conditional on which node1 and node2 are independent (where the nodes are considered
as variables) or stores null if the pair was not judged to be independent.
This is the same as the usual SepsetMap described below, but also keeps up with the individual sets of conditioning
nodes for d-separation relations for use with the Distributed Causal Inference (DCI) algorithm.
Provides a covenience interface for classes that can generate and keep track of sepsets.
Provides a SepsetProducer that selects the first sepset it comes to from among the extra sepsets or the adjacents of
i or k, or null if none is found.
The class SepsetsMaxP implements the SepsetProducer interface and provides methods for generating sepsets based on a
given graph and an independence test.
The SepsetsMinP class is a concrete implementation of the SepsetProducer interface.
Provides a sepset producer using conditional independence tests to generate
the Sepset map, for the case where possible msep sets are required.
Provides a sepset producer using conditional independence tests to generate
the Sepset map.
The SetEndpointStrategy interface provides a strategy for setting the endpoint of an edge in a graph.
Represents an ordered sextad of nodes.
Represents an ordered sextad of variables.
Tries to find a good shifting of variables to minimize average BIC for
time-series data.
Stores a 2D array of short data.
SimpleDataLoader class.
Randomizes a graph using existing factors by first removing all edges and then adding for each factor (a) an edge
from the same factor at time lag 1 and (b) a given number of factors chosen uniformly from all lagged factors with
lag > 0.
SimulateNetwork class.
SimulateNetworkMain class.
The interface that simulations must implement.
Some simulations may wish to implement this interface to specify a simulation path, which will be printed in the
output.
A list of simulations to be compared.
Jun 4, 2019 3:10:49 PM
Jun 4, 2019 5:21:45 PM
Created by jdramsey on 12/22/15.
A
Simulation implementation that returns a single supplied data set.Stores a single graph for use in simulations, etc.
PC.
A pretend distribution that always returns the given value when nextRandom() is called.
Skew.
SkewE.
SP (Sparsest Permutation)
Implements the SP (Sparsest Permutation) algorithm.
Adjusts GFCI to use a permutation algorithm (in this case SP) to do the initial steps of finding adjacencies and
unshielded colliders.
Uses SP in place of FGES for the initial step in the GFCI algorithm.
Wraps a chi square distribution for purposes of drawing random samples.
Specifies how a column (continuous or discrete) should be discretized.
Euclidean dissimilarity metric--i.e., the sum of the differences in corresponding variable values.
Stability selection.
Runs a search algorithm over a N subsamples of size b to asses stability as in "Stability Selection" and "Stability
Approach to Regularization Selection"
A special SEM model in which variances of variables are always 1 and means of variables are always 0.
The initialization method for the model.
Stores a coefficient range--i.e.
Standardized SEM simulation.
StARS
The interface that each statistic needs to implement.
A list of statistics and their utility weights.
Contains a number of basic statistical functions.
Creates a table of stored cell probabilities for the given list of
variables.
Creates a table of stored cell probabilities for the given list of
variables.
Stores a file for reading in a lag graph from a file.
Calculates the structural Hamming distance (SHD) between the estimated graph and the true graph.
Generates (nonrecursively) all of the sublists of size b from a list of size a, where a, b are nonnegative integers
and a >= b.
An interface for suborder searches for various types of permutation algorithms.
Adapts FAS for the time series setting, assuming the data is generated by a SVAR (structural vector autoregression).
The SvarFci class is an implementation of the SVAR Fast Causal Inference algorithm.
Adapts FCI for the time series setting, assuming the data is generated by a SVAR (structural vector autoregression).
Adapts FGES for the time series setting, assuming the data is generated by a SVAR (structural vector autoregression).
SvarGfci class is an implementation of the SVAR GFCI algorithm.
Represents a GFCI search algorithm for structure learning in causal discovery.
The SvarSetEndpointStrategy class implements the SetEndpointStrategy interface and provides a strategy for setting
the endpoint of an edge in a graph.
Implements a space-efficient symmetric matrix (of elements of type
short), storing only the lower
triangular portion of itImplements a space-efficient symmetric matrix (of elements of type
short), storing only the lower
triangular portion of itA confusion matrix for tails--i.e.
TailPrecision is a class that implements the Statistic interface.
Implements the TailRecall statistic, which calculates the tail recall value for a given true graph, estimated graph,
and data model.
Tags algorithm comparison wrappers that can take a covariance matrix as input.
Tags a gadget that takes a data model list as argument to its constructor.
Tags an algorithm that can take an external graph as input.
TakesGraph interface.
Tags an algorithm as using an independence wrapper.
Tanh.
This cancels all processes that check the TaskManager.getInstance().isCanceled() method.
This class is for running a list of tasks that implement Callable.
Expands templates for the generalized SEM PM.
Tests the BooleanFunction class.
Test the degenerate Gaussian score.
Test the degenerate Gaussian score.
Tests the IndexedConnectivity class by constructing graphs with randomly chosen parameters and seeing if they have
the required properties.
Tests the IndexedLagGraph class by constructing graphs with randomly chosen parameters and seeing if they have the
required properties.
Tests the MeasurementSimulator class using diagnostics devised by Richard Scheines.
Aug 31, 2017 4:42:08 PM
Sep 26, 2017 1:18:28 AM
Tests the Polynomial class.
Tests the PolynomialTerm class.
Test the Reveal evaluator.
Tests the SimpleRandomizer class by constructing graphs with randomly chosen parameters and seeing if they have the
required properties.
Represents a ordered tetrad of variables, (i, j, k, l).
Some algebra methods.
Represents a logging utility used throughout tetrad.
Represents an empty configuration for the logger.
Represents an output stream that can get its own length.
Represents the configuration for the logger.
Represents an event which is just an id and a description.
An event associated with the
TetradLoggerListener.A listener for tetrad's logger.
Nov 10, 2017 4:14:31 PM
Interface to tag a class that is part of the set of serializable classes
in the Tetrad API.
Interface to tag a class that should be exluded from the set of
TetradSerializable classes, even if it implements the TetradSerializable interface.
Contains methods used by TestSerialization to ensure that previous "stable" versions of Tetrad will by loadable by
later "stable" versions of Tetrad.
Provides an interface for classes that test tetrad constraints.
Implements different tests of tetrad constraints: using Wishart's test (CPS, Wishart 1928); Bollen's test (Bollen,
1990) or a more computationally intensive test that fits one/two factor Gaussian models.
Implements a test of tetrad constraints with discrete variables.
Implements a test of tetrad constraints in a known correlation matrix.
Stores a 2D array of Strings for printing out tables.
An enum of delimiters.
Implements and extends a scorer extending Teyssier, M., and Koller, D.
Represents a time series graph--that is, a graph with a fixed number S of lags, with edges into initial lags
only--that is, into nodes in the first R lags, for some R.
Represents a NodeId with a name and a lag value.
Nov 14, 2017 12:00:31 PM
An enum of graph types to compare.
Aug 7, 2019 6:17:29 PM
Stores time series data as a list of continuous columns.
Time series SEM simulation.
Allowable tokens.
The class is used to find the top eigenvalues and eigenvectors of a given matrix.
Represents a transformation on some dataset.
Stores a triple (x, y, z) of nodes.
Marks a search algorithm as a triad classifier and returns the triad classifications if makes.
Represents the statistic of False Negatives for Arrows compared to the true DAG.
The class TrueDagFalseNegativesTails implements the Statistic interface to calculate the number of false negatives
for tails compared to the true Directed Acyclic Graph (DAG).
Represents a statistic that calculates the false positives for arrows compared to the true directed acyclic graph
(DAG).
TrueDagFalsePositiveTails is a class that implements the Statistic interface.
The proportion of X*->Y in the estimated graph for which there is no path Y~~>X in the true graph.
A class that implements the Statistic interface to calculate the proportion of X-->Y edges in the estimated graph for
which there is a path X~~>Y in the true graph.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
A normal distribution that allows its parameters to be set and allows random sampling.
Finds the PAG to which a DAG belongs, for a time series model.
Contains some utilities for doing autoregression.
Gives a result consisting of the residuals and collapsed var graphs.
The 2-cycle precision.
The 2-cycle precision.
The 2-cycle precision.
The 2-cycle recall.
The 2-cycle precision.
Underlines class.
For given a, b (a < b), returns a point chosen uniformly from [a, b].
The UniformityTest class provides methods to calculate the p-value of a list of points using the Kolmogorov-Smirnov
test and determine if the distribution is uniform.
Interface to tag classes that should not be cloned by marshalling.> 0
Sep 19, 2017 1:56:20 PM
Represents a Bayes IM in which all of the conditional probability tables have been updated to take into account
evidence.
Implements a function from the previous time steps of a history array to the getModel time step.
Tags an algorithm as using a score wrapper.
Interface implemented by classes, instantiations of which are capable of serving as variables for columns in a
DataSet.
An Expression for a variable.
Inteface implemented by classes, instantiations of which are associated with lists of variables.
Feb 9, 2016 3:18:03 PM
Feb 9, 2016 3:18:44 PM
Feb 9, 2016 3:19:52 PM
Implements the "fast adjacency search" used in several causal algorithm in this package.
Implements a convervative version of PC, in which the Markov condition is assumed but faithfulness is tested
locally.
An enum of triple types.
Implements a convervative version of PC, in which the Markov condition is assumed but faithfulness is tested
locally.
Implements a convervative version of PC, in which the Markov condition is assumed but faithfulness is tested
locally.
An enum of the types of triples that can be found in a graph.
Vector wrapping matrix library.
Represents the getModel Tetrad version.
Stores a 2D array of double data.
Stores a 2D array of int data.
This version of Vicinity finds nearby nodes by searching with an expanding cube Prior to Vicinity4, versions of
Vicinity looked at the 3 axis independently instead of collectively.
Implements the Washdown algorithm,
Wrapper for linear, Gaussian Extended BIC score (Chen and Chen).
Implements an unpublished score based on a risk bound due to Zhang and Shen.