Uses of Interface
edu.cmu.tetrad.util.TetradSerializable

Packages that use TetradSerializable

Package	Description
edu.cmu.tetrad.algcomparison
edu.cmu.tetrad.algcomparison.algorithm
edu.cmu.tetrad.algcomparison.algorithm.continuous.dag
edu.cmu.tetrad.algcomparison.algorithm.multi
edu.cmu.tetrad.algcomparison.algorithm.oracle.cpdag
edu.cmu.tetrad.algcomparison.algorithm.oracle.pag
edu.cmu.tetrad.algcomparison.algorithm.other
edu.cmu.tetrad.algcomparison.algorithm.pairwise
edu.cmu.tetrad.algcomparison.graph
edu.cmu.tetrad.algcomparison.independence
edu.cmu.tetrad.algcomparison.score
edu.cmu.tetrad.algcomparison.simulation
edu.cmu.tetrad.algcomparison.statistic
edu.cmu.tetrad.algcomparison.utils
edu.cmu.tetrad.bayes
edu.cmu.tetrad.calculator.expression
edu.cmu.tetrad.classify
edu.cmu.tetrad.data
edu.cmu.tetrad.data.missing
edu.cmu.tetrad.data.simulation
edu.cmu.tetrad.estimate.v1
edu.cmu.tetrad.graph
edu.cmu.tetrad.hybridcg
edu.cmu.tetrad.regression
edu.cmu.tetrad.search	This package contains classes for causal graph search algorithms.
edu.cmu.tetrad.search.blocks
edu.cmu.tetrad.search.score	This package contains classes for scoring causal graph models.
edu.cmu.tetrad.search.test	This package contains classes for testing causal graph search algorithms.
edu.cmu.tetrad.search.utils	This package contains utility classes for causal graph search algorithms.
edu.cmu.tetrad.search.work_in_progress	A package for algorithms that are not ready for prime time.
edu.cmu.tetrad.sem
edu.cmu.tetrad.study.gene.tetrad.gene.graph	Contains an editable display graph for (small) lag graphs.
edu.cmu.tetrad.study.gene.tetrad.gene.history	Implements a time-series simulation engine suitable for time-series gene expression studies.
edu.cmu.tetrad.study.gene.tetrad.gene.simulation	Contains classes for generating simulations of expression levels over a collection of genes.
edu.cmu.tetrad.study.gene.tetradapp.model
edu.cmu.tetrad.util
edu.cmu.tetrad.util.dist

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison

Classes in edu.cmu.tetrad.algcomparison that implement TetradSerializable

Modifier and Type	Class	Description
class	Comparison	Script to do a comparison of a list of algorithms using a list of statistics and a list of parameters and their values.

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison.algorithm

Subinterfaces of TetradSerializable in edu.cmu.tetrad.algcomparison.algorithm

Modifier and Type	Interface	Description
interface	Algorithm	Interface that algorithm must implement.
interface	MultiDataSetAlgorithm	Implements an algorithm that takes multiple data sets as input.

Classes in edu.cmu.tetrad.algcomparison.algorithm that implement TetradSerializable

Modifier and Type	Class	Description
class	AbstractBootstrapAlgorithm	This is a base class for bootstrap algorithms.
class	AbstractMultiBootstrapAlgorithm	A base class for bootstrapping multi-dataset algorithms (such as IMaGES), parallel to AbstractBootstrapAlgorithm for single-dataset algorithms.
class	Algorithms	A list of algorithm to be compared.
class	ExternalAlgorithm	Tags an an algorithm that loads up external graphs for inclusion in reports.
class	FirstInflection	First inflection point.
class	StabilitySelection	Stability selection: runs the wrapped algorithm on resamples of the data and returns the graph containing exactly those edges (with orientation) appearing in more than "percentStability" of the resample graphs.
class	StARS	StARS (Stability Approach to Regularization Selection): selects a value for one numeric parameter of a wrapped algorithm by sweeping the parameter over [low, high] in steps of 0.5, measuring the StARS adjacency instability of the algorithm's output over a fixed set of resamples at each value, choosing the value with the largest instability strictly below the cutoff (Params "StARS.cutoff"), and then running the wrapped algorithm on the full data at the chosen value.

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison.algorithm.continuous.dag

Classes in edu.cmu.tetrad.algcomparison.algorithm.continuous.dag that implement TetradSerializable

Modifier and Type	Class	Description
class	Dagma	Implements the DAGMA algorithm.
class	DirectLingam	Direct LiNGAM.
class	Fask	FASK algorithm.
class	FaskOrig	Deprecated.
class	IcaLingam	ICA-LiNGAM, the former name of LiNGAM.
class	IcaLingD	ICA-LiNG-D, the former name of LiNG-D.
class	Lingam	IcaLingam class implements the Algorithm and ReturnsBootstrapGraphs interface.
class	LingD	IcaLingD is an implementation of the Algorithm interface that performs the LiNG-D algorithm for discovering causal models for the linear non-Gaussian case where the underlying model might be cyclic.

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison.algorithm.multi

Classes in edu.cmu.tetrad.algcomparison.algorithm.multi that implement TetradSerializable

Modifier and Type	Class	Description
class	FaskConcatenated	Wraps the IMaGES algorithm for continuous variables.
class	FaskPool	Wraps the pooled-FASK multi-dataset algorithm for continuous variables.
class	FaskVote	Wraps the MultiFask algorithm for continuous variables.
class	FciIod	Runs FCI on multiple datasets using the IOD pooled dataset independence test.
class	FgesConcatenated	Requires that the parameter 'randomSelectionSize' be set to indicate how many datasets should be taken at a time (randomly).
class	Images	Wraps the IMaGES algorithm for continuous variables.
class	ImagesBoss	Wraps the IMaGES algorithm for continuous variables.
class	ImagesFges	Wraps the IMaGES algorithm for continuous variables.
class	Ion	Runs the ION (Integration of Overlapping Networks) algorithm on multiple datasets whose variable sets may overlap only partially.

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison.algorithm.oracle.cpdag

Classes in edu.cmu.tetrad.algcomparison.algorithm.oracle.cpdag that implement TetradSerializable

