tskit 1.0.1__tar.gz → 1.0.2__tar.gz

tskit-1.0.2/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: tskit
+Version: 1.0.2
+Summary: The tree sequence toolkit.
+Author-email: Tskit Developers <admin@tskit.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://tskit.dev/tskit
+Project-URL: Documentation, https://tskit.dev/tskit/docs/stable
+Project-URL: Changelog, https://tskit.dev/tskit/docs/stable/changelogs.html
+Project-URL: Bug Tracker, https://github.com/tskit-dev/tskit/issues
+Project-URL: GitHub, https://github.com/tskit-dev/tskit/
+Keywords: population genetics,tree sequence,ancestral recombination graph,evolutionary tree,statistical genetics,phylogenetics,tskit
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.11
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: jsonschema>=3.0.0
+Requires-Dist: numpy>=2
+Dynamic: license-file
+
+
+The tree sequence toolkit.
+
+Tskit is a cross-platform library for the storage and analysis of large-scale
+genetic genealogy and variation data.
+Please see the `documentation <https://tskit.dev/tskit/docs/stable/>`_
+for further details.
+
+Tskit is highly portable, and provides a number of
+`installation options <https://tskit.dev/tskit/docs/stable/installation.html>`_.

{tskit-1.0.1 → tskit-1.0.2}/_tskitmodule.c

@@ -36,10 +36,10 @@
 #define NPY_NO_DEPRECATED_API NPY_2_0_API_VERSION
 #undef NPY_FEATURE_VERSION
 #define NPY_FEATURE_VERSION NPY_2_0_API_VERSION
-#define HAVE_NUMPY_2 1
+#define HAVE_NUMPY_2        1
 #else
 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
-#define HAVE_NUMPY_2 0
+#define HAVE_NUMPY_2          0
 #endif
 #include <numpy/arrayobject.h>
 
@@ -49,7 +49,7 @@
 #include "kastore.h"
 #include "tskit.h"
 
