Remove git submodule

Author: Ben Jeffery

.gitmodules

@@ -1,7 +1,7 @@
 include lib/*.h
-include git-submodules/tskit/c/*.h
-include git-submodules/tskit/c/tskit/*.h
-include git-submodules/tskit/c/subprojects/kastore/*.h
+include lib/subprojects/tskit/c/*.h
+include lib/subprojects/tskit/c/tskit/*.h
+include lib/subprojects/tskit/c/subprojects/kastore/*.h
 include README.txt
 include LICENSE
 recursive-include tests *.py

MANIFEST.in

@@ -0,0 +1 @@
+build

git-submodules/tskit

@@ -0,0 +1 @@
+1.1.1

lib/subprojects/tskit/.gitignore

@@ -0,0 +1,35 @@
+# Simple Makefile for building examples.
+# This will build the examples in the current directory by compiling in the
+# full tskit source into each of the examples. This is *not* recommended for
+# real projects!
+#
+# To use, type "make" in the this directory. If you have GSL installed you
+# should then get two example programs built.
+#
+# **Note**: This repo uses git submodules, and these must be checked out
+# correctly for this makefile to work, e.g.:
+#
+# $ git clone [email protected]:tskit-dev/tskit.git --recurse-submodules
+#
+# See the documentation (https://tskit.dev/tskit/docs/stable/c-api.html)
+# for more details on how to use the C API, and the tskit build examples
+# repo (https://github.com/tskit-dev/tskit-build-examples) for examples
+# of how to set up a production-ready build with tskit.
+#
+
+CFLAGS=-I../ -I../subprojects/kastore
+TSKIT_SOURCE=../tskit/*.c ../subprojects/kastore/kastore.c
+
+targets = api_structure error_handling \
+	haploid_wright_fisher streaming \
+	tree_iteration tree_traversal \
+	take_ownership
+
+all: $(targets)
+
+$(targets): %: %.c
+	${CC} ${CFLAGS} -o $@ $< ${TSKIT_SOURCE} -lm
+
+clean:
+	rm -f $(targets)
+

lib/subprojects/tskit/CHANGELOG.rst

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <tskit/tables.h>
+
+#define check_tsk_error(val)                                                            \
+    if (val < 0) {                                                                      \
+        fprintf(stderr, "line %d: %s", __LINE__, tsk_strerror(val));                    \
+        exit(EXIT_FAILURE);                                                             \
+    }
+
+int
+main(int argc, char **argv)
+{
+    int j, ret;
+    tsk_edge_table_t edges;
+
+    ret = tsk_edge_table_init(&edges, 0);
+    check_tsk_error(ret);
+    for (j = 0; j < 5; j++) {
+        ret = tsk_edge_table_add_row(&edges, 0, 1, j + 1, j, NULL, 0);
+        check_tsk_error(ret);
+    }
+    tsk_edge_table_print_state(&edges, stdout);
+    tsk_edge_table_free(&edges);
+
+    return EXIT_SUCCESS;
+}

lib/subprojects/tskit/VERSION.txt

@@ -0,0 +1,101 @@
+#include <cstddef>
+#include <vector>
+#include <algorithm>
+#include <stdexcept>
+#include <sstream>
+#include <iostream>
+#include <type_traits>
+#include <tskit.h>
+
+static void
+handle_tskit_return_code(int code)
+{
+    if (code != 0) {
+        std::ostringstream o;
+        o << tsk_strerror(code);
+        throw std::runtime_error(o.str());
+    }
+}
+
+struct edge_plus_time {
+    double time;
+    tsk_id_t parent, child;
+    double left, right;
+};
+
+int
+sort_edges(tsk_table_sorter_t *sorter, tsk_size_t start)
+{
+    if (sorter->tables->edges.metadata_length != 0) {
+        throw std::invalid_argument(
+            "the sorter does not currently handle edge metadata");
+    }
+    if (start != 0) {
+        throw std::invalid_argument("the sorter requires start==0");
+    }
+
+    std::vector<edge_plus_time> temp;
+    temp.reserve(static_cast<std::size_t>(sorter->tables->edges.num_rows));
+
+    auto edges = &sorter->tables->edges;
+    auto nodes = &sorter->tables->nodes;
+
+    for (tsk_size_t i = 0; i < sorter->tables->edges.num_rows; ++i) {
+        temp.push_back(edge_plus_time{ nodes->time[edges->parent[i]], edges->parent[i],
+            edges->child[i], edges->left[i], edges->right[i] });
+    }
+
+    std::sort(begin(temp), end(temp),
+        [](const edge_plus_time &lhs, const edge_plus_time &rhs) {
+            if (lhs.time == rhs.time) {
+                if (lhs.parent == rhs.parent) {
+                    if (lhs.child == rhs.child) {
+                        return lhs.left < rhs.left;
+                    }
+                    return lhs.child < rhs.child;
+                }
+                return lhs.parent < rhs.parent;
+            }
+            return lhs.time < rhs.time;
+        });
+
+    for (std::size_t i = 0; i < temp.size(); ++i) {
+        edges->left[i] = temp[i].left;
+        edges->right[i] = temp[i].right;
+        edges->parent[i] = temp[i].parent;
+        edges->child[i] = temp[i].child;
+    }
+
+    return 0;
+}
+
+int
+main(int argc, char **argv)
+{
+    if (argc != 3) {
+        std::cerr << "Usage: " << argv[0] << " input.trees output.trees\n";
+        std::exit(0);
+    }
+    const char *infile = argv[1];
+    const char *outfile = argv[2];
+
+    tsk_table_collection_t tables;
+    auto ret = tsk_table_collection_load(&tables, infile, 0);
+    handle_tskit_return_code(ret);
+
+    tsk_table_sorter_t sorter;
+    ret = tsk_table_sorter_init(&sorter, &tables, 0);
+    handle_tskit_return_code(ret);
+    sorter.sort_edges = sort_edges;
+    try {
+        ret = tsk_table_sorter_run(&sorter, NULL);
+    } catch (std::exception &e) {
+        std::cerr << e.what() << '\n';
+        std::exit(1);
+    }
+    handle_tskit_return_code(ret);
+    ret = tsk_table_collection_dump(&tables, outfile, 0);
+    handle_tskit_return_code(ret);
+    ret = tsk_table_collection_free(&tables);
+    handle_tskit_return_code(ret);
+}

lib/subprojects/tskit/examples/Makefile

@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <tskit.h>
+
+int
+main(int argc, char **argv)
+{
+    int ret;
+    tsk_treeseq_t ts;
+
+    if (argc != 2) {
+        fprintf(stderr, "usage: <tree sequence file>");
+        exit(EXIT_FAILURE);
+    }
+    ret = tsk_treeseq_load(&ts, argv[1], 0);
+    if (ret < 0) {
+        /* Error condition. Free and exit */
+        tsk_treeseq_free(&ts);
+        fprintf(stderr, "%s", tsk_strerror(ret));
+        exit(EXIT_FAILURE);
+    }
+    printf("Loaded tree sequence with %lld nodes and %lld edges from %s\n",
+        (long long) tsk_treeseq_get_num_nodes(&ts),
+        (long long) tsk_treeseq_get_num_edges(&ts), argv[1]);
+    tsk_treeseq_free(&ts);
+
+    return EXIT_SUCCESS;
+}