Modifier and Type	Class	Description
class	Boss	BOSS (Best Order Score Search)
class	BossCdnodScore	BOSS + score-based CD-NOD context augmentation.
class	BossTopK	BOSS-TopK (Best Order Score Search, Top K).
class	BossTrekMimic	Deprecated.
class	Cam	Represents the CAM algorithm, which is a causal additive model search algorithm.
class	Cdnod	CD-NOD wrapper for algcomparison.
class	CdnodBoss	Algcomparison wrapper for the CD-NOD-BOSS search (CdnodBoss): a BOSS backbone with constraint-based collider orientation applied only to unshielded triples that BOSS leaves fully undirected, followed by Meek closure.
class	CdnodPag	CD-NOD wrapper for algcomparison.
class	Cpc	Conservative PC (CPC).
class	Cstar	Cstar class.
class	Fas	Fast Adjacency Search (FAS)--i.e., the PC adjacency step, which is used in many algorithms.
class	Fges	FGES (the heuristic version).
class	FgesMb	FGES-MB (the heuristic version).
class	Flop	FLOP (Fast Learning of Order and Parents).
class	Grasp	GRaSP (Greedy Relaxations of Sparsest Permutation)
class	IsFges	IS-FGES (Instance-Specific FGES) wrapper for the algcomparison interface.
class	Pc	Peter/Clark algorithm (PC).
class	PcAr	Peter/Clark algorithm with adjacency-rescue (PcAR): PC augmented with detection, and optionally repair, of cancelled unfaithful-triangle edges.
class	Pcd	PC.
class	PcMax	PC-Max.
class	PcMb	PC.
class	Pcmci	PCMCI wrapper for algcomparison.
class	RestrictedBoss	Implements a restricted version of the BOSS (Best Order Score Search) algorithm that focuses search on a set of target variables and their immediate causes.
class	SingleGraphAlg	PC.
class	Sp	SP (Sparsest Permutation)
class	Tgin	Deprecated.
class	TrekMimic	Algorithm-comparison wrapper for the Trek-MIMIC search.
class	TwoStep	Deprecated.

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison.algorithm.oracle.pag

Classes in edu.cmu.tetrad.algcomparison.algorithm.oracle.pag that implement TetradSerializable

Modifier and Type	Class	Description
class	Bfci	Adjusts FGES-FCI to use a permutation algorithm (such as BOSS-Tuck) to do the initial steps of finding adjacencies and unshielded colliders.
class	BfciBryan	BFCI-Bryan: BOSS followed by the from-scratch, sepset-map-as-state formulation of the gated StarFCI extra-edge-removal step, with sepset RE-SELECTION (a gate-rejected separating set does not retire the pair; the next separating set is tried) and NO saturating step.
class	BfciBryanScore	BFCI-Bryan-Score: BFCI-Bryan (sepset re-selection under the legality gate) with a scoring step: a legal candidate is committed only if the RICF Gaussian BIC of its MAG strictly improves on the committed model's, following Bryan Andrews's "BFCI-Bryan with scoring" pseudocode.
class	BfciC	Adjusts FGES-FCI to use a permutation algorithm (such as BOSS-Tuck) to do the initial steps of finding adjacencies and unshielded colliders.
class	BfciD	Adjusts FGES-FCI to use a permutation algorithm (such as BOSS-Tuck) to do the initial steps of finding adjacencies and unshielded colliders.
class	BfciScoreCheck	/ Hidden from the interface on 2026-10-21 (no @Algorithm annotation): kept only so that saved sessions
class	BossCcd	BOSS-CCD (Cyclic Causal Discovery with a BOSS adjacency superstructure).
class	BossFci	BOSS-FCI, the former name of BFCI.
class	BossPod	BOSS-POD, removed in Tetrad 8.0.0.
class	Ccd	CCD (Cyclic Causal Discovery)
class	Cfci	CFCI (Conservative FCI).
class	Cpw	Implements the CPW (Cyclic Pairwise) algorithm for causal discovery from continuous, causally sufficient observational data.
class	Dm	Algorithm-comparison wrapper for the Murray-Watters/Glymour style Detect-Mimic search, DM.
class	DmFcit	DM-FCIT, removed in Tetrad 8.0.0.
class	DmPc	DM-PC, removed in Tetrad 8.0.0.
class	Fci	The Fast Causal Inference (FCI) algorithm.
class	FciCyclicPw	FCI-CPW: Run FCI with internally constructed PW-forbidden knowledge, then orient edges using a pairwise left-right rule on standardized data in cases that are safe under no-selection-bias cyclic semantics: Tail–tail (—) edges Orient per pairwise rule. Tail–circle (—o) edges If pairwise prefers x→y, set x→y (symmetrically, if prefers y→x, set y→x). Circle–circle (o–o) edges If pairwise prefers x→y, set x o→y (symmetrically for y→x).
class	FciMax	FCI-Max.
class	Fcit	This class represents the FCI Targeted Testing (FCIT) algorithm, which is variant of the *-FCI algorithm for learning causal structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based steps afterward.
class	FcitMagMarkov	This class represents the FCI Targeted Testing (FCIT) algorithm, which is variant of the *-FCI algorithm for learning causal structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based steps afterward.
class	FcitMarkov	This class represents the FCI Targeted Testing (FCIT) algorithm, which is variant of the *-FCI algorithm for learning causal structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based steps afterward.
class	FcitSl	This class represents the FCI Targeted Testing (FCIT) algorithm, which is variant of the *-FCI algorithm for learning causal structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based steps afterward.
class	FcitSlScoreCheck	FCIT-SL-Score-Check: the FCIT-SL algorithm with a MAG BIC SCORE CHECK applied to every candidate the search adjudicates.
class	FcitZm	This class represents the FCI Targeted Testing (FCIT) algorithm, which is variant of the *-FCI algorithm for learning causal structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based steps afterward.
class	Gfci	The Fges-FCI class represents the Greedy Fast Causal Inference algorithm, adjusted as in *-FCI.
class	GfciOld	The GFCI class represents the Greedy Fast Causal Inference algorithm, adjusted as in *-FCI.
class	Gmas	GMAS: a latent-variable search that uses no independence tests.
class	GraspFci	GRaSP-FCI, an implentatation of *-FCI using GRaSP.
class	Icd	The Iterative Causal Discovery (ICD) algorithm.
class	IsGfci	IS-GFCI (Instance-Specific GFCI) wrapper for the algcomparison interface.
class	LvBossExperimental	Wrapper for LV-BOSS: the fully score-based latent-variable search that embeds a MAG projection inside a BOSS-style search over orders, scored by the exact RICF Gaussian MAG BIC (MagRicfBicScorer).
class	LvHeuristic	This class represents the FCIT algorithm, which is an implementation of the FGES-FCI algorithm for learning causal structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based steps afterward.
class	PagSampleRfci	PAG-Sampling-RFCI, the former name of the class now called PagSamplingRfci.
class	PagSamplingRfci	Jan 29, 2023 3:45:09 PM
class	Rfci	RFCI.
class	RfciBsc	Runs RFCI-BSC, which is RFCI with bootstrap sampling of PAGs.
class	SpFci	Adjusts GFCI to use a permutation algorithm (in this case SP) to do the initial steps of finding adjacencies and unshielded colliders.

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison.algorithm.other