-#define SET_COLS 0
+#define SET_COLS    0
 #define APPEND_COLS 1
 
 /* TskitException is the superclass of all exceptions that can be thrown by
@@ -6210,21 +6210,17 @@ TreeSequence_decode_alignments(TreeSequence *self, PyObject *args, PyObject *kwd
     nodes = PyArray_DATA(nodes_array);
 
     buf_obj = PyBytes_FromStringAndSize(
-        NULL, (Py_ssize_t)(num_nodes * (tsk_size_t)(right - left)));
+        NULL, (Py_ssize_t) (num_nodes * (tsk_size_t) (right - left)));
     if (buf_obj == NULL) {
         goto out;
     }
     buf = PyBytes_AS_STRING(buf_obj);
 
-    // clang-format off
-    Py_BEGIN_ALLOW_THREADS 
-    err = tsk_treeseq_decode_alignments(self->tree_sequence,
-        ref_seq, (tsk_size_t) ref_len, nodes, num_nodes, left, right, missing_char, buf,
-        options);
+    Py_BEGIN_ALLOW_THREADS
+    err = tsk_treeseq_decode_alignments(self->tree_sequence, ref_seq,
+        (tsk_size_t) ref_len, nodes, num_nodes, left, right, missing_char, buf, options);
     Py_END_ALLOW_THREADS
-        // clang-format on
-        if (err != 0)
-    {
+    if (err != 0) {
         handle_library_error(err);
         goto out;
     }
@@ -6337,11 +6333,12 @@ TreeSequence_genealogical_nearest_neighbours(
         goto out;
     }
 
-    Py_BEGIN_ALLOW_THREADS err = tsk_treeseq_genealogical_nearest_neighbours(
-        self->tree_sequence, PyArray_DATA(focal_array), num_focal, reference_sets,
-        reference_set_size, num_reference_sets, 0, PyArray_DATA(ret_array));
-    Py_END_ALLOW_THREADS if (err != 0)
-    {
+    Py_BEGIN_ALLOW_THREADS
+    err = tsk_treeseq_genealogical_nearest_neighbours(self->tree_sequence,
+        PyArray_DATA(focal_array), num_focal, reference_sets, reference_set_size,
+        num_reference_sets, 0, PyArray_DATA(ret_array));
+    Py_END_ALLOW_THREADS
+    if (err != 0) {
         handle_library_error(err);
         goto out;
     }
@@ -6457,11 +6454,11 @@ TreeSequence_mean_descendants(TreeSequence *self, PyObject *args, PyObject *kwds
         goto out;
     }
 
-    Py_BEGIN_ALLOW_THREADS err
-        = tsk_treeseq_mean_descendants(self->tree_sequence, reference_sets,
-            reference_set_size, num_reference_sets, 0, PyArray_DATA(ret_array));
-    Py_END_ALLOW_THREADS if (err != 0)
-    {
+    Py_BEGIN_ALLOW_THREADS
+    err = tsk_treeseq_mean_descendants(self->tree_sequence, reference_sets,
+        reference_set_size, num_reference_sets, 0, PyArray_DATA(ret_array));
+    Py_END_ALLOW_THREADS
+    if (err != 0) {
         handle_library_error(err);
         goto out;
     }
@@ -7265,12 +7262,12 @@ TreeSequence_weighted_stat_vector_method(
     if (result_array == NULL) {
         goto out;
     }
-    Py_BEGIN_ALLOW_THREADS err
-        = method(self->tree_sequence, w_shape[1], PyArray_DATA(weights_array),
-            num_windows, PyArray_DATA(windows_array), num_focal_nodes,
-            PyArray_DATA(focal_nodes_array), PyArray_DATA(result_array), options);
-    Py_END_ALLOW_THREADS if (err != 0)
-    {
+    Py_BEGIN_ALLOW_THREADS
+    err = method(self->tree_sequence, w_shape[1], PyArray_DATA(weights_array),
+        num_windows, PyArray_DATA(windows_array), num_focal_nodes,
+        PyArray_DATA(focal_nodes_array), PyArray_DATA(result_array), options);
+    Py_END_ALLOW_THREADS
+    if (err != 0) {
         handle_library_error(err);
         goto out;
     }
@@ -7492,18 +7489,12 @@ TreeSequence_divergence_matrix(TreeSequence *self, PyObject *args, PyObject *kwd
         options |= TSK_STAT_SPAN_NORMALISE;
     }
 
-    // clang-format off
     Py_BEGIN_ALLOW_THREADS
-    err = tsk_treeseq_divergence_matrix(
-        self->tree_sequence,
-        num_sample_sets, sample_set_sizes, sample_sets,
-        num_windows, PyArray_DATA(windows_array),
-        options, PyArray_DATA(result_array));
+    err = tsk_treeseq_divergence_matrix(self->tree_sequence, num_sample_sets,
+        sample_set_sizes, sample_sets, num_windows, PyArray_DATA(windows_array), options,
+        PyArray_DATA(result_array));
     Py_END_ALLOW_THREADS
-        // clang-format on
-        /* Clang-format insists on doing this in spite of the "off" instruction above */
-        if (err != 0)
-    {
+    if (err != 0) {
         handle_library_error(err);
         goto out;
     }
@@ -8035,17 +8026,13 @@ TreeSequence_ld_matrix(TreeSequence *self, PyObject *args, PyObject *kwds,
         goto out;
     }
 
-    // clang-format off
     Py_BEGIN_ALLOW_THREADS
     err = method(self->tree_sequence, num_sample_sets,
         PyArray_DATA(sample_set_sizes_array), PyArray_DATA(sample_sets_array),
         result_dim[0], row_sites_parsed, row_positions_parsed, result_dim[1],
         col_sites_parsed, col_positions_parsed, options, PyArray_DATA(result_matrix));
     Py_END_ALLOW_THREADS
-        // clang-format on
-
-        if (err != 0)
-    {
+    if (err != 0) {
         handle_library_error(err);
         goto out;
     }
@@ -8218,7 +8205,6 @@ TreeSequence_k_way_ld_matrix(TreeSequence *self, PyObject *args, PyObject *kwds,
         goto out;
     }
 
-    // clang-format off
     Py_BEGIN_ALLOW_THREADS
     err = method(self->tree_sequence, num_sample_sets,
         PyArray_DATA(sample_set_sizes_array), PyArray_DATA(sample_sets_array),
@@ -8226,9 +8212,7 @@ TreeSequence_k_way_ld_matrix(TreeSequence *self, PyObject *args, PyObject *kwds,
         row_sites_parsed, row_positions_parsed, result_dim[1], col_sites_parsed,
         col_positions_parsed, options, PyArray_DATA(result_matrix));
     Py_END_ALLOW_THREADS
-        // clang-format on
-        if (err != 0)
-    {
+    if (err != 0) {
         handle_library_error(err);
         goto out;
     }

{tskit-1.0.1 → tskit-1.0.2}/lib/subprojects/kastore/kastore.h

@@ -157,7 +157,7 @@ to the API or ABI are introduced, i.e., the addition of a new function.
 The library patch version. Incremented when any changes not relevant to the
 to the API or ABI are introduced, i.e., internal refactors of bugfixes.
 */
-#define KAS_VERSION_PATCH   1
+#define KAS_VERSION_PATCH   2
 /** @} */
 
 #define KAS_HEADER_SIZE             64

{tskit-1.0.1 → tskit-1.0.2}/lib/tskit/core.c

@@ -883,8 +883,8 @@ tsk_search_sorted(const double *restrict array, tsk_size_t size, double value)
             upper = mid;
         }
     }
-    offset = (int64_t)(array[lower] < value);
-    return (tsk_size_t)(lower + offset);
+    offset = (int64_t) (array[lower] < value);
+    return (tsk_size_t) (lower + offset);
 }
 
 /* Rounds the specified double to the closest multiple of 10**-num_digits. If

{tskit-1.0.1 → tskit-1.0.2}/lib/tskit/core.h

@@ -42,7 +42,7 @@ extern "C" {
 
 #ifdef __GNUC__
 #define TSK_WARN_UNUSED __attribute__((warn_unused_result))
-#define TSK_UNUSED(x) TSK_UNUSED_##x __attribute__((__unused__))
+#define TSK_UNUSED(x)   TSK_UNUSED_##x __attribute__((__unused__))
 #else
 #define TSK_WARN_UNUSED
 #define TSK_UNUSED(x) TSK_UNUSED_##x
@@ -93,11 +93,11 @@ missing data.
  * on the thread above.
  */
 typedef int64_t tsk_id_t;
-#define TSK_MAX_ID INT64_MAX - 1
+#define TSK_MAX_ID          INT64_MAX - 1
 #define TSK_ID_STORAGE_TYPE KAS_INT64
 #else
 typedef int32_t tsk_id_t;
-#define TSK_MAX_ID INT32_MAX - 1
+#define TSK_MAX_ID          INT32_MAX - 1
 #define TSK_ID_STORAGE_TYPE KAS_INT32
 #endif
 
@@ -109,7 +109,7 @@ The ``tsk_size_t`` type is an unsigned integer used for any size or count value.
 @endrst
 */
 typedef uint64_t tsk_size_t;
-#define TSK_MAX_SIZE UINT64_MAX
+#define TSK_MAX_SIZE          UINT64_MAX
 #define TSK_SIZE_STORAGE_TYPE KAS_UINT64
 
 /**
@@ -152,7 +152,7 @@ to the API or ABI are introduced, i.e., the addition of a new function.
 The library patch version. Incremented when any changes not relevant to the
 to the API or ABI are introduced, i.e., internal refactors of bugfixes.
 */
-#define TSK_VERSION_PATCH   0
+#define TSK_VERSION_PATCH   1
 /** @} */
 
 /*

{tskit-1.0.1 → tskit-1.0.2}/lib/tskit/haplotype_matching.c

@@ -572,7 +572,7 @@ static inline bool
 element_in(
     const uint64_t *restrict A, tsk_id_t u, const tsk_id_t state, tsk_size_t num_words)
 {
-    tsk_size_t index = ((tsk_size_t) u) * num_words + (tsk_size_t)(state / 64);
+    tsk_size_t index = ((tsk_size_t) u) * num_words + (tsk_size_t) (state / 64);
     return (A[index] & (1ULL << (state % 64))) != 0;
 }
 
@@ -580,7 +580,7 @@ static inline void
 set_optimal_value(
     uint64_t *restrict A, tsk_id_t u, const tsk_size_t num_words, tsk_id_t state)
 {
-    tsk_size_t index = ((tsk_size_t) u) * num_words + (tsk_size_t)(state / 64);
+    tsk_size_t index = ((tsk_size_t) u) * num_words + (tsk_size_t) (state / 64);
     tsk_bug_assert(((tsk_size_t) state) / 64 < num_words);
     A[index] |= 1ULL << (state % 64);
 }
@@ -815,7 +815,7 @@ tsk_ls_hmm_redistribute_transitions(tsk_ls_hmm_t *self)
      * iterating over the roots. See the existing parsimony implementations
      * for an example. */
     for (root = tsk_tree_get_left_root(&self->tree); root != TSK_NULL;
-         root = right_sib[root]) {
+        root = right_sib[root]) {
         stack[0].tree_node = root;
         stack[0].old_state = T_old[T_index[root]].value_index;
         stack[0].new_state
@@ -966,7 +966,7 @@ tsk_ls_hmm_run_forward(tsk_ls_hmm_t *self, int32_t *haplotype)
     }
 
     for (t_ret = tsk_tree_first(&self->tree); t_ret == TSK_TREE_OK;
-         t_ret = tsk_tree_next(&self->tree)) {
+        t_ret = tsk_tree_next(&self->tree)) {
         ret = tsk_ls_hmm_update_tree(self, TSK_DIR_FORWARD);
         if (ret != 0) {
             goto out;
@@ -1166,7 +1166,7 @@ tsk_ls_hmm_run_backward(
     }
 
     for (t_ret = tsk_tree_last(&self->tree); t_ret == TSK_TREE_OK;
-         t_ret = tsk_tree_prev(&self->tree)) {
+        t_ret = tsk_tree_prev(&self->tree)) {
         ret = tsk_ls_hmm_update_tree(self, TSK_DIR_REVERSE);
         if (ret != 0) {
             goto out;
@@ -1492,7 +1492,7 @@ tsk_compressed_matrix_decode(tsk_compressed_matrix_t *self, double *values)
     }
 
     for (t_ret = tsk_tree_first(&tree); t_ret == TSK_TREE_OK;
-         t_ret = tsk_tree_next(&tree)) {
+        t_ret = tsk_tree_next(&tree)) {
         ret = tsk_tree_get_sites(&tree, &sites, &num_tree_sites);
         if (ret != 0) {
             goto out;

{tskit-1.0.1 → tskit-1.0.2}/lib/tskit/tables.c

@@ -100,7 +100,7 @@ check_offset_overflow(tsk_size_t current_size, tsk_size_t additional_elements)
            || current_size > (max_val - additional_elements);
 }
 
-#define TSK_NUM_ROWS_UNSET ((tsk_size_t) -1)
+#define TSK_NUM_ROWS_UNSET   ((tsk_size_t) - 1)
 #define TSK_MAX_COL_NAME_LEN 64
 
 static int
@@ -8255,8 +8255,8 @@ pair_to_integer(tsk_id_t a, tsk_id_t b, tsk_size_t N)
 static inline void
 integer_to_pair(int64_t index, tsk_size_t N, tsk_id_t *a, tsk_id_t *b)
 {
-    *a = (tsk_id_t)(index / (int64_t) N);
-    *b = (tsk_id_t)(index % (int64_t) N);
+    *a = (tsk_id_t) (index / (int64_t) N);
+    *b = (tsk_id_t) (index % (int64_t) N);
 }
 
 static int64_t
@@ -8997,7 +8997,7 @@ simplifier_check_state(simplifier_t *self)
     for (j = 0; j < self->input_tables.nodes.num_rows; j++) {
         last_position = -1;
         for (list_node = self->node_mutation_list_map_head[j]; list_node != NULL;
-             list_node = list_node->next) {
+            list_node = list_node->next) {
             tsk_bug_assert(
                 self->input_tables.mutations.node[list_node->mutation] == (tsk_id_t) j);
             site = self->input_tables.mutations.site[list_node->mutation];
@@ -9028,7 +9028,7 @@ simplifier_check_state(simplifier_t *self)
         child = self->buffered_children[j];
         tsk_bug_assert(self->child_edge_map_head[child] != NULL);
         for (int_list = self->child_edge_map_head[child]; int_list != NULL;
-             int_list = int_list->next) {
+            int_list = int_list->next) {
             tsk_bug_assert(int_list->left < int_list->right);
             if (int_list->next != NULL) {
                 tsk_bug_assert(int_list->right < int_list->next->left);
@@ -9108,7 +9108,7 @@ simplifier_print_state(simplifier_t *self, FILE *out)
         child = self->buffered_children[j];
         fprintf(out, "%lld -> ", (long long) j);
         for (int_list = self->child_edge_map_head[child]; int_list != NULL;
-             int_list = int_list->next) {
+            int_list = int_list->next) {
             fprintf(out, "(%f, %f), ", int_list->left, int_list->right);
         }
         fprintf(out, "\n");
@@ -9123,7 +9123,7 @@ simplifier_print_state(simplifier_t *self, FILE *out)
         if (self->node_mutation_list_map_head[j] != NULL) {
             fprintf(out, "%lld\t-> [", (long long) j);
             for (list_node = self->node_mutation_list_map_head[j]; list_node != NULL;
-                 list_node = list_node->next) {
+                list_node = list_node->next) {
                 fprintf(out, "%lld,", (long long) list_node->mutation);
             }
             fprintf(out, "]\n");
@@ -10187,7 +10187,7 @@ simplifier_insert_input_roots(simplifier_t *self)
     const double *node_time = self->tables->nodes.time;
 
     for (input_id = 0; input_id < (tsk_id_t) self->input_tables.nodes.num_rows;
-         input_id++) {
+        input_id++) {
         x = self->ancestor_map_head[input_id];
         if (x != NULL) {
             output_id = self->node_id_map[input_id];
@@ -10736,11 +10736,11 @@ tsk_table_collection_check_individual_integrity(
 
     for (j = 0; j < (tsk_size_t) num_individuals; j++) {
         for (k = individuals.parents_offset[j]; k < individuals.parents_offset[j + 1];
-             k++) {
+            k++) {
             /* Check parent references are valid */
             if (individuals.parents[k] != TSK_NULL
                 && (individuals.parents[k] < 0
-                       || individuals.parents[k] >= num_individuals)) {
+                    || individuals.parents[k] >= num_individuals)) {
                 ret = tsk_trace_error(TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);
                 goto out;
             }
@@ -11250,20 +11250,20 @@ tsk_table_collection_equals(const tsk_table_collection_t *self,
     if (!(options & TSK_CMP_IGNORE_TABLES)) {
         ret = ret
               && tsk_individual_table_equals(
-                     &self->individuals, &other->individuals, options)
+                  &self->individuals, &other->individuals, options)
               && tsk_node_table_equals(&self->nodes, &other->nodes, options)
               && tsk_edge_table_equals(&self->edges, &other->edges, options)
               && tsk_migration_table_equals(
-                     &self->migrations, &other->migrations, options)
+                  &self->migrations, &other->migrations, options)
               && tsk_site_table_equals(&self->sites, &other->sites, options)
               && tsk_mutation_table_equals(&self->mutations, &other->mutations, options)
               && tsk_population_table_equals(
-                     &self->populations, &other->populations, options);
+                  &self->populations, &other->populations, options);
         /* TSK_CMP_IGNORE_TABLES implies TSK_CMP_IGNORE_PROVENANCE */
         if (!(options & TSK_CMP_IGNORE_PROVENANCE)) {
             ret = ret
                   && tsk_provenance_table_equals(
-                         &self->provenances, &other->provenances, options);
+                      &self->provenances, &other->provenances, options);
         }
     }
     /* TSK_CMP_IGNORE_TS_METADATA is implied by TSK_CMP_IGNORE_METADATA */
@@ -11273,19 +11273,19 @@ tsk_table_collection_equals(const tsk_table_collection_t *self,
     if (!(options & TSK_CMP_IGNORE_TS_METADATA)) {
         ret = ret
               && (self->metadata_length == other->metadata_length
-                     && self->metadata_schema_length == other->metadata_schema_length
-                     && tsk_memcmp(self->metadata, other->metadata,
-                            self->metadata_length * sizeof(char))
-                            == 0
-                     && tsk_memcmp(self->metadata_schema, other->metadata_schema,
-                            self->metadata_schema_length * sizeof(char))
-                            == 0);
+                  && self->metadata_schema_length == other->metadata_schema_length
+                  && tsk_memcmp(self->metadata, other->metadata,
+                         self->metadata_length * sizeof(char))
+                         == 0
+                  && tsk_memcmp(self->metadata_schema, other->metadata_schema,
+                         self->metadata_schema_length * sizeof(char))
+                         == 0);
     }
 
     if (!(options & TSK_CMP_IGNORE_REFERENCE_SEQUENCE)) {
         ret = ret
               && tsk_reference_sequence_equals(
-                     &self->reference_sequence, &other->reference_sequence, options);
+                  &self->reference_sequence, &other->reference_sequence, options);
     }
     return ret;
 }
@@ -12057,7 +12057,7 @@ tsk_table_collection_dumpf(
         { "format/name", (const void *) &TSK_FILE_FORMAT_NAME,
             TSK_FILE_FORMAT_NAME_LENGTH, KAS_INT8 },
         { "format/version",
-            (const void *) &(uint32_t[]){
+            (const void *) &(uint32_t[]) {
                 TSK_FILE_FORMAT_VERSION_MAJOR, TSK_FILE_FORMAT_VERSION_MINOR },
             2, KAS_UINT32 },
         { "sequence_length", (const void *) &self->sequence_length, 1, KAS_FLOAT64 },
@@ -13302,7 +13302,7 @@ tsk_table_collection_union(tsk_table_collection_t *self,
     /* Now we know the full individual map we can remap the parents of the new
      * individuals*/
     for (k = (tsk_id_t) self->individuals.parents_offset[num_individuals_self];
-         k < (tsk_id_t) self->individuals.parents_length; k++) {
+        k < (tsk_id_t) self->individuals.parents_length; k++) {
         if (self->individuals.parents[k] != TSK_NULL) {
             self->individuals.parents[k] = individual_map[self->individuals.parents[k]];
         }

{tskit-1.0.1 → tskit-1.0.2}/lib/tskit/tables.h

@@ -4607,7 +4607,7 @@ tsk_id_t tsk_table_collection_check_integrity(
 /* Undocumented methods */
 
 /* Flags for ibd_segments */
-#define TSK_IBD_STORE_PAIRS (1 << 0)
+#define TSK_IBD_STORE_PAIRS    (1 << 0)
 #define TSK_IBD_STORE_SEGMENTS (1 << 1)
 
 /* TODO be systematic about where "result" should be in the params

{tskit-1.0.1 → tskit-1.0.2}/lib/tskit/trees.c

@@ -228,7 +228,7 @@ tsk_treeseq_init_individuals(tsk_treeseq_t *self)
         if (ind != TSK_NULL) {
             node_array = self->individual_nodes[ind];
             tsk_bug_assert(node_array - self->individual_nodes_mem
-                           < (tsk_id_t)(total_node_refs - node_count[ind]));
+                           < (tsk_id_t) (total_node_refs - node_count[ind]));
             node_array[node_count[ind]] = node;
             node_count[ind] += 1;
         }
@@ -537,7 +537,7 @@ tsk_treeseq_init(
 
     if (tsk_treeseq_get_time_units_length(self) == strlen(TSK_TIME_UNITS_UNCALIBRATED)
         && !strncmp(tsk_treeseq_get_time_units(self), TSK_TIME_UNITS_UNCALIBRATED,
-               strlen(TSK_TIME_UNITS_UNCALIBRATED))) {
+            strlen(TSK_TIME_UNITS_UNCALIBRATED))) {
         self->time_uncalibrated = true;
     }
 out:
@@ -856,7 +856,7 @@ out:
 
 /* Stats functions */
 
-#define GET_2D_ROW(array, row_len, row) (array + (((size_t)(row_len)) * (size_t)(row)))
+#define GET_2D_ROW(array, row_len, row) (array + (((size_t) (row_len)) * (size_t) (row)))
 
 static inline double *
 GET_3D_ROW(double *base, tsk_size_t num_nodes, tsk_size_t output_dim,
@@ -899,7 +899,7 @@ tsk_treeseq_genealogical_nearest_neighbours(const tsk_treeseq_t *self,
     /* TODO It's probably not worth bothering with the int16_t here. */
     int16_t k, focal_reference_set;
     /* We use the K'th element of the array for the total. */
-    const int16_t K = (int16_t)(num_reference_sets + 1);
+    const int16_t K = (int16_t) (num_reference_sets + 1);
     tsk_size_t num_nodes = self->tables->nodes.num_rows;
     const tsk_id_t num_edges = (tsk_id_t) self->tables->edges.num_rows;
     const tsk_id_t *restrict I = self->tables->indexes.edge_insertion_order;
@@ -1082,7 +1082,7 @@ tsk_treeseq_mean_descendants(const tsk_treeseq_t *self,
     tsk_size_t j;
     int32_t k;
     /* We use the K'th element of the array for the total. */
-    const int32_t K = (int32_t)(num_reference_sets + 1);
+    const int32_t K = (int32_t) (num_reference_sets + 1);
     tsk_size_t num_nodes = self->tables->nodes.num_rows;
     const tsk_id_t num_edges = (tsk_id_t) self->tables->edges.num_rows;
     const tsk_id_t *restrict I = self->tables->indexes.edge_insertion_order;
@@ -1742,7 +1742,7 @@ tsk_treeseq_site_general_stat(const tsk_treeseq_t *self, tsk_size_t state_dim,
 
         /* Update the sites */
         for (tree_site = 0; tree_site < self->tree_sites_length[tree_index];
-             tree_site++) {
+            tree_site++) {
             site = self->tree_sites[tree_index] + tree_site;
             ret = compute_general_stat_site_result(site, state, state_dim, result_dim, f,
                 f_params, total_weight, polarised, site_result);
@@ -2882,7 +2882,7 @@ positions_to_tree_indexes(const tsk_treeseq_t *ts, const double *positions,
         }
         (*tree_indexes)[i] = tree_index;
     }
-    tsk_bug_assert(tree_index <= (tsk_id_t)(num_trees - 1));
+    tsk_bug_assert(tree_index <= (tsk_id_t) (num_trees - 1));
 
 out:
     return ret;
@@ -2896,7 +2896,7 @@ get_index_counts(
     tsk_id_t index = indexes[0];
     tsk_size_t count, i;
     tsk_size_t *counts = tsk_calloc(
-        (tsk_size_t)(indexes[num_indexes ? num_indexes - 1 : 0] - indexes[0] + 1),
+        (tsk_size_t) (indexes[num_indexes ? num_indexes - 1 : 0] - indexes[0] + 1),
         sizeof(*counts));
     if (counts == NULL) {
         ret = tsk_trace_error(TSK_ERR_NO_MEMORY);
@@ -3315,7 +3315,7 @@ tsk_treeseq_two_branch_count_stat(const tsk_treeseq_t *self, tsk_size_t state_di
         }
         col = 0;
         for (c = 0; c < (col_indexes[n_cols ? n_cols - 1 : 0] - col_indexes[0] + 1);
-             c++) {
+            c++) {
             ret = advance_collect_edges(&r_state, (tsk_id_t) c + col_indexes[0]);
             if (ret != 0) {
                 goto out;
@@ -3621,7 +3621,7 @@ tsk_treeseq_site_allele_frequency_spectrum(const tsk_treeseq_t *self,
 
         /* Update the sites */
         for (tree_site = 0; tree_site < self->tree_sites_length[tree_index];
-             tree_site++) {
+            tree_site++) {
             site = self->tree_sites[tree_index] + tree_site;
             while (windows[window_index + 1] <= site->position) {
                 window_index++;
@@ -4566,8 +4566,8 @@ D2_unbiased_summary_func(tsk_size_t state_dim, const double *state,
         double w_ab = n - (w_AB + w_Ab + w_aB);
         result[j] = (1 / (n * (n - 1) * (n - 2) * (n - 3)))
                     * ((w_aB * w_aB * (w_Ab - 1) * w_Ab)
-                          + ((w_ab - 1) * w_ab * (w_AB - 1) * w_AB)
-                          - (w_aB * w_Ab * (w_Ab + (2 * w_ab * w_AB) - 1)));
+                        + ((w_ab - 1) * w_ab * (w_AB - 1) * w_AB)
+                        - (w_aB * w_Ab * (w_Ab + (2 * w_ab * w_AB) - 1)));
     }
     return 0;
 }
@@ -4604,8 +4604,8 @@ Dz_unbiased_summary_func(tsk_size_t state_dim, const double *state,
         result[j] = (1 / (n * (n - 1) * (n - 2) * (n - 3)))
                     * ((((w_AB * w_ab) - (w_Ab * w_aB)) * (w_aB + w_ab - w_AB - w_Ab)
                            * (w_Ab + w_ab - w_AB - w_aB))
-                          - ((w_AB * w_ab) * (w_AB + w_ab - w_Ab - w_aB - 2))
-                          - ((w_Ab * w_aB) * (w_Ab + w_aB - w_AB - w_ab - 2)));
+                        - ((w_AB * w_ab) * (w_AB + w_ab - w_Ab - w_aB - 2))
+                        - ((w_Ab * w_aB) * (w_Ab + w_aB - w_AB - w_ab - 2)));
     }
     return 0;
 }
@@ -4639,11 +4639,10 @@ pi2_unbiased_summary_func(tsk_size_t state_dim, const double *state,
         double w_Ab = state_row[1];
         double w_aB = state_row[2];
         double w_ab = n - (w_AB + w_Ab + w_aB);
-        result[j]
-            = (1 / (n * (n - 1) * (n - 2) * (n - 3)))
-              * (((w_AB + w_Ab) * (w_aB + w_ab) * (w_AB + w_aB) * (w_Ab + w_ab))
-                    - ((w_AB * w_ab) * (w_AB + w_ab + (3 * w_Ab) + (3 * w_aB) - 1))
-                    - ((w_Ab * w_aB) * (w_Ab + w_aB + (3 * w_AB) + (3 * w_ab) - 1)));
+        result[j] = (1 / (n * (n - 1) * (n - 2) * (n - 3)))
+                    * (((w_AB + w_Ab) * (w_aB + w_ab) * (w_AB + w_aB) * (w_Ab + w_ab))
+                        - ((w_AB * w_ab) * (w_AB + w_ab + (3 * w_Ab) + (3 * w_aB) - 1))
+                        - ((w_Ab * w_aB) * (w_Ab + w_aB + (3 * w_AB) + (3 * w_ab) - 1)));
     }
     return 0;
 }
@@ -7784,7 +7783,7 @@ tsk_tree_map_mutations(tsk_tree_t *self, int32_t *genotypes,
             ret = tsk_trace_error(TSK_ERR_BAD_ANCESTRAL_STATE);
             goto out;
         } else if (ancestral_state >= num_alleles) {
-            num_alleles = (int32_t)(ancestral_state + 1);
+            num_alleles = (int32_t) (ancestral_state + 1);
         }
     }
 
@@ -7882,8 +7881,8 @@ kc_vectors_alloc(kc_vectors *self, tsk_id_t n)
 
     self->n = n;
     self->N = (n * (n - 1)) / 2;
-    self->m = tsk_calloc((size_t)(self->N + self->n), sizeof(*self->m));
-    self->M = tsk_calloc((size_t)(self->N + self->n), sizeof(*self->M));
+    self->m = tsk_calloc((size_t) (self->N + self->n), sizeof(*self->m));
+    self->M = tsk_calloc((size_t) (self->N + self->n), sizeof(*self->M));
     if (self->m == NULL || self->M == NULL) {
         ret = tsk_trace_error(TSK_ERR_NO_MEMORY);
         goto out;
@@ -10739,14 +10738,14 @@ tsk_matvec_calculator_run(tsk_matvec_calculator_t *self)
     while (m < self->num_windows) {
         if (valid && self->position == tree_pos.interval.left) {
             for (k = (tsk_size_t) tree_pos.out.start;
-                 k != (tsk_size_t) tree_pos.out.stop; k++) {
+                k != (tsk_size_t) tree_pos.out.stop; k++) {
                 e = out_order[k];
                 p = edge_parent[e];
                 c = edge_child[e];
                 tsk_matvec_calculator_remove_edge(self, p, c);
             }
             for (j = (tsk_size_t) tree_pos.in.start; j != (tsk_size_t) tree_pos.in.stop;
-                 j++) {
+                j++) {
                 e = in_order[j];
                 p = edge_parent[e];
                 c = edge_child[e];

{tskit-1.0.1 → tskit-1.0.2}/lib/tskit/trees.h

@@ -663,7 +663,7 @@ sequence.
 @endrst
 
 @param self A pointer to a tsk_treeseq_t object.
-@return Returns a pointer to the time units.
+@return Returns a pointer to the null-terminated file uuid.
 */
 const char *tsk_treeseq_get_file_uuid(const tsk_treeseq_t *self);