lib/subprojects/tskit/examples/api_structure.c

@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <err.h>
+
+#include <tskit/tables.h>
+
+#define check_tsk_error(val)                                                            \
+    if (val < 0) {                                                                      \
+        errx(EXIT_FAILURE, "line %d: %s", __LINE__, tsk_strerror(val));                 \
+    }
+
+void
+simulate(tsk_table_collection_t *tables, int N, int T, int simplify_interval)
+{
+    tsk_id_t *buffer, *parents, *children, child, left_parent, right_parent;
+    double breakpoint;
+    int ret, j, t, b;
+
+    assert(simplify_interval != 0); // leads to division by zero
+    buffer = malloc(2 * N * sizeof(tsk_id_t));
+    if (buffer == NULL) {
+        errx(EXIT_FAILURE, "Out of memory");
+    }
+    tables->sequence_length = 1.0;
+    parents = buffer;
+    for (j = 0; j < N; j++) {
+        parents[j]
+            = tsk_node_table_add_row(&tables->nodes, 0, T, TSK_NULL, TSK_NULL, NULL, 0);
+        check_tsk_error(parents[j]);
+    }
+    b = 0;
+    for (t = T - 1; t >= 0; t--) {
+        /* Alternate between using the first and last N values in the buffer */
+        parents = buffer + (b * N);
+        b = (b + 1) % 2;
+        children = buffer + (b * N);
+        for (j = 0; j < N; j++) {
+            child = tsk_node_table_add_row(
+                &tables->nodes, 0, t, TSK_NULL, TSK_NULL, NULL, 0);
+            check_tsk_error(child);
+            /* NOTE: the use of rand() is discouraged for
+             * research code and proper random number generator
+             * libraries should be preferred.
+             */
+            left_parent = parents[(size_t)((rand() / (1. + RAND_MAX)) * N)];
+            right_parent = parents[(size_t)((rand() / (1. + RAND_MAX)) * N)];
+            do {
+                breakpoint = rand() / (1. + RAND_MAX);
+            } while (breakpoint == 0); /* tiny proba of breakpoint being 0 */
+            ret = tsk_edge_table_add_row(
+                &tables->edges, 0, breakpoint, left_parent, child, NULL, 0);
+            check_tsk_error(ret);
+            ret = tsk_edge_table_add_row(
+                &tables->edges, breakpoint, 1, right_parent, child, NULL, 0);
+            check_tsk_error(ret);
+            children[j] = child;
+        }
+        if (t % simplify_interval == 0) {
+            printf("Simplify at generation %lld: (%lld nodes %lld edges)", (long long) t,
+                (long long) tables->nodes.num_rows, (long long) tables->edges.num_rows);
+            /* Note: Edges must be sorted for simplify to work, and we use a brute force
+             * approach of sorting each time here for simplicity. This is inefficient. */
+            ret = tsk_table_collection_sort(tables, NULL, 0);
+            check_tsk_error(ret);
+            ret = tsk_table_collection_simplify(tables, children, N, 0, NULL);
+            check_tsk_error(ret);
+            printf(" -> (%lld nodes %lld edges)\n", (long long) tables->nodes.num_rows,
+                (long long) tables->edges.num_rows);
+            for (j = 0; j < N; j++) {
+                children[j] = j;
+            }
+        }
+    }
+    free(buffer);
+}
+
+int
+main(int argc, char **argv)
+{
+    int ret;
+    tsk_table_collection_t tables;
+
+    if (argc != 6) {
+        errx(EXIT_FAILURE, "usage: N T simplify-interval output-file seed");
+    }
+    ret = tsk_table_collection_init(&tables, 0);
+    check_tsk_error(ret);
+    srand((unsigned) atoi(argv[5]));
+    simulate(&tables, atoi(argv[1]), atoi(argv[2]), atoi(argv[3]));
+    ret = tsk_table_collection_dump(&tables, argv[4], 0);
+    check_tsk_error(ret);
+
+    tsk_table_collection_free(&tables);
+    return 0;
+}