Classes in edu.cmu.tetrad.algcomparison.algorithm.other that implement TetradSerializable

Modifier and Type	Class	Description
class	FactorAnalysis	Factor analysis.
class	Glasso	GLASSO.
class	MimbuildBollen	Mimbuild Bollen.
class	MimbuildPca	Mimbuild PCA.
class	PythonGin	Deprecated.
class	Rlcd	Wrapper for the RLCD algorithm (Rank-based Latent Causal Discovery; Dong et al., ICLR 2024), which learns a graph over the observed variables and newly introduced latent variables from rank constraints on the covariance matrix.

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison.algorithm.pairwise

Classes in edu.cmu.tetrad.algcomparison.algorithm.pairwise that implement TetradSerializable

Modifier and Type	Class	Description
class	FaskPw	FASK-PW (pairwise).
class	R1	R1.
class	R2	R2.
class	R3	R3.
class	Rskew	RSkew.
class	RskewE	RSkewE.
class	Skew	Skew.
class	SkewE	SkewE.
class	Tanh	Tanh.

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison.graph

Subinterfaces of TetradSerializable in edu.cmu.tetrad.algcomparison.graph

Modifier and Type	Interface	Description
interface	RandomGraph	An interface to represent a random graph of some sort.

Classes in edu.cmu.tetrad.algcomparison.graph that implement TetradSerializable

