Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, //
// 2007, 2008, 2009, 2010, 2014, 2015, 2022 by Peter Spirtes, Richard //
// Scheines, Joseph Ramsey, and Clark Glymour. //
// //
// This program is free software; you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation; either version 2 of the License, or //
// (at your option) any later version. //
// //
// This program is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with this program; if not, write to the Free Software //
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA //
///////////////////////////////////////////////////////////////////////////////
package edu.cmu.tetrad.graph;
import java.beans.PropertyChangeListener;
import java.util.*;
/**
* Implements a graph allowing nodes in the getModel time lag to have parents taken from previous time lags. This is
* intended to be interpreted as a repeating time series graph for purposes of simulation.
*
* @author josephramsey
*/
public class LagGraph implements Graph {
private static final long serialVersionUID = 23L;
private final List variables = new ArrayList<>();
private final Map> laggedVariables = new HashMap<>();
private final Map attributes = new HashMap<>();
private Dag graph = new Dag();
private Set underLineTriples = new HashSet<>();
private Set dottedUnderLineTriples = new HashSet<>();
private Set ambiguousTriples = new HashSet<>();
private Paths paths;
/**
* Generates a simple exemplar of this class to test serialization.
*/
public static LagGraph serializableInstance() {
return new LagGraph();
}
// New methods.
public boolean addVariable(String variable) {
if (this.variables.contains(variable)) {
return false;
}
for (String _variable : this.variables) {
if (variable.equals(_variable)) {
return false;
}
}
this.variables.add(variable);
this.laggedVariables.put(variable, new ArrayList<>());
for (String node : this.variables) {
List _lags = this.laggedVariables.get(node);
GraphNode _newNode = new GraphNode(node + "." + _lags.size());
_lags.add(_newNode);
_newNode.setCenter(5, 5);
addNode(_newNode);
}
return true;
}
// Modified methods from graph.
public boolean addDirectedEdge(Node node1, Node node2) {
return getGraph().addDirectedEdge(node1, node2);
}
public boolean addNode(Node node) {
throw new UnsupportedOperationException();
}
// Wrapped methods from graph.
public boolean addBidirectedEdge(Node node1, Node node2) {
throw new UnsupportedOperationException();
}
public boolean addUndirectedEdge(Node node1, Node node2) {
throw new UnsupportedOperationException();
}
public boolean addNondirectedEdge(Node node1, Node node2) {
throw new UnsupportedOperationException();
}
public boolean addPartiallyOrientedEdge(Node node1, Node node2) {
throw new UnsupportedOperationException();
}
public boolean addEdge(Edge edge) {
throw new UnsupportedOperationException();
}
public void addPropertyChangeListener(PropertyChangeListener e) {
getGraph().addPropertyChangeListener(e);
}
public void clear() {
getGraph().clear();
}
public boolean containsEdge(Edge edge) {
return getGraph().containsEdge(edge);
}
public boolean containsNode(Node node) {
return getGraph().containsNode(node);
}
public void fullyConnect(Endpoint endpoint) {
throw new UnsupportedOperationException();
}
public void reorientAllWith(Endpoint endpoint) {
getGraph().reorientAllWith(endpoint);
}
public List getAdjacentNodes(Node node) {
return getGraph().getAdjacentNodes(node);
}
public List getChildren(Node node) {
return getGraph().getChildren(node);
}
public int getDegree() {
return getGraph().getDegree();
}
public Edge getEdge(Node node1, Node node2) {
return getGraph().getEdge(node1, node2);
}
public Edge getDirectedEdge(Node node1, Node node2) {
return getGraph().getDirectedEdge(node1, node2);
}
public List getEdges(Node node) {
return getGraph().getEdges(node);
}
public List getEdges(Node node1, Node node2) {
return getGraph().getEdges(node1, node2);
}
public Set getEdges() {
return getGraph().getEdges();
}
public Endpoint getEndpoint(Node node1, Node node2) {
return getGraph().getEndpoint(node1, node2);
}
public int getIndegree(Node node) {
return getGraph().getIndegree(node);
}
@Override
public int getDegree(Node node) {
return getGraph().getDegree(node);
}
public Node getNode(String name) {
return getGraph().getNode(name);
}
public List getNodes() {
return getGraph().getNodes();
}
@Override
public void setNodes(List nodes) {
this.graph.setNodes(nodes);
}
public List getNodeNames() {
return getGraph().getNodeNames();
}
public int getNumEdges() {
return getGraph().getNumEdges();
}
public int getNumEdges(Node node) {
return getGraph().getNumEdges(node);
}
public int getNumNodes() {
return getGraph().getNumNodes();
}
public int getOutdegree(Node node) {
return getGraph().getOutdegree(node);
}
public List getParents(Node node) {
return getGraph().getParents(node);
}
public boolean isAdjacentTo(Node node1, Node node2) {
return getGraph().isAdjacentTo(node1, node2);
}
public boolean isAncestorOf(Node node1, Node node2) {
return getGraph().paths().isAncestorOf(node1, node2);
}
public boolean isChildOf(Node node1, Node node2) {
return getGraph().isChildOf(node2, node2);
}
public boolean isParentOf(Node node1, Node node2) {
return getGraph().isParentOf(node1, node2);
}
public boolean isDefNoncollider(Node node1, Node node2, Node node3) {
return getGraph().isDefNoncollider(node1, node2, node3);
}
public boolean isDefCollider(Node node1, Node node2, Node node3) {
return getGraph().isDefCollider(node1, node2, node3);
}
public boolean isExogenous(Node node) {
return getGraph().isExogenous(node);
}
public List getNodesInTo(Node node, Endpoint n) {
return getGraph().getNodesInTo(node, n);
}
public List getNodesOutTo(Node node, Endpoint n) {
return getGraph().getNodesOutTo(node, n);
}
public boolean removeEdge(Edge edge) {
return getGraph().removeEdge(edge);
}
public boolean removeEdge(Node node1, Node node2) {
return getGraph().removeEdge(node1, node2);
}
public boolean removeEdges(Node node1, Node node2) {
return getGraph().removeEdges(node1, node2);
}
public boolean removeEdges(Collection edges) {
return getGraph().removeEdges(edges);
}
public boolean removeNode(Node node) {
return getGraph().removeNode(node);
}
public boolean removeNodes(List nodes) {
return getGraph().removeNodes(nodes);
}
public boolean setEndpoint(Node from, Node to, Endpoint endPoint) {
return getGraph().setEndpoint(from, to, endPoint);
}
public Graph subgraph(List nodes) {
return getGraph().subgraph(nodes);
}
public void transferNodesAndEdges(Graph graph) throws IllegalArgumentException {
this.getGraph().transferNodesAndEdges(graph);
}
public void transferAttributes(Graph graph) throws IllegalArgumentException {
this.getGraph().transferAttributes(graph);
}
@Override
public Paths paths() {
return this.paths;
}
public boolean isParameterizable(Node node) {
return getGraph().isParameterizable(node);
}
public boolean isTimeLagModel() {
return false;
}
public TimeLagGraph getTimeLagGraph() {
return null;
}
@Override
public Set getSepset(Node n1, Node n2) {
throw new UnsupportedOperationException();
}
private Dag getGraph() {
return this.graph;
}
public void setGraph(Dag graph) {
this.graph = graph;
}
@Override
public Map getAllAttributes() {
return this.attributes;
}
@Override
public Object getAttribute(String key) {
return this.attributes.get(key);
}
@Override
public void removeAttribute(String key) {
this.attributes.remove(key);
}
@Override
public void addAttribute(String key, Object value) {
this.attributes.put(key, value);
}
public Set getAmbiguousTriples() {
return new HashSet<>(this.ambiguousTriples);
}
public void setAmbiguousTriples(Set triples) {
this.ambiguousTriples.clear();
for (Triple triple : triples) {
addAmbiguousTriple(triple.getX(), triple.getY(), triple.getZ());
}
}
public Set getUnderLines() {
return new HashSet<>(this.underLineTriples);
}
public Set getDottedUnderlines() {
return new HashSet<>(this.dottedUnderLineTriples);
}
/**
* States whether r-s-r is an underline triple or not.
*/
public boolean isAmbiguousTriple(Node x, Node y, Node z) {
return this.ambiguousTriples.contains(new Triple(x, y, z));
}
/**
* States whether r-s-r is an underline triple or not.
*/
public boolean isUnderlineTriple(Node x, Node y, Node z) {
return this.underLineTriples.contains(new Triple(x, y, z));
}
public void addAmbiguousTriple(Node x, Node y, Node z) {
this.ambiguousTriples.add(new Triple(x, y, z));
}
public void addUnderlineTriple(Node x, Node y, Node z) {
Triple triple = new Triple(x, y, z);
if (!triple.alongPathIn(this)) {
return;
}
this.underLineTriples.add(new Triple(x, y, z));
}
public void addDottedUnderlineTriple(Node x, Node y, Node z) {
Triple triple = new Triple(x, y, z);
if (!triple.alongPathIn(this)) {
return;
}
this.dottedUnderLineTriples.add(triple);
}
public void removeAmbiguousTriple(Node x, Node y, Node z) {
this.ambiguousTriples.remove(new Triple(x, y, z));
}
public void removeUnderlineTriple(Node x, Node y, Node z) {
this.underLineTriples.remove(new Triple(x, y, z));
}
public void removeDottedUnderlineTriple(Node x, Node y, Node z) {
this.dottedUnderLineTriples.remove(new Triple(x, y, z));
}
public void setUnderLineTriples(Set triples) {
this.underLineTriples.clear();
for (Triple triple : triples) {
addUnderlineTriple(triple.getX(), triple.getY(), triple.getZ());
}
}
public void setDottedUnderLineTriples(Set triples) {
this.dottedUnderLineTriples.clear();
for (Triple triple : triples) {
addDottedUnderlineTriple(triple.getX(), triple.getY(), triple.getZ());
}
}
public void removeTriplesNotInGraph() {
for (Triple triple : new HashSet<>(this.ambiguousTriples)) {
if (!containsNode(triple.getX()) || !containsNode(triple.getY())
|| !containsNode(triple.getZ())) {
this.ambiguousTriples.remove(triple);
continue;
}
if (!isAdjacentTo(triple.getX(), triple.getY())
|| !isAdjacentTo(triple.getY(), triple.getZ())) {
this.ambiguousTriples.remove(triple);
}
}
for (Triple triple : new HashSet<>(this.underLineTriples)) {
if (!containsNode(triple.getX()) || !containsNode(triple.getY())
|| !containsNode(triple.getZ())) {
this.underLineTriples.remove(triple);
continue;
}
if (!isAdjacentTo(triple.getX(), triple.getY()) || !isAdjacentTo(triple.getY(), triple.getZ())) {
this.underLineTriples.remove(triple);
}
}
for (Triple triple : new HashSet<>(this.dottedUnderLineTriples)) {
if (!containsNode(triple.getX()) || !containsNode(triple.getY()) || !containsNode(triple.getZ())) {
this.dottedUnderLineTriples.remove(triple);
continue;
}
if (!isAdjacentTo(triple.getX(), triple.getY()) || isAdjacentTo(triple.getY(), triple.getZ())) {
this.dottedUnderLineTriples.remove(triple);
}
}
}
}
