Struct tskit::TreeSequence
source · pub struct TreeSequence { /* private fields */ }
Expand description
A tree sequence.
This is a thin wrapper around the C type tsk_treeseq_t
.
When created from a TableCollection
, the input tables are
moved into the TreeSequence
object.
Examples
let mut tables = tskit::TableCollection::new(1000.).unwrap();
tables.add_node(0, 1.0, tskit::PopulationId::NULL, tskit::IndividualId::NULL).unwrap();
tables.add_node(0, 0.0, tskit::PopulationId::NULL, tskit::IndividualId::NULL).unwrap();
tables.add_node(0, 0.0, tskit::PopulationId::NULL, tskit::IndividualId::NULL).unwrap();
tables.add_edge(0., 1000., 0, 1).unwrap();
tables.add_edge(0., 1000., 0, 2).unwrap();
// index
tables.build_index();
// tables gets moved into our treeseq variable:
let treeseq = tables.tree_sequence(tskit::TreeSequenceFlags::default()).unwrap();
assert_eq!(treeseq.nodes().num_rows(), 3);
assert_eq!(treeseq.edges().num_rows(), 2);
This type does not std::ops::DerefMut
to crate::table_views::TableViews
:
assert_eq!(treeseq.nodes_mut().num_rows(), 3);
Implementations
sourceimpl TreeSequence
impl TreeSequence
sourcepub fn new<F: Into<TreeSequenceFlags>>(
tables: TableCollection,
flags: F
) -> Result<Self, TskitError>
pub fn new<F: Into<TreeSequenceFlags>>(
tables: TableCollection,
flags: F
) -> Result<Self, TskitError>
Create a tree sequence from a TableCollection
.
In general, TableCollection::tree_sequence
may be preferred.
The table collection is moved/consumed.
Parameters
tables
, aTableCollection
Errors
TskitError
if the tables are not indexed.TskitError
if the tables are not properly sorted. SeeTableCollection::full_sort
.
Examples
let mut tables = tskit::TableCollection::new(1000.).unwrap();
tables.build_index();
let tree_sequence = tskit::TreeSequence::try_from(tables).unwrap();
The following may be preferred to the previous example, and more closely
mimics the Python tskit
interface:
let mut tables = tskit::TableCollection::new(1000.).unwrap();
tables.build_index();
let tree_sequence = tables.tree_sequence(tskit::TreeSequenceFlags::default()).unwrap();
The following raises an error because the tables are not indexed:
let mut tables = tskit::TableCollection::new(1000.).unwrap();
let tree_sequence = tskit::TreeSequence::try_from(tables).unwrap();
Note
This function makes no extra copies of the tables. There is, however, a temporary allocation of an empty table collection in order to convince rust that we are safely handling all memory.
sourcepub fn dump<O: Into<TableOutputOptions>>(
&self,
filename: &str,
options: O
) -> TskReturnValue
pub fn dump<O: Into<TableOutputOptions>>(
&self,
filename: &str,
options: O
) -> TskReturnValue
sourcepub fn load(filename: impl AsRef<str>) -> Result<Self, TskitError>
pub fn load(filename: impl AsRef<str>) -> Result<Self, TskitError>
Load from a file.
This function calls TableCollection::new_from_file
with
TreeSequenceFlags::default
.
sourcepub fn dump_tables(&self) -> Result<TableCollection, TskitError>
pub fn dump_tables(&self) -> Result<TableCollection, TskitError>
Obtain a copy of the TableCollection
.
The result is a “deep” copy of the tables.
Errors
TskitError
will be raised if the underlying C library returns an error code.
sourcepub fn tree_iterator<F: Into<TreeFlags>>(
&self,
flags: F
) -> Result<Tree, TskitError>
pub fn tree_iterator<F: Into<TreeFlags>>(
&self,
flags: F
) -> Result<Tree, TskitError>
Create an iterator over trees.
Parameters
flags
ATreeFlags
bit field.
Errors
Examples
// You must include streaming_iterator as a dependency
// and import this type.
use streaming_iterator::StreamingIterator;
// Import this to allow .next_back() for reverse
// iteration over trees.
use streaming_iterator::DoubleEndedStreamingIterator;
let mut tables = tskit::TableCollection::new(1000.).unwrap();
tables.build_index();
let tree_sequence = tables.tree_sequence(tskit::TreeSequenceFlags::default()).unwrap();
let mut tree_iterator = tree_sequence.tree_iterator(tskit::TreeFlags::default()).unwrap();
while let Some(tree) = tree_iterator.next() {
}
Warning
The following code results in an infinite loop. Be sure to note the difference from the previous example.
use streaming_iterator::StreamingIterator;
let mut tables = tskit::TableCollection::new(1000.).unwrap();
tables.build_index();
let tree_sequence = tables.tree_sequence(tskit::TreeSequenceFlags::default()).unwrap();
while let Some(tree) = tree_sequence.tree_iterator(tskit::TreeFlags::default()).unwrap().next() {
}
sourcepub fn samples_to_vec(&self) -> Vec<NodeId>
👎Deprecated since 0.2.3: Please use TreeSequence::sample_nodes instead
pub fn samples_to_vec(&self) -> Vec<NodeId>
Get the list of samples as a vector.
Panics
Will panic if the number of samples is too large to cast to a valid id.
sourcepub fn sample_nodes(&self) -> &[NodeId]
pub fn sample_nodes(&self) -> &[NodeId]
Get the list of sample nodes as a slice.
sourcepub fn kc_distance(
&self,
other: &TreeSequence,
lambda: f64
) -> Result<f64, TskitError>
pub fn kc_distance(
&self,
other: &TreeSequence,
lambda: f64
) -> Result<f64, TskitError>
Calculate the average Kendall-Colijn (K-C
) distance between
pairs of trees whose intervals overlap.
Note
Parameters
lambda
specifies the relative weight of topology and branch length. SeeTreeInterface::kc_distance
for more details.
pub fn num_samples(&self) -> SizeType
sourcepub fn simplify<O: Into<SimplificationOptions>>(
&self,
samples: &[NodeId],
options: O,
idmap: bool
) -> Result<(Self, Option<Vec<NodeId>>), TskitError>
pub fn simplify<O: Into<SimplificationOptions>>(
&self,
samples: &[NodeId],
options: O,
idmap: bool
) -> Result<(Self, Option<Vec<NodeId>>), TskitError>
Simplify tables and return a new tree sequence.
Parameters
samples
: a slice containing non-null node ids. The tables are simplified with respect to the ancestry of these nodes.options
: ASimplificationOptions
bit field controlling the behavior of simplification.idmap
: iftrue
, the return value contains a vector equal in length to the input node table. For each input node, this vector either contains the node’s new index orNodeId::NULL
if the input node is not part of the simplified history.
sourcepub fn add_provenance(
&mut self,
record: &str
) -> Result<ProvenanceId, TskitError>
Available on crate feature provenance
only.
pub fn add_provenance(
&mut self,
record: &str
) -> Result<ProvenanceId, TskitError>
provenance
only.Add provenance record with a time stamp.
All implementation of this trait provided by tskit
use
an ISO 8601
format time stamp
written using the RFC 3339
specification.
This formatting approach has been the most straightforward method
for supporting round trips to/from a crate::provenance::ProvenanceTable
.
The implementations used here use the humantime
crate.
Parameters
record
: the provenance record
Examples
let mut tables = tskit::TableCollection::new(1000.).unwrap();
let mut treeseq = tables.tree_sequence(tskit::TreeSequenceFlags::BUILD_INDEXES).unwrap();
treeseq.add_provenance(&String::from("All your provenance r belong 2 us.")).unwrap();
let prov_ref = treeseq.provenances();
let row_0 = prov_ref.row(0).unwrap();
assert_eq!(row_0.record, "All your provenance r belong 2 us.");
let record_0 = prov_ref.record(0).unwrap();
assert_eq!(record_0, row_0.record);
let timestamp = prov_ref.timestamp(0).unwrap();
assert_eq!(timestamp, row_0.timestamp);
use core::str::FromStr;
let dt_utc = humantime::Timestamp::from_str(×tamp).unwrap();
println!("utc = {}", dt_utc);
Methods from Deref<Target = TableViews>
sourcepub fn mutations(&self) -> &MutationTable
pub fn mutations(&self) -> &MutationTable
Get reference to the MutationTable
.
sourcepub fn individuals(&self) -> &IndividualTable
pub fn individuals(&self) -> &IndividualTable
Get reference to the IndividualTable
.
sourcepub fn populations(&self) -> &PopulationTable
pub fn populations(&self) -> &PopulationTable
Get reference to the PopulationTable
.
sourcepub fn migrations(&self) -> &MigrationTable
pub fn migrations(&self) -> &MigrationTable
Get reference to the MigrationTable
.
sourcepub fn provenances(&self) -> &ProvenanceTable
Available on crate feature provenance
only.
pub fn provenances(&self) -> &ProvenanceTable
provenance
only.Get reference to the ProvenanceTable
sourcepub fn edges_iter(&self) -> impl Iterator<Item = EdgeTableRow> + '_
pub fn edges_iter(&self) -> impl Iterator<Item = EdgeTableRow> + '_
Return an iterator over the edges.
sourcepub fn nodes_iter(&self) -> impl Iterator<Item = NodeTableRow> + '_
pub fn nodes_iter(&self) -> impl Iterator<Item = NodeTableRow> + '_
Return an iterator over the nodes.
sourcepub fn sites_iter(&self) -> impl Iterator<Item = SiteTableRow> + '_
pub fn sites_iter(&self) -> impl Iterator<Item = SiteTableRow> + '_
Return an iterator over the sites.
sourcepub fn mutations_iter(&self) -> impl Iterator<Item = MutationTableRow> + '_
pub fn mutations_iter(&self) -> impl Iterator<Item = MutationTableRow> + '_
Return an iterator over the mutations.
sourcepub fn individuals_iter(&self) -> impl Iterator<Item = IndividualTableRow> + '_
pub fn individuals_iter(&self) -> impl Iterator<Item = IndividualTableRow> + '_
Return an iterator over the individuals.
sourcepub fn populations_iter(&self) -> impl Iterator<Item = PopulationTableRow> + '_
pub fn populations_iter(&self) -> impl Iterator<Item = PopulationTableRow> + '_
Return an iterator over the populations.
sourcepub fn migrations_iter(&self) -> impl Iterator<Item = MigrationTableRow> + '_
pub fn migrations_iter(&self) -> impl Iterator<Item = MigrationTableRow> + '_
Return an iterator over the migrations.
sourcepub fn provenances_iter(&self) -> impl Iterator<Item = ProvenanceTableRow> + '_
Available on crate feature provenance
only.
pub fn provenances_iter(&self) -> impl Iterator<Item = ProvenanceTableRow> + '_
provenance
only.Return an iterator over provenances
sourcepub fn samples_as_vector(&self) -> Vec<NodeId>
pub fn samples_as_vector(&self) -> Vec<NodeId>
Obtain a vector containing the indexes (“ids”)
of all nodes for which crate::TSK_NODE_IS_SAMPLE
is true
.
The provided implementation dispatches to
crate::NodeTable::samples_as_vector
.
sourcepub fn create_node_id_vector(
&self,
f: impl FnMut(&NodeTableRow) -> bool
) -> Vec<NodeId>
pub fn create_node_id_vector(
&self,
f: impl FnMut(&NodeTableRow) -> bool
) -> Vec<NodeId>
Obtain a vector containing the indexes (“ids”) of all nodes satisfying a certain criterion.
The provided implementation dispatches to
crate::NodeTable::create_node_id_vector
.
Parameters
f
: a function. The function is passed the current table collection and eachcrate::node_table::NodeTableRow
. Iff
returnstrue
, the index of that row is included in the return value.
Examples
Get all nodes with time > 0.0:
use tskit::bindings::tsk_id_t;
let mut tables = tskit::TableCollection::new(100.).unwrap();
tables
.add_node(tskit::TSK_NODE_IS_SAMPLE, 0.0, tskit::PopulationId::NULL,
tskit::IndividualId::NULL)
.unwrap();
tables
.add_node(tskit::TSK_NODE_IS_SAMPLE, 1.0, tskit::PopulationId::NULL,
tskit::IndividualId::NULL)
.unwrap();
let samples = tables.create_node_id_vector(
|row: &tskit::NodeTableRow| row.time > 0.,
);
assert_eq!(samples[0], 1);
// Get all nodes that have a mutation:
fn node_has_mutation(
// dyn trait here means this
// will work with TreeSequence, too.
tables_type: &dyn std::ops::Deref<Target=tskit::table_views::TableViews>,
row: &tskit::NodeTableRow,
) -> bool {
for mrow in tables_type.mutations_iter() {
if mrow.node == row.id {
return true;
}
}
false
}
// Get all nodes that have a mutation:
tables.add_mutation(0, 0, tskit::MutationId::NULL, 0.0, None).unwrap();
let samples_with_mut = tables.create_node_id_vector(
|row: &tskit::NodeTableRow| node_has_mutation(&tables, row));
assert_eq!(samples_with_mut[0], 0);