Modifier and Type	Class	Description
class	Cyclic	Returns a cyclic graph build up from small cyclic graph components.
class	ErdosRenyi	Creates a random graph by the Erdos-Renyi method (probabiliy of edge fixed, # edges not).
class	RandomForward	Creates a random graph by adding forward edges.
class	RandomMim	Creates a random graph by adding forward edges.
class	RandomMimic	Creates a random graph by adding forward edges.
class	RandomSingleFactorMim	Creates a random graph by adding forward edges.
class	RandomTwoFactorMim	Creates a random graph by adding forward edges.
class	ScaleFree	Returns a scale free graph.
class	SingleGraph	Stores a single graph for use in simulations, etc.

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison.independence

Subinterfaces of TetradSerializable in edu.cmu.tetrad.algcomparison.independence

Modifier and Type	Interface	Description
interface	BlockIndependenceWrapper	An interface that extends functionality of the IndependenceWrapper and HasParameters interfaces by adding support for block-specific configuration in independence testing.
interface	IndependenceWrapper	Interface that algorithm must implement.

Classes in edu.cmu.tetrad.algcomparison.independence that implement TetradSerializable

Modifier and Type	Class	Description
class	BasisExpandedGcm	Wrapper for BE-GCM (Basis-Expanded Generalised Covariance Measure Test).
class	BasisFunctionBlocksIndTest	Wrapper for BF-Blocks-Test.
class	BasisFunctionLrt	Wrapper for BF-LRT (Basis Function Likelihood Ratio Test).
class	BlocksIndTest	Deprecated.
class	BlocksIndTestLemma10	Deprecated.
class	BlocksIndTestTs	Wrapper for BF-Blocks-Test.
class	CciTest	Wrapper for Daudin Conditional Independence test.
class	ChiSquare	Wrapper for Fisher Z test.
class	ClFisherZPython	An IndependenceWrapper that runs the Fisher Z conditional independence test implemented in the Python causal-learn library, bridging it into Tetrad's IndependenceTest framework.
class	ClKciPython	An IndependenceWrapper that runs the Kernel-based Conditional Independence (KCI) test implemented in the Python causal-learn library, bridging it into Tetrad's IndependenceTest framework.
class	ClRcitPython	An IndependenceWrapper that runs the Randomized Conditional Independence Test (RCIT) implemented in the Python causal-learn library, bridging it into Tetrad's IndependenceTest framework.
class	ConditionalGaussianLrt	Wrapper for Fisher Z test.
class	Cord	Wrapper for the CORD conditional independence test backed by Eric's engine (IndTestCordEric): an omnibus, orthogonal rank-score test of Y ⊥ Z | X that is sensitive to higher-moment, tail, and co-volatility dependence which a covariance-based test (e.g., Fisher Z) cannot see.
class	DegenerateGaussianLrt	Wrapper for DG LRT.
class	DgBicTest	The SemBicTest class implements the IndependenceWrapper interface and represents a test for independence based on SEM BIC algorithm.
class	EquivalenceTest	Wrapper for the equivalence (TOST) test on the Fisher Z partial correlation.
class	FfCi	Wrapper for FFCI test with a reduced parameter set.
class	FfCiContinuous	Wrapper for FF-CI-Continuous test.
class	FisherZ	Wrapper for Fisher Z test.
class	Gcm	Wrapper for KCI test.
class	Gin	Wrapper for GIN (Generalized Independent Noise) residual-independence test.
class	GSquare	Wrapper for Fisher Z test.
class	Kci	Wrapper for KCI test.
class	MinimaxCITest	Wrapper for Minimax binning test.
class	MSeparationTest	Wrapper for M-separation test.
class	MultinomialLogisticRegressionWald	Wrapper for Fisher Z test.
class	Mvplrt	Deprecated.
class	PoissonBicTest	The SemBicTest class implements the IndependenceWrapper interface and represents a test for independence based on SEM BIC algorithm.
class	ProbabilisticTest	Dec 17, 2018 3:44:46 PM
class	RankIndependenceTestLemma10Singletons	Deprecated.
class	RankIndependenceTestTs	Rank Independence Test TS, the former name of the test now called Rank Independence Test TS Singletons.
class	RankIndependenceTestTsSingletons	Deprecated.
class	RankIndependenceTestWilkesSingletons	Deprecated.
class	Rcit	Wrapper for RCIT test.
class	SemBicTest	The SemBicTest class implements the IndependenceWrapper interface and represents a test for independence based on SEM BIC algorithm.
class	StratifiedRank	Wrapper for the stratified (domain-pooled) rank conditional independence test, IndTestStratifiedRank -- the Phase 1 test of LCD-NOD (Dong, Dai, Ng, Spirtes, and Zhang, ICML 2026).
class	TrekSeparationBlocksIndependence	Wrapper for Rank independence test.
final class	TRffLrTest	Wrapper for the TRFF likelihood-ratio CI test built on TRffBicScore.

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison.score

Subinterfaces of TetradSerializable in edu.cmu.tetrad.algcomparison.score

Modifier and Type	Interface	Description
interface	BlockScoreWrapper	Represents an interface for scoring data models using predefined block structures.
interface	ScoreWrapper	Interface that algorithm must implement.

Classes in edu.cmu.tetrad.algcomparison.score that implement TetradSerializable

Modifier and Type	Class	Description
class	BasisFunctionBgeScore	Wrapper for BF-BGe, the BGe (Normal-Wishart marginal likelihood) score over the basis-function embedding that BF-BIC uses.
class	BasisFunctionBicScore	Wrapper for Basis Function BIC Score (Basis-BIC) version.
class	BasisFunctionBicScoreTabular	Wrapper for the full-sample (tabular) Basis Function BIC Score, delegating to BasisFunctionBicScoreFullSample.
class	BdeuScore	Wrapper for Fisher Z test.
class	BfBlocksBicScore	Wrapper for Blocks BIC Score (Blocks-BIC) version.
class	BgeScore	Wrapper for the BGe (Bayesian Gaussian equivalent) score, the Gaussian analog of BDeu: the local score is the exact log marginal likelihood of a family under a Normal-Wishart prior rather than a BIC-penalized maximum likelihood.
class	BlocksBicScore	Wrapper for Blocks BIC Score (Blocks-BIC) version.
class	ConditionalGaussianBicScore	Wrapper for Fisher Z test.
class	DegenerateGaussianBgeScore	Wrapper for DG-BGe, the BGe (Normal-Wishart marginal likelihood) score over the degenerate Gaussian indicator embedding that DG-BIC uses.
class	DegenerateGaussianBicScore	Wrapper for degenerate Gaussian BIC score
class	DiscreteBicScore	Wrapper for Discrete BIC test.
class	EbicScore	Wrapper for linear, Gaussian Extended BIC score (Chen and Chen).
class	FfMl	Wrapper for FF-ML MIxed Marginal Likelihood Score.
class	FfMlContinuous	Wrapper for FF Marginal Likelihood Score.
class	GicScores	The GicScores class is an implementation of the ScoreWrapper interface that calculates the Generalized Information Criterion (GIC) scores for a given data model.
class	HeavyTailSemBicScore	Wrapper for linear, Gaussian SEM BIC score.
class	HuangMarginalLikelihoodScore	// * Wrapper for Huang Marginal Likelihood Score.
final class	InstanceAugmentedSemBicScoreWrapper	Wrapper for InstanceAugmentedSemBicScore that: - pulls the testing DataSet from Params.TESTING_DATA (injected by the algorithm wrapper), - takes the instance row from Params.INSTANCE_ROW, - aligns columns by training variable names, - uses alpha from Params.IS_ALPHA (default 1.0).
final class	IsBDeuScoreWrapper	Wrapper for ISBDeuScore (discrete).
class	KcvBicScore	Wrapper for KVC BIC score.
class	KernelMarginalLikelihoodScore	Wrapper for Kernel Marginal Likelihood Score.
class	MagDgBicScore	Wrapper for degenerate Gaussian BIC score
class	MSepScore	Wrapper for Fisher Z test.
class	MVPBicScore	Deprecated.
class	PoissonPriorScore	Wrapper for the Poisson prior score (Bryan)
class	RankBicScore	Wrapper for linear, Gaussian SEM BIC score.
class	RffBicScore	Wrapper for linear, Gaussian SEM BIC score.
class	SemBicScore	Wrapper for linear, Gaussian SEM BIC score.
class	TRffBicScore	The TRffBicScore class is a scoring mechanism designed to evaluate the fit and complexity of a data model.
class	ZhangShenBoundScore	Wrapper for linear, Gaussian Extended BIC score (Chen and Chen).

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison.simulation

Subinterfaces of TetradSerializable in edu.cmu.tetrad.algcomparison.simulation

Modifier and Type	Interface	Description
interface	Simulation	The interface that simulations must implement.

Classes in edu.cmu.tetrad.algcomparison.simulation that implement TetradSerializable

Modifier and Type	Class	Description
class	AdditiveNoiseSimulation	This class represents a Causal Perceptron Network.
class	BayesNetSimulation	Bayes net simulation.
class	ConditionalGaussianSimulation	A simulation method based on the conditional Gaussian assumption.
class	DaoSimulation	Implements the DAG-adaptation of the Onion (DaO) simulation method for generating linear data from a DAG, with exogenous errors drawn from one of the reference implementation's five variance-matched families (Gaussian by default; Exponential, Gumbel, Laplace, or Uniform via daoErrorDistribution), as described in:
class	DesignedExperimentSimulation	Simulates data with the anatomy of a designed physical experiment (the archetype is the NASA Airfoil Self-Noise dataset), in contrast to an observational sample.
class	GeneralAdditiveModel	Wrapper for the neural-net Generalized Additive Model (GAM) simulator.
class	GeneralNoiseSimulation	This class represents a Causal Perceptron Network.
class	GeneralSemSimulation	The GeneralSemSimulation class represents a simulation using a generalized structural equation model (SEM).
class	GeneralSemSimulationSpecial1	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.
class	GpSemSimulation	NL SEM simulation.
class	HybridCgSimulation	This class represents a Simulation using Structural Equation Modeling (SEM).
class	LeeHastieSimulation	A version of the Lee and Hastic simulation.
class	LgMnarSimulation	This class represents a continuous MNAR simulation.
class	LinearFisherModel	Linear Fisher Model.
class	LinearSineSimulation	A simulation method based on the mixed variable polynomial assumption.
class	NonGaussianSemSimulation	A linear SEM simulation whose exogenous noises are drawn independently from the distribution given by the customNoiseExpression parameter (default Exp(1)) rather than from Gaussians.
class	NonlinearFunctionsOfLinear	This class represents a nonlinear functions of linear simulation.
class	ObservationalStudySimulation	Simulates data with the anatomy of a real observational scientific dataset (the archetype is the Algerian Forest Fires dataset, but with all complications defaulted off this is a plain mixed-data cross-sectional study).
class	PostnonlinearSem	This class represents a post-nonlinear SEM model.
class	SemSimulation	This class represents a Simulation using Structural Equation Modeling (SEM).
class	SemThenDiscretize	SEM the discretize.
class	Simulations	A list of simulations to be compared.
class	SingleDatasetSimulation	A Simulation implementation that returns a single supplied data set.
class	StandardizedSemSimulation	Standardized SEM simulation.
class	TimeSeriesSemSimulation	Time series SEM simulation.
class	TrainedDagModel	Trained DAG model.

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison.statistic

Classes in edu.cmu.tetrad.algcomparison.statistic that implement TetradSerializable

Modifier and Type	Class	Description
class	Statistics	A list of statistics and their utility weights.

Uses of TetradSerializable in edu.cmu.tetrad.algcomparison.utils

Subinterfaces of TetradSerializable in edu.cmu.tetrad.algcomparison.utils

Modifier and Type	Interface	Description
interface	MultiDataSetScoreWrapper	A score wrapper that can construct its per-data-set scores jointly, coordinating any data-dependent representation choices across the data sets.

Classes in edu.cmu.tetrad.algcomparison.utils that implement TetradSerializable

Modifier and Type	Class	Description
final class	PooledIndependenceWrapper	The test-side counterpart of PooledScoreWrapper: builds the inner test on each pooled data set and combines them with IndTestMulti using Fisher's method (default) or Tippett's method on the per-data-set p-values, per Params.POOLED_TEST_METHOD (data sets are assumed independent of one another, e.g.
final class	PooledScoreWrapper	A score wrapper that pools several data sets into one IMaGES score built from an inner score wrapper.

Uses of TetradSerializable in edu.cmu.tetrad.bayes

Subinterfaces of TetradSerializable in edu.cmu.tetrad.bayes

Modifier and Type	Interface	Description
interface	BayesIm	Interface implemented by Bayes instantiated models.
interface	BayesUpdater	Interface for a discrete Bayes updating algorithm.
interface	CptMap	An interface representing a map of probabilities or counts for nodes in a Bayesian network.
interface	ManipulatingBayesUpdater	Interface for a Bayes updating algorithm that's capable of doing manipulation.

Classes in edu.cmu.tetrad.bayes that implement TetradSerializable

Modifier and Type	Class	Description
final class	ApproximateUpdater	Calculates updated marginals for a Bayes net by simulating data and calculating likelihood ratios.
final class	BayesImProbs	Calculates cell probabilities from conditional BayesIm probabilities on the fly without constructing the entire table.
final class	BayesPm	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.
class	CptMapCounts	Represents a conditional probability table (CPT) in a Bayes net.
class	CptMapProbs	Represents a conditional probability table (CPT) in a Bayes net.
final class	DirichletBayesIm	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.
final class	Evidence	Stores information for a variable source about evidence we have for each variable as well as whether each variable has been manipulated.
final class	Identifiability	Identifiability, based on RowSummingExactUpdater
final class	JunctionTreeUpdater	RowSummingExactUpdater-style updater plumbing, but uses JunctionTreeInference for marginals/joints/conditionals.
final class	Manipulation	Stores information for a variable source about evidence we have for each variable as well as whether each variable has been manipulated.
final class	MlBayesIm	Stores a table of probabilities for a Bayes net and, together with BayesPm and Dag, provides methods to manipulate this table.
final class	MlBayesImObs	Stores a table of probabilities for a Bayes net and, together with BayesPm and Dag, provides methods to manipulate this table.
final class	Proposition	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.
final class	RowSummingExactUpdater	Performs updating operations on a BayesIm by summing over cells in the joint probability table for the BayesIm.
final class	StoredCellProbs	Creates a table of stored cell probabilities for the given list of variables.
final class	StoredCellProbsObs	///////////////////////////////////////////////////////////////////
final class	UpdatedBayesIm	Represents a Bayes IM in which all of the conditional probability tables have been updated to take into account evidence.
final class	VariableEliminationUpdater	RowSummingExactUpdater-style updater plumbing, but uses VariableEliminationInference for marginals/joints/conditionals.

Uses of TetradSerializable in edu.cmu.tetrad.calculator.expression

Subinterfaces of TetradSerializable in edu.cmu.tetrad.calculator.expression

Modifier and Type	Interface	Description
interface	Expression	Represents a mathematical expression.
interface	ExpressionDescriptor	Represents a definition for some expression.
interface	ExpressionSignature	Represents the signature of the expression, for example sqrt(number).

Classes in edu.cmu.tetrad.calculator.expression that implement TetradSerializable

Modifier and Type	Class	Description
class	ConstantExpression	Represents a constant expression, that is an expression that always evaluates to the same value.
class	EvaluationExpression	An equation expression.
static enum	ExpressionDescriptor.Position	An enum of positions that an expression can occur in.
class	VariableExpression	An Expression for a variable.

Uses of TetradSerializable in edu.cmu.tetrad.classify

Classes in edu.cmu.tetrad.classify that implement TetradSerializable

Modifier and Type	Class	Description
final class	ClassifierBayesUpdaterDiscrete	This class contains a method classify which uses an instantiated Bayes net (BayesIm) provided in the constructor.

Uses of TetradSerializable in edu.cmu.tetrad.data

Subinterfaces of TetradSerializable in edu.cmu.tetrad.data

Modifier and Type	Interface	Description
interface	DataBox	Stores a 2D array of data.
interface	DataModel	Interface implemented by classes, instantiations of which can serve as data models in Tetrad.
interface	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.
interface	ICovarianceMatrix	Interface for covariance matrices.
interface	KnowledgeTransferable	Interface implemented by classes that are capable of participating in the transfer of knowledge objects.
interface	Simulator	Created by jdramsey on 12/22/15.
interface	Variable	Interface implemented by classes, instantiations of which are capable of serving as variables for columns in a DataSet.
interface	VariableSource	Inteface implemented by classes, instantiations of which are associated with lists of variables.

Classes in edu.cmu.tetrad.data that implement TetradSerializable

Modifier and Type	Class	Description
class	AbstractVariable	Base class for variable specifications for DataSet.
final class	BoxDataSet	Wraps a DataBox in such a way that mixed data sets can be stored.
class	ByteDataBox	Stores a 2D array of byte data.
final class	ContinuousDiscretizationSpec	Specifies how a column (continuous or discrete) should be discretized.
final class	ContinuousVariable	Represents a real-valued variable.
final class	CorrelationMatrix	Stores a correlation matrix together with variable names and sample size; intended as a representation of a data set.
class	CorrelationMatrixOnTheFly	Stores a covariance matrix together with variable names and sample size, intended as a representation of a data set.
class	CovarianceMatrix	Stores a covariance matrix together with variable names and sample size, intended as a representation of a data set.
class	CovarianceMatrixOnTheFly	Stores a covariance matrix together with variable names and sample size, intended as a representation of a data set.
final class	DataModelList	Stores a list of data models and keeps track of which one is selected.
final class	DelimiterType	Type-safe enum of delimiter types for parsing data.
final class	DiscreteDiscretizationSpec	Specifies how a column (continuous or discrete) should be discretized.
final class	DiscreteVariable	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.
final class	DiscreteVariableType	Type-safe enum of discrete variable types.
class	DoubleDataBox	Stores a 2D array of double data.
class	FloatDataBox	Stores a 2D array of float data.
class	IndependenceFacts	Stores a list of independence facts.
class	IntDataBox	Stores a 2D array of integer data.
final class	Knowledge	Stores information about required and forbidden edges and common causes for use in algorithm.
final class	KnowledgeEdge	Implements a knowledge edge X-->Y as a simple ordered pair of strings.
final class	KnowledgeGroup	Represents a "Other Group" in Knowledge, which can be understood as: Group1 -> Group2 where there are edges between all members of Group1 to Group2.
final class	KnowledgeTierStructure	An additional, named tier structure over (a subset of) the variables of a Knowledge object, independent of the main temporal tiers and of every other tier structure.
class	LongDataBox	Stores a 2D array of long data.
class	MixedDataBox	Stores a 2D array of double continuousData.
final class	NumberObjectDataSet	Wraps a 2D array of Number objects in such a way that mixed data sets can be stored.
class	ShortDataBox	Stores a 2D array of short data.
final class	SplitCasesSpec	Specifies how a column (continuous or discrete) should be discretized.
final class	TimeSeriesData	Stores time series data as a list of continuous columns.
class	VerticalDoubleDataBox	Stores a 2D array of double data.
class	VerticalIntDataBox	Stores a 2D array of int data.

Uses of TetradSerializable in edu.cmu.tetrad.data.missing

Classes in edu.cmu.tetrad.data.missing that implement TetradSerializable

Modifier and Type	Class	Description
final class	MissingDataSpec	An immutable specification of how missing data are to be handled: a MissingDataPolicy together with the parameters that policy needs (EM settings for MissingDataPolicy.EM_COVARIANCE, the number of imputations for MissingDataPolicy.MULTIPLE_IMPUTATION, and so on).

Uses of TetradSerializable in edu.cmu.tetrad.data.simulation

Classes in edu.cmu.tetrad.data.simulation that implement TetradSerializable

Modifier and Type	Class	Description
class	LoadContinuousDataAndGraphs	Load data sets and graphs from a directory.
class	LoadContinuousDataAndSingleGraph	Load data sets and graphs from a directory.
class	LoadContinuousDataSmithSim	Load data sets and graphs from a directory.
class	LoadDataAndGraphs	Load data sets and graphs from a directory.
class	LoadDataFromFileWithoutGraph	Load data sets and graphs from a directory.

Uses of TetradSerializable in edu.cmu.tetrad.estimate.v1

Classes in edu.cmu.tetrad.estimate.v1 that implement TetradSerializable

Modifier and Type	Class	Description
static final class	AdjustmentEffectEstimatorV1.ConfigV1	v1: Configuration knobs with conservative defaults.
static final class	AdjustmentEffectEstimatorV1.EffectEstimateResultV1	v1: Result object returned to UI/table.

Uses of TetradSerializable in edu.cmu.tetrad.graph

Subinterfaces of TetradSerializable in edu.cmu.tetrad.graph

Modifier and Type	Interface	Description
interface	Graph	Implements a graph capable of storing edges of type N1 *-# N2 where * and # are endpoints of type Endpoint.
interface	Node	Represents an object with a name, node type, and position that can serve as a node in a graph.

Classes in edu.cmu.tetrad.graph that implement TetradSerializable

Modifier and Type	Class	Description
final class	Dag	Represents a directed acyclic graph--that is, a graph containing only directed edges, with no cycles.
class	Edge	Represents an edge node1 *-# node2 where * and # are endpoints of type Endpoint--that is, Endpoint.TAIL, Endpoint.ARROW, or Endpoint.CIRCLE.
class	EdgeListGraph	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.
class	EdgeTypeProbability	Apr 13, 2017 3:56:46 PM
enum	Endpoint	A enumeration of the endpoint types that are permitted in Tetrad-style graphs: null (-), arrow (->), circle (-o), start (-*), and null (no endpoint).
class	GraphNode	Implements a basic node in a graph--that is, a node that is not itself a variable.
final class	IndependenceFact	Stores a triple (x, y, z) of nodes.
class	LagGraph	Implements a graph allowing nodes in the getModel time lag to have parents taken from previous time lags.
final class	LagReplicationPolicy	SVAR-style lag mirroring policy.
class	OrderedPair<E>	An ordered pair of objects.
class	Paths	Paths class.
class	ReplicatingGraph	EdgeListGraph subclass that applies an EdgeReplicationPolicy whenever edges are added/removed or endpoints are oriented.
final class	SemGraph	Represents the graphical structure of a structural equation model.
class	TimeLagGraph	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.
final class	Triple	Stores a triple (x, y, z) of nodes.
class	Underlines	Underlines class.

Uses of TetradSerializable in edu.cmu.tetrad.hybridcg

Classes in edu.cmu.tetrad.hybridcg that implement TetradSerializable

Modifier and Type	Class	Description
final class	HybridCgPruneReport	Result of HybridCgEdgeSignificance.backwardPrune(HybridCgModel.HybridCgPm, DataSet, double, boolean): a per-child backward elimination of edges whose per-edge likelihood-ratio test could not distinguish the reduced local model from the full one at the given level.
static final class	HybridCgPruneReport.Deletion	One proposed edge deletion.

Uses of TetradSerializable in edu.cmu.tetrad.regression

Classes in edu.cmu.tetrad.regression that implement TetradSerializable

Modifier and Type	Class	Description
class	LogisticRegression	Implements a logistic regression algorithm based on a Javascript implementation by John Pezzullo.
static class	LogisticRegression.Result	The result of a logistic regression.
class	RegressionResult	Stores the various components of a regression result so they can be passed around together more easily.

Uses of TetradSerializable in edu.cmu.tetrad.search

Subinterfaces of TetradSerializable in edu.cmu.tetrad.search

Modifier and Type	Interface	Description
interface	ModelObserver	The ModelObserver interface is implemented by classes that want to observe changes in a model.

Classes in edu.cmu.tetrad.search that implement TetradSerializable

Modifier and Type	Class	Description
static class	Cstar.Record	Represents a single record in the returned table for CSTaR.
static final class	NtadExplorer.NtadResult	Represents the result of a near-total aggregate decomposition (NTAD) analysis.

Uses of TetradSerializable in edu.cmu.tetrad.search.blocks

Classes in edu.cmu.tetrad.search.blocks that implement TetradSerializable

Modifier and Type	Class	Description
final class	BlockSpec	Represents a block specification that organizes data into blocks, each associated with a variable and a rank.

Uses of TetradSerializable in edu.cmu.tetrad.search.score

Classes in edu.cmu.tetrad.search.score that implement TetradSerializable

Modifier and Type	Class	Description
class	ScoredGraph	Stores a graph with a score for the graph.

Uses of TetradSerializable in edu.cmu.tetrad.search.test

Classes in edu.cmu.tetrad.search.test that implement TetradSerializable

Modifier and Type	Class	Description
final class	CachedIndependenceQueries	Shared cache + utilities for independence testing keyed by (X,Y|Z) using variable NAMES for mapping into the test, but using a structured int-ID cache key for speed/GC reduction.
static final record	CachedIndependenceQueries.Eval	This record represents an evaluation with a binary indicator of independence and an associated p-value.
final class	IndependenceResult	Stores a single conditional independence result, e.g., whether X _||_ Y | Z1,...,Zn holds or does not, and the p-value of the test.

Uses of TetradSerializable in edu.cmu.tetrad.search.utils

Classes in edu.cmu.tetrad.search.utils that implement TetradSerializable

Modifier and Type	Class	Description
class	AlmostCycleRemover	A class for heuristically removing almost cycles from a PAG to avoid unfaithfulness in an estimated PAG.
enum	BpcAlgorithmType	Enumerates the algorithm types for BuildPureClusters, and Purify.
enum	BpcTestType	Enumerates the test types for BuildPureClusters, and Purify.
final class	SepsetMap	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.
class	Sextad	Represents an ordered sextad of nodes.
class	Tetrad	Represents an ordered sextad of nodes.
final record	TetradInt	Represents an ordered tetrad (quartet) of nodes, where the order of nodes within {i, j} and {k, l} does not matter, but the order of the pairs <{i, j}, {k, l}> does matter.

Uses of TetradSerializable in edu.cmu.tetrad.search.work_in_progress

Classes in edu.cmu.tetrad.search.work_in_progress that implement TetradSerializable

Modifier and Type	Class	Description
class	Sextad	Represents an ordered sextad of variables.

Uses of TetradSerializable in edu.cmu.tetrad.sem

Subinterfaces of TetradSerializable in edu.cmu.tetrad.sem

Modifier and Type	Interface	Description
interface	ISemIm	An interface for SemIM's; see implementations.
interface	SemOptimizer	Interface for algorithm that optimize the fitting function of a SemIm model by adjusting its freeParameters in search of a global maximum.

Classes in edu.cmu.tetrad.sem that implement TetradSerializable

Modifier and Type	Class	Description
final class	AdequacyReport	Represents a report evaluating the adequacy of a model's performance relative to a baseline.
final class	CVReport	Result of k-fold cross-validation performed by NNEstimator#crossValidate(int).
final class	DagScorer	Estimates a SemIm given a CovarianceMatrix and a SemPm.
final class	EdgeStrengthResult	Result of a single edge-strength computation performed by NNEstimator.computeEdgeStrength(String, String, int).
class	GeneralizedSemIm	Represents a generalized SEM-instantiated model.
final class	GeneralizedSemPm	Parametric model for a Generalized SEM model.
class	Mapping	Maps a parameter to the matrix element where its value is stored in the model.
final class	NNEstimator	Pure-library neural-network estimator for a DAG factorization.
final class	NNEstimatorParams	Tuning parameters for NNEstimator.
final class	NodeAdequacySummary	Represents the adequacy summary of a specific node in a model with information about its characteristics, performance metrics, and improvement over a baseline.
final class	NodeCVSummary	Immutable per-node summary produced by k-fold cross-validation in NNEstimator#crossValidate(int).
class	ParamConstraint	A class for implementing constraints on the values of the freeParameters of of instances of the SemIm class.
final class	Parameter	Stores information about the identity of a SEM parameter--its name, its type (COEF, COVAR), and the node(s) it is associated with.
class	ParameterPair	Implements an ordered pair of objects (a, b) suitable for storing in HashSets.
final class	PartialEdgeStrengthResult	Result of a partial edge strength computation performed by NNEstimator.computePartialEdgeStrength(String, String, int).
final class	PredictionPruneReport	Result of NNEstimator.pruneByPredictiveContribution(int, double): a per-child backward elimination of parents whose held-out predictive contribution is not distinguishable from zero.
static final class	PredictionPruneReport.Deletion	One proposed edge deletion.
final class	SemEstimator	Estimates a SemIm given a CovarianceMatrix and a SemPm.
final class	SemEstimatorGibbsParams	Stores the freeParameters for an instance of a SemEstimatorGibbs.
final class	SemEvidence	Stores information for a SemIm about evidence we have for each variable as well as whether each variable has been manipulated.
final class	SemIm	Stores an instantiated structural equation model (SEM), with error covariance terms, possibly cyclic, suitable for estimation and simulation.
final class	SemManipulation	Stores information for a BayesIm about evidence we have for each variable as well as whether each variable has been manipulated.
class	SemOptimizerEm	Optimizes a DAG SEM with hidden variables using expectation-maximization.
class	SemOptimizerPowell	Optimizes a SEM using Powell's method from the Apache library.
class	SemOptimizerRegression	Optimizes a DAG SEM by regressing each varaible onto its parents using a linear regression.
class	SemOptimizerRicf	Optimizes a SEM using RICF for ADMGs (no selection bias).
class	SemOptimizerScattershot	Optimizes a SEM by randomly selecting points in cubes of decreasing size about a given point.
final class	SemPm	Parametric model for Structural Equation Models.
final class	SemProposition	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.
class	SemUpdater	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.
class	StandardizedSemIm	A special SEM model in which variances of variables are always 1 and means of variables are always 0.
static final class	StandardizedSemIm.ParameterRange	Stores a coefficient range--i.e.
final class	TrainedDagSimulatorGNM	Trained DAG simulator (GNM): learn local mechanisms with non-additive noise and resimulate
static final class	TrainedDagSimulatorGNM.NodeReport	Represents a report for a single node in a trained directed acyclic graph (DAG) structure.
static final class	TrainedDagSimulatorGNM.Params	Represents a configuration class containing various hyperparameters and settings used for the simulation and training of a directed acyclic graph (DAG) model.
static final class	TrainedDagSimulatorGNM.SimResult	Represents the result of a simulation, containing continuous and discrete data for variables, metadata about the simulation, and support for generating reports.

Uses of TetradSerializable in edu.cmu.tetrad.study.gene.tetrad.gene.graph

Classes in edu.cmu.tetrad.study.gene.tetrad.gene.graph that implement TetradSerializable

Modifier and Type	Class	Description
class	ActiveLagGraph	Adds Javabean property change events so that it can be used in a MVC type architecture.
final class	ManualLagGraph	Constructs as a (manual) update graph.
class	ManualLagGraphParams	Stores the parameters needed to generate a new lag graph, whether randomized or manually constructed.
class	StoredLagGraphParams	Stores a file for reading in a lag graph from a file.

Uses of TetradSerializable in edu.cmu.tetrad.study.gene.tetrad.gene.history

Subinterfaces of TetradSerializable in edu.cmu.tetrad.study.gene.tetrad.gene.history

Modifier and Type	Interface	Description
interface	GraphRandomizer	Instantiations of this interface know how to randomize update graphs in particular ways.
interface	Initializer	Initializes a history array.
interface	LagGraph	Lag graph.
interface	RandomDistribution	A distribution from which noise values are drawn.
interface	UpdateFunction	Implements a function from the previous time steps of a history array to the getModel time step.

Classes in edu.cmu.tetrad.study.gene.tetrad.gene.history that implement TetradSerializable

Modifier and Type	Class	Description
class	BasalInitializer	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.
final class	BasicLagGraph	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.
class	BooleanFunction	Stores a boolean function from a set of boolean-valued parents to a single boolean-valued column.
class	BooleanGlassFunction	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.
class	DishModel	Models the manner in which gene models are initialized differentially depending on the dishes that the cells are in.
class	GeneHistory	Implements the basic machinery used by all history objects.
class	IndexedConnectivity	Stores a "shapshot" of the indexedConnectivity of a lag graph, using indices rather than Strings to refer to factors.
class	IndexedLagGraph	Stores a "shapshot" of the indexedLagGraph of a lag graph, using indices rather than Strings to refer to factors.
final class	IndexedParent	Holds an ordered pair (index, lag) to represent a causal parent of a factor, where the factor at the given index is independently known.
class	LaggedEdge	wrapper class for passing factor+edge via a propertyChange event
class	LaggedFactor	Identifies a particular factor (by name) at a particular lag (integer).
class	LinearFunction	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.
final class	Polynomial	Implements a polynomial as a sum of a list of terms whose variables are identified as integers in the set {0, 1, 2, ...}.
class	PolynomialFunction	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.
class	PolynomialTerm	Implements a term in a polymonial whose variables are mapped to indices in in the set {0, 1, 2, ...}.

Uses of TetradSerializable in edu.cmu.tetrad.study.gene.tetrad.gene.simulation

Classes in edu.cmu.tetrad.study.gene.tetrad.gene.simulation that implement TetradSerializable

Modifier and Type	Class	Description
class	MeasurementSimulator	Simulates measurement genetic data using an underlying GeneHistory object to generate individual cell data.

Uses of TetradSerializable in edu.cmu.tetrad.study.gene.tetradapp.model

Classes in edu.cmu.tetrad.study.gene.tetradapp.model that implement TetradSerializable

Modifier and Type	Class	Description
class	GenePm	Implements a parametric gene model.
class	MeasurementSimulatorParams	Wraps MeasurementSimulator so that it may be used as a parameter object.

Uses of TetradSerializable in edu.cmu.tetrad.util

Subinterfaces of TetradSerializable in edu.cmu.tetrad.util

Modifier and Type	Interface	Description
interface	Im	Tagging interface for instantiated models.
interface	TetradLoggerConfig	Represents the configuration for the logger.
static interface	TetradLoggerConfig.Event	Represents an event which is just an id and a description.

Classes in edu.cmu.tetrad.util that implement TetradSerializable

Modifier and Type	Class	Description
class	DefaultTetradLoggerConfig	Logger configuration.
static class	DefaultTetradLoggerConfig.DefaultEvent	A default implementation of the event.
class	Matrix	Wraps the EJML linear algebra library for most uses in Tetrad.
class	MView	Allows a view of a matrix to be created that is a subset of the original matrix, to allow parts of a matrix to be set using indices in the view.
class	Parameters	Stores a list of named parameters with their values.
class	PartialCorrelationPdf	Frequency function of partial correlation r(12|34...k), assuming that the true partial correlation is equal to zero.
class	PointXy	Stores a (x, y) point without having to use awt classes.
static class	TetradLogger.EmptyConfig	Represents an empty configuration for the logger.
class	Vector	Vector wrapping matrix library.
class	Version	Represents the getModel Tetrad version.

Uses of TetradSerializable in edu.cmu.tetrad.util.dist

Subinterfaces of TetradSerializable in edu.cmu.tetrad.util.dist

Modifier and Type	Interface	Description
interface	Distribution	Interface for a statistical distribution from which random values can be drawn.

Classes in edu.cmu.tetrad.util.dist that implement TetradSerializable

Modifier and Type	Class	Description
class	Beta	Implements a Beta distribution for purposes of drawing random numbers.
class	ChiSquare	Wraps a chi square distribution for purposes of drawing random samples.
class	Discrete	Wraps a chi square distribution for purposes of drawing random samples.
class	Exponential	Wraps a chi square distribution for purposes of drawing random samples.
class	Gamma	Wraps a chi square distribution for purposes of drawing random samples.
class	GaussianPower	GaussianPower class.
class	Indicator	Created by IntelliJ IDEA.
class	LogNormal	Represents a lognormal distribution for purposes of sampling.
class	MixtureOfGaussians	Wraps a chi square distribution for purposes of drawing random samples.
class	Normal	A normal distribution that allows its parameters to be set and allows random sampling.
class	Poisson	Wraps a chi square distribution for purposes of drawing random samples.
class	SingleValue	A pretend distribution that always returns the given value when nextRandom() is called.
class	Split	Wraps a chi square distribution for purposes of drawing random samples.
class	TruncatedNormal	A normal distribution that allows its parameters to be set and allows random sampling.
class	Uniform	For given a, b (a < b), returns a point chosen uniformly from [a, b].