lib/subprojects/tskit/examples/cpp_sorting_example.cpp

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <tskit/tables.h>
+
+#define check_tsk_error(val)                                                            \
+    if (val < 0) {                                                                      \
+        fprintf(stderr, "Error: line %d: %s\n", __LINE__, tsk_strerror(val));           \
+        exit(EXIT_FAILURE);                                                             \
+    }
+
+int
+main(int argc, char **argv)
+{
+    int ret;
+    int j = 0;
+    tsk_table_collection_t tables;
+
+    ret = tsk_table_collection_init(&tables, 0);
+    check_tsk_error(ret);
+
+    while (true) {
+        ret = tsk_table_collection_loadf(&tables, stdin, TSK_NO_INIT);
+        if (ret == TSK_ERR_EOF) {
+            break;
+        }
+        check_tsk_error(ret);
+        fprintf(stderr, "Tree sequence %d had %lld mutations\n", j,
+            (long long) tables.mutations.num_rows);
+        ret = tsk_mutation_table_truncate(&tables.mutations, 0);
+        check_tsk_error(ret);
+        ret = tsk_table_collection_dumpf(&tables, stdout, 0);
+        check_tsk_error(ret);
+        j++;
+    }
+    tsk_table_collection_free(&tables);
+    return EXIT_SUCCESS;
+}

lib/subprojects/tskit/examples/error_handling.c

@@ -0,0 +1,38 @@
+#include <err.h>
+#include <stdlib.h>
+#include <tskit/tables.h>
+#include <tskit/trees.h>
+
+#define check_tsk_error(val)                                                            \
+    if (val < 0) {                                                                      \
+        errx(EXIT_FAILURE, "line %d: %s", __LINE__, tsk_strerror(val));                 \
+    }
+
+int
+main(int argc, char **argv)
+{
+    tsk_table_collection_t *tables;
+    tsk_treeseq_t treeseq;
+    int rv;
+
+    tables = malloc(sizeof(*tables));
+    rv = tsk_table_collection_init(tables, 0);
+    check_tsk_error(rv);
+
+    /* NOTE: you must set sequence length AFTER initialization */
+    tables->sequence_length = 1.0;
+
+    /* Do your regular table operations */
+    rv = tsk_node_table_add_row(&tables->nodes, 0, 0.0, -1, -1, NULL, 0);
+    check_tsk_error(rv);
+
+    /* Initalize the tree sequence, transferring all responsibility
+     * for the table collection's memory managment
+     */
+    rv = tsk_treeseq_init(
+        &treeseq, tables, TSK_TS_INIT_BUILD_INDEXES | TSK_TAKE_OWNERSHIP);
+    check_tsk_error(rv);
+
+    /* WARNING: calling tsk_table_collection_free is now a memory error! */
+    tsk_treeseq_free(&treeseq);
+}