Struct tskit::TreeSequence

pub struct TreeSequence { /* fields omitted */ }

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::TSK_NULL, tskit::TSK_NULL).unwrap();
tables.add_node(0, 0.0, tskit::TSK_NULL, tskit::TSK_NULL).unwrap();
tables.add_node(0, 0.0, tskit::TSK_NULL, tskit::TSK_NULL).unwrap();
tables.add_edge(0., 1000., 0, 1).unwrap();
tables.add_edge(0., 1000., 0, 2).unwrap();

// index
tables.build_index(0);

// tables gets moved into our treeseq variable:
let treeseq = tables.tree_sequence().unwrap();

Implementations

impl TreeSequence

pub fn new(tables: TableCollection) -> 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, a TableCollection

Errors

• TskitError if the tables are not indexed.

Examples

let mut tables = tskit::TableCollection::new(1000.).unwrap();
tables.build_index(0);
let tree_sequence = tskit::TreeSequence::new(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(0);
let tree_sequence = tables.tree_sequence().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::new(tables).unwrap();

pub fn load(filename: &str) -> Result<Self, TskitError>

Load from a file.

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.

pub fn tree_iterator(&self, flags: TreeFlags) -> Result<Tree, TskitError>

Create an iterator over trees.

Parameters

• flags A TreeFlags bit field.

Errors

Examples

// You must include streaming_iterator as a dependency
// and import this type.
use streaming_iterator::StreamingIterator;

let mut tables = tskit::TableCollection::new(1000.).unwrap();
tables.build_index(0);
let tree_sequence = tables.tree_sequence().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(0);
let tree_sequence = tables.tree_sequence().unwrap();
while let Some(tree) = tree_sequence.tree_iterator(tskit::TreeFlags::default()).unwrap().next() {
}

pub fn samples_to_vec(&self) -> Vec<tsk_id_t>

Get the list of samples as a vector.

pub fn num_trees(&self) -> tsk_size_t

Get the number of trees.

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

• Citation

Parameters

• lambda specifies the relative weight of topology and branch length. See Tree::kc_distance for more details.

pub fn num_samples(&self) -> tsk_size_t

Trait Implementations

impl Drop for TreeSequence

fn drop(&mut self)

Executes the destructor for this type.

impl TskitTypeAccess<tsk_treeseq_t> for TreeSequence

fn as_ptr(&self) -> *const tsk_treeseq_t

Return const pointer

fn as_mut_ptr(&mut self) -> *mut tsk_treeseq_t

Return mutable pointer